(32.53279579064663, 0.0, E3M, ---)
ERROR: ArgumentError: Converting an instance of ReverseDiff.TrackedReal{Float64, Float64, Nothing} to Float64 is not defined. Please use `ReverseDiff.value` instead.
Stacktrace:
[1] convert(#unused#::Type{Float64}, t::ReverseDiff.TrackedReal{Float64, Float64, Nothing})
@ ReverseDiff ~/.julia/packages/ReverseDiff/Zu4v6/src/tracked.jl:261
[2] setindex!(A::Vector{Float64}, x::ReverseDiff.TrackedReal{Float64, Float64, Nothing}, i1::Int64)
@ Base ./array.jl:969
[3] tbnn_opt(σ::ReverseDiff.TrackedArray{Float64, Float64, 2, SizedMatrix{3, 3,
...
```
```julia
function dudt_univ_opt!(du, σ, p, t, gradv, model_univ, model_weights)
# the parameters are [NN parameters, ODE parameters)
η0, τ = @view p[end-1 : end]
# SizeMatrix wraps an array of known size to increase efficiency. Not static.
∇v = SizedMatrix{3,3}([0. 0. 0. ; gradv(t) 0. 0. ; 0. 0. 0.]) # ERROR with gradv ???
D = 0.5 .* (∇v .+ transpose(∇v))
T1 = (η0/τ) .* D
T2 = (transpose(∇v) * σ) .+ (σ * ∇v)
# Run stress/strain through a Tensor-Base Neural Network (TBNN)
# Change tbnn to read D
F = tbnn_opt(σ, D, model_weights, model_univ, t)
du .= F # TEMPORARY to SIMPLIFY the code
end
function tbnn_opt(σ, D, model_weights, model_univ, t)
# Compute elements of the tensor basis
I = SA[1. 0. 0.; 0. 1. 0.; 0. 0. 1.]
# Compute the integrity basis from scalar invariants. Traces.
λ = zeros(2) # must be mutale
println("σ: ", σ)
println("tr(σ): ", tr(σ))
λ[1] = tr(σ)
λ[2] = 3
g = re(model_weights)(λ)
println("==> g: ", g) # should be a Vector
F = g[1] .* I .+ g[2] .* σ
println("==> F: ", F)
return F
end
# Neural network
model_univ = Flux.Chain(Flux.Dense(2, 8, tanh),
Flux.Dense(8, 2))
p_model, re = Flux.destructure(model_univ)
```
and the processing that leads to the error, namely the last line. The code is to complete. I can add more if necessary. It would be nice to simply use an attachment.
```julia
# Continutation training loop
adtype = Optimization.AutoZygote()
klist = [1,1]
trajectory = klist[1]
loss_fn(θ) = loss_univ([θ; p_system], protocols[klist], tspans[klist], σ0, σ12_all, trajectory, model_univ, model_weights)
cb_fun(θ, l) = callback(θ, l)
optf = Optimization.OptimizationFunction((x,p) -> loss_fn(x), adtype)
optprob = Optimization.OptimizationProblem(optf, θi)
result_univ = Optimization.solve(optprob, Optimisers.AMSGrad(), callback=cb_fun, maxiters=max_nb_iter)
```
---
### Author:  [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)
#### Post date: [May 5, 2023, 9:30pm UTC](https://discourse.julialang.org/t/array-could-not-broadcast-to-match-destination-in-solve/98397/5 "2023-05-05T21:30:20Z")
`λ = zeros(2) # must be mutale` will make it Float64 when it shouldn’t be.
`λ = similar(σ, (2,))` is what you want.
---
### Author:  [@erlebach](https://discourse.julialang.org/u/erlebach)
#### Post date: [May 6, 2023, 3:26am UTC](https://discourse.julialang.org/t/array-could-not-broadcast-to-match-destination-in-solve/98397/6 "2023-05-06T03:26:27Z")
Thank you, Chris. I made the change you suggested (which I never would have guessed), and got a setIndex error. I fixed that by changing the definition of the identity matrix from a 3x3 StaticArray to a 3x3 SizedArray. Why would I have to do this? Basically, `g[2]*I` created a problem when I was a static array. Why would that be?
Here is the code:
```julia
function tbnn_opt(σ, D, model_weights, model_univ, t)
# Compute elements of the tensor basis
# I = SA[1. 0. 0.; 0. 1. 0.; 0. 0. 1.] # Should work but doesn't
I = SizedMatrix{3,3}([1. 0. 0.; 0. 1. 0.; 0. 0. 1.])
# Compute the integrity basis from scalar invariants. Traces.
# λ = zeros(2) # must be mutale
# Important to use similar() to ensure the same type of σ, which can change
λ = similar(σ, (2,)) # must be mutable and the same type of σ
λ[1] = tr(σ)
λ[2] = 3
g = re(model_weights)(λ)
F = g[1] .* I .+ g[2] .* σ
return F
end
```
---
### Author:  [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)
#### Post date: [May 6, 2023, 4:39am UTC](https://discourse.julialang.org/t/array-could-not-broadcast-to-match-destination-in-solve/98397/7 "2023-05-06T04:39:50Z")
Is this on the new patch?
---
### Author:  [@erlebach](https://discourse.julialang.org/u/erlebach)
#### Post date: [May 6, 2023, 11:06am UTC](https://discourse.julialang.org/t/array-could-not-broadcast-to-match-destination-in-solve/98397/8 "2023-05-06T11:06:05Z")
No. The code ran with Tsit5 and had the issue I posted.
I will now try the new patch.
---
### Author:  [@erlebach](https://discourse.julialang.org/u/erlebach)
#### Post date: [May 6, 2023, 4:04pm UTC](https://discourse.julialang.org/t/array-could-not-broadcast-to-match-destination-in-solve/98397/9 "2023-05-06T16:04:55Z")
Hi @ChrisRackauckas ,
I ran `Rodas4` with the new patch and it work. However (I could post another topic), look at this src:
```julia
function tbnn_opt(σ, D, model_weights, model_univ, t)
# Compute elements of the tensor basis
I = SA[1. 0. 0.; 0. 1. 0.; 0. 0. 1.] # Should work
# I = SizedMatrix{3,3}([1. 0. 0.; 0. 1. 0.; 0. 0. 1.])
λ = similar(σ, (2,)) # must be mutable and the same type of σ
λ[1] = tr(σ)
λ[2] = 3
g = re(model_weights)(λ)
F = g[1] .* I .+ g[2] .* σ
return F
end
```
Using `Rodas4` and a definition of the identity matrix `I` as a mutable array using` SizedMatrix`, the code works. However, if the identity matrix is defined as a static array, I get an error (first few lines of an extremely long trace):
```julia
ERROR: setindex!(::SMatrix{3, 3, Float64, 9}, value, ::Int) is not defined.
Hint: Use `MArray` or `SizedArray` to create a mutable static array
Stacktrace:
[1] error(s::String)
@ Base ./error.jl:35
[2] setindex!(a::SMatrix{3, 3, Float64, 9}, value::Float64, i::Int64)
@ StaticArrays ~/.julia/packages/StaticArrays/VLqRb/src/indexing.jl:3
[3] macro expansion
@ ~/.julia/packages/StaticArrays/VLqRb/src/broadcast.jl:160 [inlined]
[4] _broadcast!
```
I don’t understand why that should because the identity never changes, and the expression `g[1] .* I` should work regardless of the type of `g[1]`. When `g[1]` is of type `ForwardDiff`, there is no issue. the issue occurs when `g[1]` is of type `ReverseDiff`, see below:
```julia
==> g: ForwardDiff.Dual{ForwardDiff.Tag{DiffEqBase.OrdinaryDiffEqTag, Float64}, Float64, 9}[Dual{ForwardDiff.Tag{DiffEqBase.OrdinaryDiffEqTag, Float64}}(-0.9629427516671772,-0.003012227512831078,0.0,0.0,0.0,-0.003012227512831078,0.0,0.0,0.0,-0.003012227512831078), Dual{ForwardDiff.Tag{DiffEqBase.OrdinaryDiffEqTag, Float64}}(0.5011892925377939,0.1570962334407297,0.0,0.0,0.0,0.1570962334407297,0.0,0.0,0.0,0.1570962334407297)]
==> g: Float32[-0.9629427, 0.50118923]
==> g: Float32[-0.9629815, 0.5026771]
==> g: Float32[-0.96296215, 0.50202286]
==> g: Float32[-0.96303296, 0.5039894]
==> g: Float32[-0.9632064, 0.5069435]
==> g: Float32[-0.96320677, 0.50695294]
==> g: ReverseDiff.TrackedReal{Float64, Float64, Nothing}[TrackedReal<6SM>(-0.9632086547532805, 0.0, KFo, ---), TrackedReal(0.5069759643583189, 0.0, KFo, ---)]
ERROR: setindex!(::SMatrix{3, 3, Float64, 9}, value, ::Int) is not defined.
Hint: Use `MArray` or `SizedArray` to create a mutable static array
Stacktrace:
```
I feel that the type structure of Julia gets so complex that as packages keep extending, it becomes harder and harder to ensure that all type combinations are taken into account, especially if people do not define their packages with the highest level of Array abstractions. But that is a discussion for another time 🙂 .