# Example for integro-differential equation with NeuralPDE does not run

**URL:** <https://discourse.julialang.org/t/example-for-integro-differential-equation-with-neuralpde-does-not-run/104603>\
**Category:** Modelling & Simulations\
**Created:** [October 5, 2023, 8:51am UTC](https://discourse.julialang.org/t/example-for-integro-differential-equation-with-neuralpde-does-not-run/104603 "2023-10-05T08:51:33Z")\
**Posts on this page:** 3\
**Page:** 1

<div class="post-metadata">

**Author:** ![TommasoStentella](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tommasostentella/32/202245_2.png) [@TommasoStentella](https://discourse.julialang.org/u/TommasoStentella)\
**Post date:** [October 5, 2023, 8:51am UTC](https://discourse.julialang.org/t/example-for-integro-differential-equation-with-neuralpde-does-not-run/104603/1 "2023-10-05T08:51:33Z")

</div>

I am trying to use NeuralPDE for solving an integro-differential equation with the aim of later embedding a neural network in it. To begin with, I tried the example I found in the documentation, but it gives me an error:

```julia
using NeuralPDE, Flux, ModelingToolkit, Optimization, OptimizationOptimJL, DomainSets
import ModelingToolkit: Interval, infimum, supremum

@parameters t
@variables i(..)
Di = Differential(t)
Ii = Integral(t in DomainSets.ClosedInterval(0, t))
eq = Di(i(t)) + 2 * i(t) + 5 * Ii(i(t)) ~ 1
bcs = [i(0.0) ~ 0.0]
domains = [t ∈ Interval(0.0, 2.0)]
chain = Chain(Dense(1, 15, Flux.σ), Dense(15, 1)) |> f64

strategy_ = GridTraining(0.05)
discretization = PhysicsInformedNN(chain,
                                   strategy_)
@named pde_system = PDESystem(eq, bcs, domains, [t], [i(t)])
prob = NeuralPDE.discretize(pde_system, discretization)
callback = function (p, l)
    println("Current loss is: $l")
    return false
end
res = Optimization.solve(prob, BFGS(); callback = callback, maxiters = 100)

```

```julia
DimensionMismatch: array with ndims(x) == 2 > 0 cannot have dx::Number

Stacktrace:
  [1] (::Cubature.var"#17#18"{Bool, Bool, Int64, Float64, Float64, Int64, Int32, Ptr{Nothing}, Cubature.IntegrandData{IntegralsCubature.var"#7#15"{IntegralProblem{false, Vector{Float64}, IntegralsZygoteExt.var"#14#23"{Float64, Integrals.IntegralCache{false, NeuralPDE.var"#integrand_#286"{Vector{Float64}, NeuralPDE.var"#12#13", NeuralPDE.Phi{Optimisers.Restructure{Chain{Tuple{Dense{typeof(σ), Matrix{Float64}, Vector{Float64}}, Dense{typeof(identity), Matrix{Float64}, Vector{Float64}}}}, NamedTuple{(:layers,), Tuple{Tuple{NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}}}}}, Nothing}, Vector{Int64}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:cord, Symbol("##θ#293"), :phi, :derivative, :integral, :u, :p), NeuralPDE.var"#_RGF_ModTag", NeuralPDE.var"#_RGF_ModTag", (0xd0887b84, 0x430aacf6, 0x16011867, 0xdd06f795, 0xbb666625), Expr}, typeof(NeuralPDE.numeric_derivative)}, Vector{Float64}, Vector{Float64}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, IntegralsCubature.CubatureJLh, Integrals.ReCallVJP{Integrals.ZygoteVJP}, Base.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, Nothing}}, Vector{Float64}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, Vector{Float64}}}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Int64})()
    @ Cubature ~/.julia/packages/Cubature/5zwuu/src/Cubature.jl:215
[2] disable_sigint
    @ ./c.jl:473 [inlined]
  [3] cubature(xscalar::Bool, fscalar::Bool, vectorized::Bool, padaptive::Bool, fdim::Int64, f::IntegralsCubature.var"#7#15"{IntegralProblem{false, Vector{Float64}, IntegralsZygoteExt.var"#14#23"{Float64, Integrals.IntegralCache{false, NeuralPDE.var"#integrand_#286"{Vector{Float64}, NeuralPDE.var"#12#13", NeuralPDE.Phi{Optimisers.Restructure{Chain{Tuple{Dense{typeof(σ), Matrix{Float64}, Vector{Float64}}, Dense{typeof(identity), Matrix{Float64}, Vector{Float64}}}}, NamedTuple{(:layers,), Tuple{Tuple{NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}}}}}, Nothing}, Vector{Int64}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:cord, Symbol("##θ#293"), :phi, :derivative, :integral, :u, :p), NeuralPDE.var"#_RGF_ModTag", NeuralPDE.var"#_RGF_ModTag", (0xd0887b84, 0x430aacf6, 0x16011867, 0xdd06f795, 0xbb666625), Expr}, typeof(NeuralPDE.numeric_derivative)}, Vector{Float64}, Vector{Float64}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, IntegralsCubature.CubatureJLh, Integrals.ReCallVJP{Integrals.ZygoteVJP}, Base.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, Nothing}}, Vector{Float64}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, Vector{Float64}}, xmin_::Vector{Float64}, xmax_::Vector{Float64}, reqRelError::Float64, reqAbsError::Float64, maxEval::Int64, error_norm::Int32)
    @ Cubature ~/.julia/packages/Cubature/5zwuu/src/Cubature.jl:169
  [4] #hcubature#21
    @ ~/.julia/packages/Cubature/5zwuu/src/Cubature.jl:227 [inlined]
  [5] hcubature
    @ ~/.julia/packages/Cubature/5zwuu/src/Cubature.jl:227 [inlined]
  [6] __solvebp_call(prob::IntegralProblem{false, Vector{Float64}, IntegralsZygoteExt.var"#14#23"{Float64, Integrals.IntegralCache{false, NeuralPDE.var"#integrand_#286"{Vector{Float64}, NeuralPDE.var"#12#13", NeuralPDE.Phi{Optimisers.Restructure{Chain{Tuple{Dense{typeof(σ), Matrix{Float64}, Vector{Float64}}, Dense{typeof(identity), Matrix{Float64}, Vector{Float64}}}}, NamedTuple{(:layers,), Tuple{Tuple{NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}}}}}, Nothing}, Vector{Int64}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:cord, Symbol("##θ#293"), :phi, :derivative, :integral, :u, :p), NeuralPDE.var"#_RGF_ModTag", NeuralPDE.var"#_RGF_ModTag", (0xd0887b84, 0x430aacf6, 0x16011867, 0xdd06f795, 0xbb666625), Expr}, typeof(NeuralPDE.numeric_derivative)}, Vector{Float64}, Vector{Float64}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, IntegralsCubature.CubatureJLh, Integrals.ReCallVJP{Integrals.ZygoteVJP}, Base.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, Nothing}}, Vector{Float64}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, alg::IntegralsCubature.CubatureJLh, sensealg::Integrals.ReCallVJP{Integrals.ZygoteVJP}, lb::Vector{Float64}, ub::Vector{Float64}, p::Vector{Float64}; reltol::Float64, abstol::Float64, maxiters::Int64)
    @ IntegralsCubature ~/.julia/packages/IntegralsCubature/OPTxp/src/IntegralsCubature.jl:138
  [7] __solvebp_call
    @ ~/.julia/packages/IntegralsCubature/OPTxp/src/IntegralsCubature.jl:50 [inlined]
  [8] #__solvebp_call#4
    @ ~/.julia/packages/Integrals/d3rQd/src/common.jl:95 [inlined]
  [9] (::IntegralsZygoteExt.var"#quadrature_adjoint#16"{Base.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, Integrals.IntegralCache{false, NeuralPDE.var"#integrand_#286"{Vector{Float64}, NeuralPDE.var"#12#13", NeuralPDE.Phi{Optimisers.Restructure{Chain{Tuple{Dense{typeof(σ), Matrix{Float64}, Vector{Float64}}, Dense{typeof(identity), Matrix{Float64}, Vector{Float64}}}}, NamedTuple{(:layers,), Tuple{Tuple{NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}}}}}, Nothing}, Vector{Int64}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:cord, Symbol("##θ#293"), :phi, :derivative, :integral, :u, :p), NeuralPDE.var"#_RGF_ModTag", NeuralPDE.var"#_RGF_ModTag", (0xd0887b84, 0x430aacf6, 0x16011867, 0xdd06f795, 0xbb666625), Expr}, typeof(NeuralPDE.numeric_derivative)}, Vector{Float64}, Vector{Float64}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, IntegralsCubature.CubatureJLh, Integrals.ReCallVJP{Integrals.ZygoteVJP}, Base.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, Nothing}, IntegralsCubature.CubatureJLh, Integrals.ReCallVJP{Integrals.ZygoteVJP}, Vector{Float64}, Vector{Float64}, Vector{Float64}})(Δ::Array{Float64, 0})
    @ IntegralsZygoteExt ~/.julia/packages/Integrals/d3rQd/ext/IntegralsZygoteExt.jl:82

```

(full stacktrace is so long I could not paste it here)

My side question would be wether it makes sense to use NeuralPDE for automated discovery of a missing term in an integro-differential equation

---

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [April 7, 2024, 12:15pm UTC](https://discourse.julialang.org/t/example-for-integro-differential-equation-with-neuralpde-does-not-run/104603/2 "2024-04-07T12:15:02Z")

</div>

@SathvikBhagavan did this get handled when we did the push for MTK v9 and fixed all of the tutorials? I believe it’s a test case?

---

<div class="post-metadata">

**Author:** ![SathvikBhagavan](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/sathvikbhagavan/32/205417_2.png) [@SathvikBhagavan](https://discourse.julialang.org/u/SathvikBhagavan)\
**Post date:** [April 7, 2024, 1:24pm UTC](https://discourse.julialang.org/t/example-for-integro-differential-equation-with-neuralpde-does-not-run/104603/3 "2024-04-07T13:24:15Z")

</div>

The tutorial uses `QuadratureTraining` and it works [Solving Integro Differential Equations · NeuralPDE.jl](https://docs.sciml.ai/NeuralPDE/dev/tutorials/integro_diff/). I am not sure why it fails with GridTraining though. I will look into it.