System of PDEs with CUDA? #410
Comments
|
That code works? |
|
@ChrisRackauckas not when you run it in the GPU, it throws a scalar indexing error. It only throws a warning when I run it in REPL |
using Flux, CUDA, DiffEqFlux
CUDA.allowscalar(false)
chain = [FastChain(FastDense(3, 16, Flux.σ), FastDense(16,16,Flux.σ), FastDense(16, 1)),
FastChain(FastDense(2, 16, Flux.σ), FastDense(16,16,Flux.σ), FastDense(16, 1))]
initθ = map(c -> CuArray(Float64.(c)), DiffEqFlux.initial_params.(chain))seems to work fine? |
|
Oh great :) |
|
I should have included a fuller example: the code works until that point, and then fails once I call Is there anything I am doing wrong here? This is the full example: @parameters t x v
@variables f(..) E(..)
Dx = Differential(x)
Dt = Differential(t)
Dv = Differential(v)
# Constants
μ_0 = 1.25663706212e-6 # N A⁻²
ε_0 = 8.8541878128e-12 # F ms⁻¹
e = 1.602176634e-19 # Coulombs
m_e = 9.10938188e-31 # Kg
v_th = sqrt(2)
# Space
domains = [t ∈ Interval(0.0, 1.0),
x ∈ Interval(0.0, 1.0),
v ∈ Interval(0.0, 1.0)]
# Integrals
Iv = Integral(v in DomainSets.ClosedInterval(-1, 1))
# Equations
eqs = [Dt(f(t,x,v)) ~ - v * Dx(f(t,x,v)) - e/m_e * E(t,x) * Dv(f(t,x,v))
Dx(E(t,x)) ~ e/ε_0 * (Iv(f(t,x,v)) - 1)]
bcs = [f(0,x,v) ~ 1/(v_th * sqrt(2π)) * exp(-v^2/(2*v_th^2)),
E(0,x) ~ e/ε_0 * (Iv(f(0,x,v)) - 1) * x,
E(t,0) ~ 0]
# Neural Network
CUDA.allowscalar(false)
chain = [FastChain(FastDense(3, 16, Flux.σ), FastDense(16,16,Flux.σ), FastDense(16, 1)),
FastChain(FastDense(2, 16, Flux.σ), FastDense(16,16,Flux.σ), FastDense(16, 1))]
initθ = GPU ? map(c -> CuArray(Float64.(c)), DiffEqFlux.initial_params.(chain)) : map(c -> Float64.(c), DiffEqFlux.initial_params.(chain))
discretization = NeuralPDE.PhysicsInformedNN(chain, QuadratureTraining(), init_params= initθ)
@named pde_system = PDESystem(eqs, bcs, domains, [t,x,v], [f(t,x,v), E(t,x)])
prob = SciMLBase.symbolic_discretize(pde_system, discretization)
prob = SciMLBase.discretize(pde_system, discretization)
# cb
cb = function (p,l)
println("Current loss is: $l")
return false
end
# Solve
opt = Optim.BFGS()
res = GalacticOptim.solve(prob, opt, cb = cb, maxiters=1000) # the code errors here
phi = discretization.phi |
|
BFGS fails on GPU, and the PR needs help: JuliaNLSolvers/Optim.jl#946 |
|
Think this problem still occurs. I have just get the error given below with NeuralPDE 4.0.1:
Thank you |
|
Using the latest version of Optim? |
|
I think yes. Optim.jl 1.4.1 is the latest version. This is the status report of my currect packages: ERROR: LoadError: Scalar indexing is disallowed. |
ChrisRackauckas
added a commit
to ChrisRackauckas/Optim.jl
that referenced
this issue
Nov 1, 2021
This will allow the version to be tagged JuliaRegistries/General#46769 and is required to finally get SciML/NeuralPDE.jl#410 (comment) solved.
|
It needs Optim v1.5, which was blocked because of a compat bounds issue fixed in JuliaNLSolvers/Optim.jl#959 . It should be fine on master and we'll get that tag finished ASAP. |
pkofod
pushed a commit
to JuliaNLSolvers/Optim.jl
that referenced
this issue
Nov 1, 2021
This will allow the version to be tagged JuliaRegistries/General#46769 and is required to finally get SciML/NeuralPDE.jl#410 (comment) solved.
|
I have updated Optim to 1.5.0 But result is the same :( It still gives the same error :( I really looking forward to being solved this issue :) because training is too slow :( |
|
What code is that for? And the issue was only with BFGS anyways, ADAM has always worked fine. |
I am using the code below (from julia examples): when I run the code: Might Problem be related to GalacticOptim???? ("res = GalacticOptim.solve(prob, ADAM(0.001); cb = cb, maxiters=3000)") Edit: If I use LBFGS optimizer alone without ADAM, result is the same with the error given above. |
|
@ChrisRackauckas hi, any improvement or comment 👆👆👆 |
|
That's a completely unrelated issue #267 . Did you try ADAM with QuasiRandomStrategy? |
@ChrisRackauckas yes, I have tried that. I want to emphasize that "If I use LBFGS optimizer alone without ADAM, the result is the same with the error given above." |
|
What piece of code is using scalar indexing when not using quadrature? |
|
@ChrisRackauckas This is the code I have been using and it is a test code from your git repository. |
|
@KirillZubov could you take a look? |
|
@udemirezen initθ = map(c -> Float64.(c), DiffEqFlux.initial_params.(chain)) |> gpu
typeof(initθ)
Vector{CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}} (alias for Array{CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, 1})it is required for GPU in NeuralPDE that all calc be in one format: Float32 (like in the test - NeuralPDE.jl/test/NNPDE_tests_gpu.jl Line 32 in 860972f or Float64, then need use so initial params should be float64 initθ = map(c -> CuArray(Float64.(c)), DiffEqFlux.initial_params.(chain))
Vector{CuArray{Float64, 1, CUDA.Mem.DeviceBuffer}} (alias for Array{CuArray{Float64, 1, CUDA.Mem.DeviceBuffer}, 1}) |
|
it works with all strategies except Quadrature using NeuralPDE, Flux, ModelingToolkit, GalacticOptim, Optim, DiffEqFlux
using Plots
using Quadrature,Cubature
import ModelingToolkit: Interval, infimum, supremum
using CUDA
using Random
Random.seed!(100)
CUDA.allowscalar(false)
@parameters t, x
@variables u(..), w(..)
Dxx = Differential(x)^2
Dt = Differential(t)
# Constants
a = 1
b1 = 4
b2 = 2
c1 = 3
c2 = 1
λ1 = (b1 + c2 + sqrt((b1 + c2)^2 + 4 * (b1 * c2 - b2 * c1))) / 2
λ2 = (b1 + c2 - sqrt((b1 + c2)^2 + 4 * (b1 * c2 - b2 * c1))) / 2
# Analytic solution
θ(t, x) = exp(-t) * cos(x / a)
u_analytic(t, x) = (b1 - λ2) / (b2 * (λ1 - λ2)) * exp(λ1 * t) * θ(t, x) - (b1 - λ1) / (b2 * (λ1 - λ2)) * exp(λ2 * t) * θ(t, x)
w_analytic(t, x) = 1 / (λ1 - λ2) * (exp(λ1 * t) * θ(t, x) - exp(λ2 * t) * θ(t, x))
# Second-order constant-coefficient linear parabolic system
eqs = [Dt(u(x, t)) ~ a * Dxx(u(x, t)) + b1 * u(x, t) + c1 * w(x, t),
Dt(w(x, t)) ~ a * Dxx(w(x, t)) + b2 * u(x, t) + c2 * w(x, t)]
# Boundary conditions
bcs = [u(0, x) ~ u_analytic(0, x),
w(0, x) ~ w_analytic(0, x),
u(t, 0) ~ u_analytic(t, 0),
w(t, 0) ~ w_analytic(t, 0),
u(t, 1) ~ u_analytic(t, 1),
w(t, 1) ~ w_analytic(t, 1)]
# Space and time domains
domains = [x ∈ Interval(0.0, 1.0),
t ∈ Interval(0.0, 1.0)]
# Neural network
input_ = length(domains)
n = 15
chain = [Chain(Dense(input_, n, Flux.σ), Dense(n, n, Flux.σ), Dense(n, 1)) for _ in 1:2] |> gpu
initθ = map(c -> CuArray(Float64.(c)), DiffEqFlux.initial_params.(chain))
_strategy = GridTraining(0.1)
_strategy = QuasiRandomTraining(200)
_strategy = StochasticTraining(200)
#_strategy = QuadratureTraining() not support
discretization = PhysicsInformedNN(chain, _strategy, init_params=initθ)
@named pde_system = PDESystem(eqs, bcs, domains, [t,x], [u(t,x),w(t,x)])
prob = discretize(pde_system, discretization)
sym_prob = symbolic_discretize(pde_system, discretization)
pde_inner_loss_functions = prob.f.f.loss_function.pde_loss_function.pde_loss_functions.contents
bcs_inner_loss_functions = prob.f.f.loss_function.bcs_loss_function.bc_loss_functions.contents
cb = function (p, l)
println("loss: ", l)
println("pde_losses: ", map(l_ -> l_(p), pde_inner_loss_functions))
println("bcs_losses: ", map(l_ -> l_(p), bcs_inner_loss_functions))
return false
end
println("ADAM Training...")
#flush(stdout)
res = GalacticOptim.solve(prob, ADAM(0.01); cb = cb, maxiters=10)
prob = remake(prob,u0=res.minimizer)
println("LBFGS Training...")
flush(stdout)
res = GalacticOptim.solve(prob, LBFGS(); cb = cb, maxiters=10)
prob = remake(prob,u0=res.minimizer)
println("BFGS Training...")
flush(stdout)
res = GalacticOptim.solve(prob, BFGS(); cb = cb, maxiters=10)
phi = discretization.phi |
|
but FastChain is failed with GPU system chain = [FastChain(FastDense(input_, n, Flux.σ), FastDense(n, n, Flux.σ), FastDense(n, 1)) for _ in 1:2]
initθ = map(c -> CuArray(Float64.(c)), DiffEqFlux.initial_params.(chain))type Nothing has no field buffer
Stacktrace:
[1] getproperty(x::Nothing, f::Symbol)
@ Base ./Base.jl:33
[2] unsafe_convert
@ ~/.julia/packages/CUDA/YpW0k/src/array.jl:320 [inlined]
[3] pointer
@ ~/.julia/packages/CUDA/YpW0k/src/array.jl:275 [inlined]
[4] mightalias(A::CuArray{Float64, 2, CUDA.Mem.DeviceBuffer}, B::CuArray{Float64, 2, CUDA.Mem.DeviceBuffer})
@ CUDA ~/.julia/packages/CUDA/YpW0k/src/array.jl:113
[5] unalias(dest::CuArray{Float64, 2, CUDA.Mem.DeviceBuffer}, A::CuArray{Float64, 2, CUDA.Mem.DeviceBuffer})
@ Base ./abstractarray.jl:1349
[6] broadcast_unalias
@ ./broadcast.jl:957 [inlined]
[7] preprocess
@ ./broadcast.jl:964 [inlined]
[8] preprocess_args
@ ./broadcast.jl:967 [inlined]
[9] preprocess_args
@ ./broadcast.jl:966 [inlined]
[10] preprocess
@ ./broadcast.jl:963 [inlined]
[11] copyto!
@ ~/.julia/packages/GPUArrays/3sW6s/src/host/broadcast.jl:53 [inlined]
[12] copyto!
@ ./broadcast.jl:936 [inlined]
[13] copy
@ ~/.julia/packages/GPUArrays/3sW6s/src/host/broadcast.jl:47 [inlined]
[14] materialize
@ ./broadcast.jl:883 [inlined]
[15] broadcast_preserving_zero_d
@ ./broadcast.jl:872 [inlined]
[16] *(A::Float64, B::CuArray{Float64, 2, CUDA.Mem.DeviceBuffer})
@ Base ./arraymath.jl:52
[17] #1295
@ ~/.julia/packages/ChainRules/Tj6lu/src/rulesets/Base/arraymath.jl:123 [inlined]
[18] unthunk
@ ~/.julia/packages/ChainRulesCore/7ZiwT/src/tangent_types/thunks.jl:194 [inlined]
[19] unthunk
@ ~/.julia/packages/ChainRulesCore/7ZiwT/src/tangent_types/thunks.jl:217 [inlined]
[20] wrap_chainrules_output
@ ~/.julia/packages/Zygote/AlLTp/src/compiler/chainrules.jl:104 [inlined]
[21] map
@ ./tuple.jl:215 [inlined]
[22] wrap_chainrules_output
@ ~/.julia/packages/Zygote/AlLTp/src/compiler/chainrules.jl:105 [inlined]
[23] ZBack
@ ~/.julia/packages/Zygote/AlLTp/src/compiler/chainrules.jl:204 [inlined]
[24] (::Zygote.var"#3802#back#1032"{Zygote.ZBack{ChainRules.var"#times_pullback#1297"{CuArray{Float64, 2, CUDA.Mem.DeviceBuffer}, Float64, ChainRulesCore.ProjectTo{AbstractArray, NamedTuple{(:element, :axes), Tuple{ChainRulesCore.ProjectTo{Float64, NamedTuple{(), Tuple{}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}}}, ChainRulesCore.ProjectTo{Float64, NamedTuple{(), Tuple{}}}}}})(Δ::CuArray{Float64, 2, CUDA.Mem.DeviceBuffer})
@ Zygote ~/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:67
[25] Pullback
@ ~/.julia/packages/NeuralPDE/6acEl/src/pinns_pde_solve.jl:857 [inlined]
[26] (::typeof(∂(λ)))(Δ::CuArray{Float64, 2, CUDA.Mem.DeviceBuffer})
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
[27] macro expansion
@ ~/.julia/packages/NeuralPDE/6acEl/src/pinns_pde_solve.jl:583 [inlined]
[28] macro expansion
@ ~/.julia/packages/RuntimeGeneratedFunctions/KrkGo/src/RuntimeGeneratedFunctions.jl:129 [inlined]
[29] macro expansion
@ ./none:0 [inlined]
[30] Pullback
@ ./none:0 [inlined]
[31] (::Zygote.var"#208#209"{Tuple{Tuple{Nothing}, NTuple{7, Nothing}}, typeof(∂(generated_callfunc))})(Δ::CuArray{Float64, 2, CUDA.Mem.DeviceBuffer})
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/lib/lib.jl:203
[32] #1734#back
@ ~/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:67 [inlined]
[33] Pullback
@ ~/.julia/packages/RuntimeGeneratedFunctions/KrkGo/src/RuntimeGeneratedFunctions.jl:117 [inlined]
[34] Pullback
@ ~/.julia/packages/NeuralPDE/6acEl/src/pinns_pde_solve.jl:622 [inlined]
[35] (::typeof(∂(λ)))(Δ::CuArray{Float64, 2, CUDA.Mem.DeviceBuffer})
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
[36] Pullback
@ ~/.julia/packages/NeuralPDE/6acEl/src/pinns_pde_solve.jl:909 [inlined]
[37] (::typeof(∂(λ)))(Δ::Float64)
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
[38] Pullback
@ ~/.julia/packages/NeuralPDE/6acEl/src/pinns_pde_solve.jl:1191 [inlined]
[39] (::typeof(∂(λ)))(Δ::Float64)
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
[40] #559
@ ~/.julia/packages/Zygote/AlLTp/src/lib/array.jl:211 [inlined]
[41] (::Base.var"#4#5"{Zygote.var"#559#564"})(a::Tuple{Tuple{Float64, typeof(∂(λ))}, Float64})
@ Base ./generator.jl:36
[42] iterate
@ ./generator.jl:47 [inlined]
[43] collect(itr::Base.Generator{Base.Iterators.Zip{Tuple{Vector{Tuple{Float64, Zygote.Pullback}}, Vector{Float64}}}, Base.var"#4#5"{Zygote.var"#559#564"}})
@ Base ./array.jl:678
[44] map
@ ./abstractarray.jl:2383 [inlined]
[45] (::Zygote.var"#map_back#561"{NeuralPDE.var"#351#367"{CuArray{Float64, 1, CUDA.Mem.DeviceBuffer}}, 1, Tuple{Vector{NeuralPDE.var"#299#300"{_A, CuArray{Float64, 2, CUDA.Mem.DeviceBuffer}} where _A}}, Tuple{Tuple{Base.OneTo{Int64}}}, Vector{Tuple{Float64, Zygote.Pullback}}})(Δ::FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}})
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/lib/array.jl:211
[46] (::Zygote.var"#2577#back#565"{Zygote.var"#map_back#561"{NeuralPDE.var"#351#367"{CuArray{Float64, 1, CUDA.Mem.DeviceBuffer}}, 1, Tuple{Vector{NeuralPDE.var"#299#300"{_A, CuArray{Float64, 2, CUDA.Mem.DeviceBuffer}} where _A}}, Tuple{Tuple{Base.OneTo{Int64}}}, Vector{Tuple{Float64, Zygote.Pullback}}}})(Δ::FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}})
@ Zygote ~/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:67
[47] Pullback
@ ~/.julia/packages/NeuralPDE/6acEl/src/pinns_pde_solve.jl:1191 [inlined]
[48] (::typeof(∂(λ)))(Δ::Float64)
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
[49] Pullback
@ ~/.julia/packages/NeuralPDE/6acEl/src/pinns_pde_solve.jl:1193 [inlined]
[50] (::typeof(∂(λ)))(Δ::Float64)
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
[51] Pullback
@ ~/.julia/packages/NeuralPDE/6acEl/src/pinns_pde_solve.jl:1197 [inlined]
[52] (::typeof(∂(λ)))(Δ::Float64)
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
[53] #208
@ ~/.julia/packages/Zygote/AlLTp/src/lib/lib.jl:203 [inlined]
[54] #1734#back
@ ~/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:67 [inlined]
[55] Pullback
@ ~/.julia/packages/SciMLBase/x3z0g/src/problems/basic_problems.jl:107 [inlined]
[56] (::typeof(∂(λ)))(Δ::Float64)
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
[57] #208
@ ~/.julia/packages/Zygote/AlLTp/src/lib/lib.jl:203 [inlined]
[58] #1734#back
@ ~/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:67 [inlined]
[59] Pullback
@ ~/.julia/packages/GalacticOptim/DHxE0/src/function/zygote.jl:6 [inlined]
[60] (::typeof(∂(λ)))(Δ::Float64)
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
[61] #208
@ ~/.julia/packages/Zygote/AlLTp/src/lib/lib.jl:203 [inlined]
[62] #1734#back
@ ~/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:67 [inlined]
[63] Pullback
@ ~/.julia/packages/GalacticOptim/DHxE0/src/function/zygote.jl:8 [inlined]
[64] (::typeof(∂(λ)))(Δ::Float64)
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
[65] (::Zygote.var"#55#56"{typeof(∂(λ))})(Δ::Float64)
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface.jl:41
[66] gradient(f::Function, args::CuArray{Float64, 1, CUDA.Mem.DeviceBuffer})
@ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface.jl:76
[67] (::GalacticOptim.var"#231#241"{GalacticOptim.var"#230#240"{OptimizationFunction{true, GalacticOptim.AutoZygote, NeuralPDE.var"#loss_function_#371"{NeuralPDE.var"#354#370"{NeuralPDE.var"#352#368", NeuralPDE.var"#350#366"}, Vector{NeuralPDE.var"#274#276"{FastChain{Tuple{FastDense{typeof(σ), DiffEqFlux.var"#initial_params#90"{Vector{Float32}}}, FastDense{typeof(σ), DiffEqFlux.var"#initial_params#90"{Vector{Float32}}}, FastDense{typeof(identity), DiffEqFlux.var"#initial_params#90"{Vector{Float32}}}}}, UnionAll}}, Nothing, Bool, Nothing}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing}, SciMLBase.NullParameters}})(::CuArray{Float64, 1, CUDA.Mem.DeviceBuffer}, ::CuArray{Float64, 1, CUDA.Mem.DeviceBuffer})
@ GalacticOptim ~/.julia/packages/GalacticOptim/DHxE0/src/function/zygote.jl:8
[68] macro expansion
@ ~/.julia/packages/GalacticOptim/DHxE0/src/solve/flux.jl:41 [inlined]
[69] macro expansion
@ ~/.julia/packages/GalacticOptim/DHxE0/src/utils.jl:35 [inlined]
[70] __solve(prob::OptimizationProblem{true, OptimizationFunction{true, GalacticOptim.AutoZygote, NeuralPDE.var"#loss_function_#371"{NeuralPDE.var"#354#370"{NeuralPDE.var"#352#368", NeuralPDE.var"#350#366"}, Vector{NeuralPDE.var"#274#276"{FastChain{Tuple{FastDense{typeof(σ), DiffEqFlux.var"#initial_params#90"{Vector{Float32}}}, FastDense{typeof(σ), DiffEqFlux.var"#initial_params#90"{Vector{Float32}}}, FastDense{typeof(identity), DiffEqFlux.var"#initial_params#90"{Vector{Float32}}}}}, UnionAll}}, Nothing, Bool, Nothing}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing}, CuArray{Float64, 1, CUDA.Mem.DeviceBuffer}, SciMLBase.NullParameters, Nothing, Nothing, Nothing, Nothing, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, opt::ADAM, data::Base.Iterators.Cycle{Tuple{GalacticOptim.NullData}}; maxiters::Int64, cb::Function, progress::Bool, save_best::Bool, kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
@ GalacticOptim ~/.julia/packages/GalacticOptim/DHxE0/src/solve/flux.jl:39
[71] #solve#476
@ ~/.julia/packages/SciMLBase/x3z0g/src/solve.jl:3 [inlined]
[72] top-level scope
@ In[9]:80
[73] eval
@ ./boot.jl:360 [inlined] |
|
@KirillZubov Sorry but according to your answer I checked what you said: When I investigate the objects both are Float32 as far as I see from the typeof command. But again it failed even with GridTraining. Result is : So what is wrong with this? Am I doing somthing wrong? How can i get rid of this problem? |
|
@udemirezen if you want to calculate in Float32 , description of eq and bcs also should be in Float32 - NeuralPDE.jl/test/NNPDE_tests_gpu.jl Line 32 in 860972f |
|
All that's left is #267, so closing as a duplicate of that issue. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
I tried to adapt the https://neuralpde.sciml.ai/dev/pinn/2D/ GPU tutorial to a system of PDEs and unfortunately failed. I need to turn the initθ into a CuArray but I get a warning that Scalar indexing is disallowed. What is the performant/correct way to do the mapping I am doing here with CUDA?
The text was updated successfully, but these errors were encountered: