Package evaluation to test NormalizingFlows on Julia 1.13.0-alpha2.30 (5abf758bb1*) started at 2026-01-09T10:41:00.421 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 9.37s ################################################################################ # Installation # Installing NormalizingFlows... Resolving package versions... Updating `~/.julia/environments/v1.13/Project.toml` [50e4474d] + NormalizingFlows v0.2.2 Updating `~/.julia/environments/v1.13/Manifest.toml` [47edcb42] + ADTypes v1.21.0 [621f4979] + AbstractFFTs v1.5.0 [7d9f7c33] + Accessors v0.1.43 [79e6a3ab] + Adapt v4.4.0 [66dad0bd] + AliasTables v1.1.3 [dce04be8] + ArgCheck v2.5.0 [a9b6321e] + Atomix v1.1.2 [198e06fe] + BangBang v0.4.6 [9718e550] + Baselet v0.1.1 [76274a88] + Bijectors v0.15.14 [082447d4] + ChainRules v1.72.6 [d360d2e6] + ChainRulesCore v1.26.0 [9e997f8a] + ChangesOfVariables v0.1.10 [38540f10] + CommonSolve v0.2.6 [bbf7d656] + CommonSubexpressions v0.3.1 [34da2185] + Compat v4.18.1 [a33af91c] + CompositionsBase v0.1.2 [187b0558] + ConstructionBase v1.6.0 [6add18c4] + ContextVariablesX v0.1.3 [9a962f9c] + DataAPI v1.16.0 [864edb3b] + DataStructures v0.19.3 [e2d170a0] + DataValueInterfaces v1.0.0 [244e2a9f] + DefineSingletons v0.1.2 [8bb1440f] + DelimitedFiles v1.9.1 [163ba53b] + DiffResults v1.1.0 [b552c78f] + DiffRules v1.15.1 [a0c0ee7d] + DifferentiationInterface v0.7.13 [31c24e10] + Distributions v0.25.123 [ffbed154] + DocStringExtensions v0.9.5 [f151be2c] + EnzymeCore v0.8.18 [cc61a311] + FLoops v0.2.2 [b9860ae5] + FLoopsBase v0.1.1 [1a297f60] + FillArrays v1.15.0 [587475ba] + Flux v0.16.7 [f6369f11] + ForwardDiff v1.3.1 [d9f16b24] + Functors v0.5.2 [46192b85] + GPUArraysCore v0.2.0 [076d061b] + HashArrayMappedTries v0.2.0 [2182be2a] + HeterogeneousComputing v0.2.4 [34004b35] + HypergeometricFunctions v0.3.28 [7869d1d1] + IRTools v0.4.15 [22cec73e] + InitialValues v0.3.1 [3587e190] + InverseFunctions v0.1.17 [92d709cd] + IrrationalConstants v0.2.6 [82899510] + IteratorInterfaceExtensions v1.0.0 [692b3bcd] + JLLWrappers v1.7.1 [b14d175d] + JuliaVariables v0.2.4 [63c18a36] + KernelAbstractions v0.9.39 [2ab3a3ac] + LogExpFunctions v0.3.29 [c2834f40] + MLCore v1.0.0 [7e8f7934] + MLDataDevices v1.17.0 [d8e11817] + MLStyle v0.4.17 [f1d291b0] + MLUtils v0.4.8 [1914dd2f] + MacroTools v0.5.16 [dbb5928d] + MappedArrays v0.4.3 [128add7d] + MicroCollections v0.2.0 [e1d29d7a] + Missings v1.2.0 [568f7cb4] + MonotonicSplines v0.3.3 [872c559c] + NNlib v0.9.32 [77ba4419] + NaNMath v1.1.3 [71a1bf82] + NameResolution v0.1.5 [50e4474d] + NormalizingFlows v0.2.2 [0b1bfda6] + OneHotArrays v0.2.10 [3bd65402] + Optimisers v0.4.7 [bac558e1] + OrderedCollections v1.8.1 [90014a1f] + PDMats v0.11.37 [aea7be01] + PrecompileTools v1.3.3 [21216c6a] + Preferences v1.5.1 [8162dcfd] + PrettyPrint v0.2.0 [33c8b6b6] + ProgressLogging v0.1.6 [92933f4c] + ProgressMeter v1.11.0 [43287f4e] + PtrArrays v1.3.0 [1fd47b50] + QuadGK v2.11.2 [c1ae055f] + RealDot v0.1.0 [189a3867] + Reexport v1.2.2 [ae029012] + Requires v1.3.1 [79098fc4] + Rmath v0.9.0 [f2b01f46] + Roots v2.2.10 [431bcebd] + SciMLPublic v1.0.1 [7e506255] + ScopedValues v1.5.0 [efcf1570] + Setfield v1.1.2 [605ecd9f] + ShowCases v0.1.0 [699a6c99] + SimpleTraits v0.9.5 [a2af1166] + SortingAlgorithms v1.2.2 [dc90abb0] + SparseInverseSubset v0.1.2 [276daf66] + SpecialFunctions v2.6.1 [171d559e] + SplittablesBase v0.1.15 [90137ffa] + StaticArrays v1.9.16 [1e83bf80] + StaticArraysCore v1.4.4 [10745b16] + Statistics v1.11.1 [82ae8749] + StatsAPI v1.8.0 [2913bbd2] + StatsBase v0.34.9 [4c63d2b9] + StatsFuns v1.5.2 [09ab397b] + StructArrays v0.7.2 [3783bdb8] + TableTraits v1.0.1 [bd369af6] + Tables v1.12.1 [28d57a85] + Transducers v0.4.85 [013be700] + UnsafeAtomics v0.3.0 [e88e6eb3] + Zygote v0.7.10 [700de1a5] + ZygoteRules v0.2.7 [efe28fd5] + OpenSpecFun_jll v0.5.6+0 [f50d1b31] + Rmath_jll v0.5.1+0 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [8ba89e20] + Distributed v1.11.0 [9fa8497b] + Future v1.11.0 [b77e0a4c] + InteractiveUtils v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.12.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.13.0 [56ddb016] + Logging v1.11.0 [d6f4376e] + Markdown v1.11.0 [a63ad114] + Mmap v1.11.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v1.0.0 [9e88b42a] + Serialization v1.11.0 [6462fe0b] + Sockets v1.11.0 [2f01184e] + SparseArrays v1.13.0 [f489334b] + StyledStrings v1.11.0 [4607b0f0] + SuiteSparse [fa267f1f] + TOML v1.0.3 [8dfed614] + Test v1.11.0 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.3.0+1 [4536629a] + OpenBLAS_jll v0.3.29+0 [05823500] + OpenLibm_jll v0.8.7+0 [bea87d4a] + SuiteSparse_jll v7.10.1+0 [8e850b90] + libblastrampoline_jll v5.15.0+0 Installation completed after 5.41s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 240.43s ################################################################################ # Testing # Testing NormalizingFlows Status `/tmp/jl_2dOOxu/Project.toml` [47edcb42] ADTypes v1.21.0 [76274a88] Bijectors v0.15.14 [a0c0ee7d] DifferentiationInterface v0.7.13 [31c24e10] Distributions v0.25.123 [7da242da] Enzyme v0.13.114 [587475ba] Flux v0.16.7 [f6369f11] ForwardDiff v1.3.1 [d9f16b24] Functors v0.5.2 [568f7cb4] MonotonicSplines v0.3.3 [da2b9cff] Mooncake v0.4.198 [50e4474d] NormalizingFlows v0.2.2 [3bd65402] Optimisers v0.4.7 [37e2e3b7] ReverseDiff v1.16.1 [e88e6eb3] Zygote v0.7.10 [37e2e46d] LinearAlgebra v1.13.0 [9a3f8284] Random v1.11.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_2dOOxu/Manifest.toml` [47edcb42] ADTypes v1.21.0 [621f4979] AbstractFFTs v1.5.0 [7d9f7c33] Accessors v0.1.43 [79e6a3ab] Adapt v4.4.0 [66dad0bd] AliasTables v1.1.3 [dce04be8] ArgCheck v2.5.0 [ec485272] ArnoldiMethod v0.4.0 [a9b6321e] Atomix v1.1.2 [198e06fe] BangBang v0.4.6 [9718e550] Baselet v0.1.1 [76274a88] Bijectors v0.15.14 [fa961155] CEnum v0.5.0 [082447d4] ChainRules v1.72.6 [d360d2e6] ChainRulesCore v1.26.0 [9e997f8a] ChangesOfVariables v0.1.10 [38540f10] CommonSolve v0.2.6 [bbf7d656] CommonSubexpressions v0.3.1 [34da2185] Compat v4.18.1 [a33af91c] CompositionsBase v0.1.2 [187b0558] ConstructionBase v1.6.0 [6add18c4] ContextVariablesX v0.1.3 [9a962f9c] DataAPI v1.16.0 [864edb3b] DataStructures v0.19.3 [e2d170a0] DataValueInterfaces v1.0.0 [244e2a9f] DefineSingletons v0.1.2 [8bb1440f] DelimitedFiles v1.9.1 [163ba53b] DiffResults v1.1.0 [b552c78f] DiffRules v1.15.1 [a0c0ee7d] DifferentiationInterface v0.7.13 [8d63f2c5] DispatchDoctor v0.4.26 [31c24e10] Distributions v0.25.123 [ffbed154] DocStringExtensions v0.9.5 [7da242da] Enzyme v0.13.114 [f151be2c] EnzymeCore v0.8.18 [e2ba6199] ExprTools v0.1.10 [cc61a311] FLoops v0.2.2 [b9860ae5] FLoopsBase v0.1.1 [1a297f60] FillArrays v1.15.0 [587475ba] Flux v0.16.7 [f6369f11] ForwardDiff v1.3.1 [069b7b12] FunctionWrappers v1.1.3 [d9f16b24] Functors v0.5.2 [46192b85] GPUArraysCore v0.2.0 [61eb1bfa] GPUCompiler v1.7.5 [86223c79] Graphs v1.13.3 [076d061b] HashArrayMappedTries v0.2.0 [2182be2a] HeterogeneousComputing v0.2.4 [34004b35] HypergeometricFunctions v0.3.28 [7869d1d1] IRTools v0.4.15 [d25df0c9] Inflate v0.1.5 [22cec73e] InitialValues v0.3.1 [3587e190] InverseFunctions v0.1.17 [92d709cd] IrrationalConstants v0.2.6 [82899510] IteratorInterfaceExtensions v1.0.0 [692b3bcd] JLLWrappers v1.7.1 [b14d175d] JuliaVariables v0.2.4 [63c18a36] KernelAbstractions v0.9.39 [929cbde3] LLVM v9.4.4 [2ab3a3ac] LogExpFunctions v0.3.29 [c2834f40] MLCore v1.0.0 [7e8f7934] MLDataDevices v1.17.0 [d8e11817] MLStyle v0.4.17 [f1d291b0] MLUtils v0.4.8 [1914dd2f] MacroTools v0.5.16 [dbb5928d] MappedArrays v0.4.3 [128add7d] MicroCollections v0.2.0 [e1d29d7a] Missings v1.2.0 [dbe65cb8] MistyClosures v2.1.0 [568f7cb4] MonotonicSplines v0.3.3 [da2b9cff] Mooncake v0.4.198 [872c559c] NNlib v0.9.32 [77ba4419] NaNMath v1.1.3 [71a1bf82] NameResolution v0.1.5 [50e4474d] NormalizingFlows v0.2.2 [d8793406] ObjectFile v0.5.0 [0b1bfda6] OneHotArrays v0.2.10 [3bd65402] Optimisers v0.4.7 [bac558e1] OrderedCollections v1.8.1 [90014a1f] PDMats v0.11.37 [aea7be01] PrecompileTools v1.3.3 [21216c6a] Preferences v1.5.1 [8162dcfd] PrettyPrint v0.2.0 [33c8b6b6] ProgressLogging v0.1.6 [92933f4c] ProgressMeter v1.11.0 [43287f4e] PtrArrays v1.3.0 [1fd47b50] QuadGK v2.11.2 [c1ae055f] RealDot v0.1.0 [189a3867] Reexport v1.2.2 [ae029012] Requires v1.3.1 [37e2e3b7] ReverseDiff v1.16.1 [79098fc4] Rmath v0.9.0 [f2b01f46] Roots v2.2.10 [431bcebd] SciMLPublic v1.0.1 [7e506255] ScopedValues v1.5.0 [6c6a2e73] Scratch v1.3.0 [efcf1570] Setfield v1.1.2 [605ecd9f] ShowCases v0.1.0 [699a6c99] SimpleTraits v0.9.5 [a2af1166] SortingAlgorithms v1.2.2 [dc90abb0] SparseInverseSubset v0.1.2 [276daf66] SpecialFunctions v2.6.1 [171d559e] SplittablesBase v0.1.15 [90137ffa] StaticArrays v1.9.16 [1e83bf80] StaticArraysCore v1.4.4 [10745b16] Statistics v1.11.1 [82ae8749] StatsAPI v1.8.0 [2913bbd2] StatsBase v0.34.9 [4c63d2b9] StatsFuns v1.5.2 [09ab397b] StructArrays v0.7.2 [53d494c1] StructIO v0.3.1 [3783bdb8] TableTraits v1.0.1 [bd369af6] Tables v1.12.1 [e689c965] Tracy v0.1.6 [28d57a85] Transducers v0.4.85 [013be700] UnsafeAtomics v0.3.0 [e88e6eb3] Zygote v0.7.10 [700de1a5] ZygoteRules v0.2.7 [7cc45869] Enzyme_jll v0.0.235+0 [dad2f222] LLVMExtra_jll v0.0.38+0 [ad6e5548] LibTracyClient_jll v0.13.1+0 [efe28fd5] OpenSpecFun_jll v0.5.6+0 [f50d1b31] Rmath_jll v0.5.1+0 [0dad84c5] ArgTools v1.1.2 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [8ba89e20] Distributed v1.11.0 [f43a241f] Downloads v1.7.0 [7b1f6079] FileWatching v1.11.0 [9fa8497b] Future v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.12.0 [4af54fe1] LazyArtifacts v1.11.0 [b27032c2] LibCURL v1.0.0 [76f85450] LibGit2 v1.11.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.13.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [a63ad114] Mmap v1.11.0 [ca575930] NetworkOptions v1.3.0 [44cfe95a] Pkg v1.13.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v1.0.0 [9e88b42a] Serialization v1.11.0 [6462fe0b] Sockets v1.11.0 [2f01184e] SparseArrays v1.13.0 [f489334b] StyledStrings v1.11.0 [4607b0f0] SuiteSparse [fa267f1f] TOML v1.0.3 [a4e569a6] Tar v1.10.0 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.3.0+1 [deac9b47] LibCURL_jll v8.16.0+0 [e37daf67] LibGit2_jll v1.9.1+0 [29816b5a] LibSSH2_jll v1.11.3+1 [14a3606d] MozillaCACerts_jll v2025.12.2 [4536629a] OpenBLAS_jll v0.3.29+0 [05823500] OpenLibm_jll v0.8.7+0 [458c3c95] OpenSSL_jll v3.5.4+0 [efcefdf7] PCRE2_jll v10.46.0+0 [bea87d4a] SuiteSparse_jll v7.10.1+0 [83775a58] Zlib_jll v1.3.1+2 [3161d3a3] Zstd_jll v1.5.7+1 [8e850b90] libblastrampoline_jll v5.15.0+0 [8e850ede] nghttp2_jll v1.67.1+0 [3f19e933] p7zip_jll v17.7.0+0 Testing Running tests... WARNING: Method definition delete(StructArrays.StructArray{var"#s1", N, C, I} where I where C<:Union{Tuple, NamedTuple{names, T} where T<:Tuple where names} where N where var"#s1"<:Union{Tuple, NamedTuple{names, T} where T<:Tuple where names}, Accessors.PropertyLens{fieldname} where fieldname) in module StructArraysExt at /home/pkgeval/.julia/packages/Accessors/cfsTn/ext/StructArraysExt.jl:10 overwritten in module StructArraysExt on the same line (check for duplicate calls to `include`). WARNING: Method definition set(StructArrays.StructArray{T, N, C, I} where I where C<:Union{Tuple, NamedTuple{names, T} where T<:Tuple where names} where N where T, typeof(StructArrays.components), Any) in module StructArraysExt at /home/pkgeval/.julia/packages/Accessors/cfsTn/ext/StructArraysExt.jl:14 overwritten in module StructArraysExt on the same line (check for duplicate calls to `include`). WARNING: Method definition set(StructArrays.StructArray{var"#s1", N, C, I} where I where C<:Union{Tuple, NamedTuple{names, T} where T<:Tuple where names} where N where var"#s1"<:Union{Tuple, NamedTuple{names, T} where T<:Tuple where names}, typeof(Base.propertynames), Any) in module StructArraysExt at /home/pkgeval/.julia/packages/Accessors/cfsTn/ext/StructArraysExt.jl:12 overwritten in module StructArraysExt on the same line (check for duplicate calls to `include`). WARNING: Method definition set(StructArrays.StructArray{T, N, C, I} where I where C<:Union{Tuple, NamedTuple{names, T} where T<:Tuple where names} where N where T, Accessors.PropertyLens{fieldname} where fieldname, Any) in module StructArraysExt at /home/pkgeval/.julia/packages/Accessors/cfsTn/ext/StructArraysExt.jl:6 overwritten in module StructArraysExt on the same line (check for duplicate calls to `include`). WARNING: Method definition insert(StructArrays.StructArray{var"#s1", N, C, I} where I where C<:Union{Tuple, NamedTuple{names, T} where T<:Tuple where names} where N where var"#s1"<:Union{Tuple, NamedTuple{names, T} where T<:Tuple where names}, Accessors.PropertyLens{fieldname} where fieldname, Any) in module StructArraysExt at /home/pkgeval/.julia/packages/Accessors/cfsTn/ext/StructArraysExt.jl:9 overwritten in module StructArraysExt on the same line (check for duplicate calls to `include`). ┌ Warning: Replacing module `StructArraysExt` └ @ Base loading.jl:2623 WARNING: Method definition within_gradient(AbstractArray{var"#s1", N} where N where var"#s1"<:(ForwardDiff.Dual{T, V, N} where N where V where T)) in module NNlibForwardDiffExt at /home/pkgeval/.julia/packages/NNlib/ytFya/ext/NNlibForwardDiffExt.jl:7 overwritten in module NNlibForwardDiffExt on the same line (check for duplicate calls to `include`). WARNING: Method definition within_gradient(ForwardDiff.Dual{T, V, N} where N where V where T) in module NNlibForwardDiffExt at /home/pkgeval/.julia/packages/NNlib/ytFya/ext/NNlibForwardDiffExt.jl:6 overwritten in module NNlibForwardDiffExt on the same line (check for duplicate calls to `include`). ┌ Warning: Replacing module `NNlibForwardDiffExt` └ @ Base loading.jl:2623 ┌ Warning: `MvNormal(μ::AbstractVector{<:Real}, σ::AbstractVector{<:Real})` is deprecated, use `MvNormal(μ, LinearAlgebra.Diagonal(map(abs2, σ)))` instead. │ caller = ip:0x0 └ @ Core :-1 Test Summary: | Pass Total Time variational objectives | 10 10 18.9s WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). Float32: Error During Test at /home/pkgeval/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:14 Got exception outside of a @test LLVM error: Added modules have incompatible data layouts: e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128 (module) vs e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128-ni:10:11:12:13 (jit) Stacktrace: [1] macro expansion @ ~/.julia/packages/LLVM/iza6e/src/executionengine/utils.jl:28 [inlined] [2] add! @ ~/.julia/packages/LLVM/iza6e/src/orc.jl:434 [inlined] [3] add!(mod::LLVM.Module) @ Enzyme.Compiler.JIT ~/.julia/packages/Enzyme/QsBMf/src/compiler/orcv2.jl:290 [4] _link(job::GPUCompiler.CompilerJob{<:Enzyme.Compiler.EnzymeTarget}, mod::LLVM.Module, edges::Vector{Any}, adjoint_name::String, primal_name::Union{Nothing, String}, TapeType::Any, prepost::String) @ Enzyme.Compiler ~/.julia/packages/Enzyme/QsBMf/src/compiler.jl:6688 [5] cached_compilation @ ~/.julia/packages/Enzyme/QsBMf/src/compiler.jl:6782 [inlined] [6] thunkbase(mi::Core.MethodInstance, World::UInt64, FA::Type{<:Annotation}, A::Type{<:Annotation}, TT::Type, Mode::Enzyme.API.CDerivativeMode, width::Int64, ModifiedBetween::NTuple{N, Bool} where N, ReturnPrimal::Bool, ShadowInit::Bool, ABI::Type, ErrIfFuncWritten::Bool, RuntimeActivity::Bool, StrongZero::Bool, edges::Vector{Any}) @ Enzyme.Compiler ~/.julia/packages/Enzyme/QsBMf/src/compiler.jl:6897 [7] thunk_generator(world::UInt64, source::Union{LineNumberNode, Method}, FA::Type, A::Type, TT::Type, Mode::Enzyme.API.CDerivativeMode, Width::Int64, ModifiedBetween::NTuple{N, Bool} where N, ReturnPrimal::Bool, ShadowInit::Bool, ABI::Type, ErrIfFuncWritten::Bool, RuntimeActivity::Bool, StrongZero::Bool, self::Any, fakeworld::Any, fa::Type, a::Type, tt::Type, mode::Type, width::Type, modifiedbetween::Type, returnprimal::Type, shadowinit::Type, abi::Type, erriffuncwritten::Type, runtimeactivity::Type, strongzero::Type) @ Enzyme.Compiler ~/.julia/packages/Enzyme/QsBMf/src/compiler.jl:7041 [8] autodiff_thunk @ ~/.julia/packages/Enzyme/QsBMf/src/Enzyme.jl:1001 [inlined] [9] autodiff @ ~/.julia/packages/Enzyme/QsBMf/src/Enzyme.jl:395 [inlined] [10] macro expansion @ ~/.julia/packages/Enzyme/QsBMf/src/sugar.jl:287 [inlined] [11] gradient @ ~/.julia/packages/Enzyme/QsBMf/src/sugar.jl:274 [inlined] [12] value_and_gradient(::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::DifferentiationInterfaceEnzymeExt.EnzymeGradientPrep{Tuple{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Vector{Float32}, Tuple{DifferentiationInterface.Constant{TaskLocalRNG}, DifferentiationInterface.Constant{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}}, DifferentiationInterface.Constant{Int64}}}, Nothing, Tuple{Nothing, Nothing, Nothing}}, ::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, ::Vector{Float32}, ::DifferentiationInterface.Constant{TaskLocalRNG}, ::DifferentiationInterface.Constant{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}}, ::DifferentiationInterface.Constant{Int64}) @ DifferentiationInterfaceEnzymeExt ~/.julia/packages/DifferentiationInterface/6H4dc/ext/DifferentiationInterfaceEnzymeExt/reverse_onearg.jl:253 [13] _value_and_gradient(::Function, ::DifferentiationInterfaceEnzymeExt.EnzymeGradientPrep{Tuple{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Vector{Float32}, Tuple{DifferentiationInterface.Constant{TaskLocalRNG}, DifferentiationInterface.Constant{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}}, DifferentiationInterface.Constant{Int64}}}, Nothing, Tuple{Nothing, Nothing, Nothing}}, ::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, ::Vector{Float32}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:13 [14] optimize(::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, ::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::Vector{Float32}, ::Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}, prog::ProgressMeter.Progress) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:86 [15] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}, ::typeof(NormalizingFlows.optimize), ::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, ::Function, ::Vector{Float32}, ::Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:57 [16] train_flow(::TaskLocalRNG, ::typeof(elbo), ::MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, ::var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, ADbackend::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, kwargs::@Kwargs{show_progress::Bool, callback::var"#cb#cb##0"{AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:72 [17] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, ADbackend::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, show_progress::Bool, callback::var"#cb#cb##0"{AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}, ::typeof(train_flow), ::TaskLocalRNG, ::Function, ::MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, ::Function, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:54 [18] #train_flow#1 @ ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:52 [inlined] [19] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, ADbackend::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, show_progress::Bool, callback::var"#cb#cb##0"{AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}, ::typeof(train_flow), ::Function, ::MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, ::Function, ::Int64) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:51 [20] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:2 [21] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1961 [inlined] [22] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:3 [inlined] [23] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [24] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:14 [inlined] [25] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [26] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:30 [inlined] [27] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [28] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/runtests.jl:15 [29] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [30] top-level scope @ none:6 [31] eval(m::Module, e::Any) @ Core ./boot.jl:489 [32] exec_options(opts::Base.JLOptions) @ Base ./client.jl:310 [33] _start() @ Base ./client.jl:577 WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). Float64: Error During Test at /home/pkgeval/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:14 Got exception outside of a @test LLVM error: Added modules have incompatible data layouts: e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128 (module) vs e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128-ni:10:11:12:13 (jit) Stacktrace: [1] macro expansion @ ~/.julia/packages/LLVM/iza6e/src/executionengine/utils.jl:28 [inlined] [2] add! @ ~/.julia/packages/LLVM/iza6e/src/orc.jl:434 [inlined] [3] add!(mod::LLVM.Module) @ Enzyme.Compiler.JIT ~/.julia/packages/Enzyme/QsBMf/src/compiler/orcv2.jl:290 [4] _link(job::GPUCompiler.CompilerJob{<:Enzyme.Compiler.EnzymeTarget}, mod::LLVM.Module, edges::Vector{Any}, adjoint_name::String, primal_name::Union{Nothing, String}, TapeType::Any, prepost::String) @ Enzyme.Compiler ~/.julia/packages/Enzyme/QsBMf/src/compiler.jl:6688 [5] cached_compilation @ ~/.julia/packages/Enzyme/QsBMf/src/compiler.jl:6782 [inlined] [6] thunkbase(mi::Core.MethodInstance, World::UInt64, FA::Type{<:Annotation}, A::Type{<:Annotation}, TT::Type, Mode::Enzyme.API.CDerivativeMode, width::Int64, ModifiedBetween::NTuple{N, Bool} where N, ReturnPrimal::Bool, ShadowInit::Bool, ABI::Type, ErrIfFuncWritten::Bool, RuntimeActivity::Bool, StrongZero::Bool, edges::Vector{Any}) @ Enzyme.Compiler ~/.julia/packages/Enzyme/QsBMf/src/compiler.jl:6897 [7] thunk_generator(world::UInt64, source::Union{LineNumberNode, Method}, FA::Type, A::Type, TT::Type, Mode::Enzyme.API.CDerivativeMode, Width::Int64, ModifiedBetween::NTuple{N, Bool} where N, ReturnPrimal::Bool, ShadowInit::Bool, ABI::Type, ErrIfFuncWritten::Bool, RuntimeActivity::Bool, StrongZero::Bool, self::Any, fakeworld::Any, fa::Type, a::Type, tt::Type, mode::Type, width::Type, modifiedbetween::Type, returnprimal::Type, shadowinit::Type, abi::Type, erriffuncwritten::Type, runtimeactivity::Type, strongzero::Type) @ Enzyme.Compiler ~/.julia/packages/Enzyme/QsBMf/src/compiler.jl:7041 [8] autodiff_thunk @ ~/.julia/packages/Enzyme/QsBMf/src/Enzyme.jl:1001 [inlined] [9] autodiff @ ~/.julia/packages/Enzyme/QsBMf/src/Enzyme.jl:395 [inlined] [10] macro expansion @ ~/.julia/packages/Enzyme/QsBMf/src/sugar.jl:287 [inlined] [11] gradient @ ~/.julia/packages/Enzyme/QsBMf/src/sugar.jl:274 [inlined] [12] value_and_gradient(::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::DifferentiationInterfaceEnzymeExt.EnzymeGradientPrep{Tuple{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Vector{Float64}, Tuple{DifferentiationInterface.Constant{TaskLocalRNG}, DifferentiationInterface.Constant{var"#logp#logp##1"{DiagNormal}}, DifferentiationInterface.Constant{Int64}}}, Nothing, Tuple{Nothing, Nothing, Nothing}}, ::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, ::Vector{Float64}, ::DifferentiationInterface.Constant{TaskLocalRNG}, ::DifferentiationInterface.Constant{var"#logp#logp##1"{DiagNormal}}, ::DifferentiationInterface.Constant{Int64}) @ DifferentiationInterfaceEnzymeExt ~/.julia/packages/DifferentiationInterface/6H4dc/ext/DifferentiationInterfaceEnzymeExt/reverse_onearg.jl:253 [13] _value_and_gradient(::Function, ::DifferentiationInterfaceEnzymeExt.EnzymeGradientPrep{Tuple{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Vector{Float64}, Tuple{DifferentiationInterface.Constant{TaskLocalRNG}, DifferentiationInterface.Constant{var"#logp#logp##1"{DiagNormal}}, DifferentiationInterface.Constant{Int64}}}, Nothing, Tuple{Nothing, Nothing, Nothing}}, ::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, ::Vector{Float64}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:13 [14] optimize(::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, ::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::Vector{Float64}, ::Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}, prog::ProgressMeter.Progress) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:86 [15] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}, ::typeof(NormalizingFlows.optimize), ::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, ::Function, ::Vector{Float64}, ::Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:57 [16] train_flow(::TaskLocalRNG, ::typeof(elbo), ::MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, ::var"#logp#logp##1"{DiagNormal}, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, ADbackend::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, kwargs::@Kwargs{show_progress::Bool, callback::var"#cb#cb##0"{AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:72 [17] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, ADbackend::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, show_progress::Bool, callback::var"#cb#cb##0"{AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}, ::typeof(train_flow), ::TaskLocalRNG, ::Function, ::MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, ::Function, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:54 [18] #train_flow#1 @ ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:52 [inlined] [19] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, ADbackend::AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, show_progress::Bool, callback::var"#cb#cb##0"{AutoEnzyme{ReverseMode{false, true, false, FFIABI, false, false}, Const}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}, ::typeof(train_flow), ::Function, ::MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, ::Function, ::Int64) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:51 [20] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:2 [21] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1961 [inlined] [22] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:3 [inlined] [23] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [24] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:14 [inlined] [25] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [26] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:30 [inlined] [27] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [28] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/runtests.jl:15 [29] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [30] top-level scope @ none:6 [31] eval(m::Module, e::Any) @ Core ./boot.jl:489 [32] exec_options(opts::Base.JLOptions) @ Base ./client.jl:310 [33] _start() @ Base ./client.jl:577 WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). Float32: Error During Test at /home/pkgeval/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:14 Got exception outside of a @test MooncakeRuleCompilationError: an error occurred while Mooncake was compiling a rule to differentiate something. If the `caused by` error message below does not make it clear to you how the problem can be fixed, please open an issue at github.com/chalk-lab/Mooncake.jl describing your problem. To replicate this error run the following: Mooncake.build_rrule(Mooncake.MooncakeInterpreter(Mooncake.ReverseMode), Tuple{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, Tuple{}}; debug_mode=false) Note that you may need to `using` some additional packages if not all of the names printed in the above signature are available currently in your environment. Stacktrace: [1] build_rrule(interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Type; debug_mode::Bool, silence_debug_messages::Bool) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1164 [2] kwcall(::@NamedTuple{debug_mode::Bool}, ::typeof(Mooncake.build_rrule), interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Type) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1105 [3] (::Mooncake.DynamicDerivedRule{Dict{Any, Any}})(::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}, ::Mooncake.CoDual{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}, ::Mooncake.CoDual{Tuple{}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1800 [4] (::Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}})(::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}, ::Mooncake.CoDual{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}, ::Mooncake.CoDual{Tuple{}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [5] CoDual @ ~/.julia/packages/Mooncake/pjlQh/src/tangents/codual.jl:2 [inlined] [6] rrule!! @ ~/.julia/packages/Mooncake/pjlQh/src/rules/misc.jl:95 [inlined] [7] map @ ./namedtuple.jl:260 [inlined] [8] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{typeof(map), Nothing}, Mooncake.LazyZeroRData{Function, Any}, Mooncake.LazyZeroRData{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Nothing}, Mooncake.LazyZeroRData{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.CoDual{Tuple{Symbol, Symbol}, Mooncake.NoFData}, Mooncake.Stack{Tuple{Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{Mooncake.TuplePullback{2}, Tl} where Tl<:(Mooncake.LazyZeroRData{P} where P<:Tuple{Any, Any})}, Mooncake.NoPullback, Mooncake.NoPullback, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, _3::Mooncake.CoDual, _4::Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, _5::Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}) @ Base.Experimental ./:0 [9] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual}})(::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, ::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, ::Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [10] DerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [inlined] [11] _build_rule!(rule::Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}, args::Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1893 [12] LazyDerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1887 [inlined] [13] (::Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}})(::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, ::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [14] CoDual @ ~/.julia/packages/Mooncake/pjlQh/src/tangents/codual.jl:2 [inlined] [15] rrule!! @ ~/.julia/packages/Mooncake/pjlQh/src/rules/new.jl:44 [inlined] [16] _Trainable_biwalk @ ~/.julia/packages/Optimisers/ZOK0f/src/destructure.jl:108 [inlined] [17] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{Optimisers._Trainable_biwalk, Nothing}, Mooncake.LazyZeroRData{Function, Any}, Mooncake.LazyZeroRData{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Nothing}, Mooncake.LazyZeroRData{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.Stack{Tuple{Mooncake.NoPullback, Mooncake.NoPullback, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb}, Mooncake.RRuleWrapperPb{Mooncake.Pullback{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, 5}, Tl} where Tl<:Mooncake.LazyZeroRData, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, _3::Mooncake.CoDual, _4::Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, _5::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ Base.Experimental ./:0 [18] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual}})(::Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, ::Mooncake.CoDual{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}, Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}, ::Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [19] DerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [inlined] [20] _build_rule!(rule::Mooncake.LazyDerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, Val{4}}}, args::Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}, Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}, Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1893 [21] LazyDerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1887 [inlined] [22] RRuleZeroWrapper @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [inlined] [23] loss @ ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:69 [inlined] [24] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Nothing}, Mooncake.LazyZeroRData{Vector{Float32}, Nothing}, Mooncake.LazyZeroRData{TaskLocalRNG, Nothing}, Mooncake.LazyZeroRData{Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, Val{4}}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.Stack{Tuple{Mooncake.RRuleWrapperPb{Mooncake.Pullback{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, 4}, Tl} where Tl<:Mooncake.LazyZeroRData}}, Mooncake.Stack{Tuple{Any}}, Mooncake.Stack{Tuple{Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, _3::Mooncake.CoDual{Vector{Float32}, Vector{Float32}}, _4::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, _5::Mooncake.CoDual{Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}}, Mooncake.NoFData}}) @ Base.Experimental ./:0 [25] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, Mooncake.CoDual{Vector{Float32}, Vector{Float32}}, Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, Mooncake.CoDual{Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual}})(::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, ::Mooncake.CoDual{Vector{Float32}, Vector{Float32}}, ::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, ::Mooncake.CoDual{Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}}, Mooncake.NoFData}}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [26] (::Mooncake.DerivedRule{Tuple{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Vector{Float32}, TaskLocalRNG, Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}}, Tuple{Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, Mooncake.CoDual{Vector{Float32}, Vector{Float32}}, Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, Mooncake.CoDual{Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, NTuple{4, Mooncake.NoRData}, true, Val{4}})(::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, ::Mooncake.CoDual{Vector{Float32}, Vector{Float32}}, ::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, ::Mooncake.CoDual{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}}}, ::Mooncake.CoDual{Int64, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [27] prepare_gradient_cache(::Function, ::Vararg{Any}; friendly_tangents::Bool, kwargs::@Kwargs{debug_mode::Bool, silence_debug_messages::Bool}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interface.jl:584 [28] prepare_gradient_cache @ ~/.julia/packages/Mooncake/pjlQh/src/interface.jl:581 [inlined] [29] prepare_gradient_nokwarg(::Val{true}, ::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::AutoMooncake{Mooncake.Config}, ::Vector{Float32}, ::DifferentiationInterface.Constant{TaskLocalRNG}, ::DifferentiationInterface.Constant{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}}, ::DifferentiationInterface.Constant{Int64}) @ DifferentiationInterfaceMooncakeExt ~/.julia/packages/DifferentiationInterface/6H4dc/ext/DifferentiationInterfaceMooncakeExt/onearg.jl:124 [30] #prepare_gradient#45 @ ~/.julia/packages/DifferentiationInterface/6H4dc/src/first_order/gradient.jl:11 [inlined] [31] prepare_gradient(::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::AutoMooncake{Mooncake.Config}, ::Vector{Float32}, ::DifferentiationInterface.Constant{TaskLocalRNG}, ::DifferentiationInterface.Constant{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}}, ::DifferentiationInterface.Constant{Int64}) @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/6H4dc/src/first_order/gradient.jl:8 [32] _prepare_gradient(::Function, ::AutoMooncake{Mooncake.Config}, ::Vector{Float32}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:9 [33] optimize(::AutoMooncake{Mooncake.Config}, ::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::Vector{Float32}, ::Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}, prog::ProgressMeter.Progress) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:77 [34] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}, ::typeof(NormalizingFlows.optimize), ::AutoMooncake{Mooncake.Config}, ::Function, ::Vector{Float32}, ::Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:57 [35] train_flow(::TaskLocalRNG, ::typeof(elbo), ::MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, ::var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, kwargs::@Kwargs{show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:72 [36] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}, ::typeof(train_flow), ::TaskLocalRNG, ::Function, ::MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, ::Function, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:54 [37] #train_flow#1 @ ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:52 [inlined] [38] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}, ::typeof(train_flow), ::Function, ::MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, ::Function, ::Int64) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:51 [39] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:2 [40] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1961 [inlined] [41] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:3 [inlined] [42] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [43] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:14 [inlined] [44] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [45] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:30 [inlined] [46] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [47] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/runtests.jl:15 [48] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [49] top-level scope @ none:6 [50] eval(m::Module, e::Any) @ Core ./boot.jl:489 [51] exec_options(opts::Base.JLOptions) @ Base ./client.jl:310 [52] _start() @ Base ./client.jl:577 caused by: MethodError: no method matching compute_ir_rettype(::Nothing) The function `compute_ir_rettype` exists, but no method is defined for this combination of argument types. Closest candidates are: compute_ir_rettype(!Matched::Compiler.IRCode) @ Base /opt/julia/share/julia/Compiler/src/opaque_closure.jl:3 Stacktrace: [1] compute_ir_rettype(ir::Nothing) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/utils.jl:381 [2] rule_type(interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Core.MethodInstance; debug_mode::Bool) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1910 [3] kwcall(::@NamedTuple{debug_mode::Bool}, ::typeof(Mooncake.rule_type), interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Core.MethodInstance) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1903 [4] Mooncake.LazyDerivedRule(mi::Core.MethodInstance, debug_mode::Bool) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1874 [5] make_ad_stmts!(stmt::Expr, line::Mooncake.BasicBlockCode.ID, info::Mooncake.ADInfo) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:710 [6] _broadcast_getindex_evalf @ ./broadcast.jl:698 [inlined] [7] _broadcast_getindex @ ./broadcast.jl:671 [inlined] [8] _getindex @ ./broadcast.jl:619 [inlined] [9] getindex @ ./broadcast.jl:615 [inlined] [10] macro expansion @ ./broadcast.jl:994 [inlined] [11] macro expansion @ ./simdloop.jl:77 [inlined] [12] copyto! @ ./broadcast.jl:993 [inlined] [13] copyto! @ ./broadcast.jl:946 [inlined] [14] copy @ ./broadcast.jl:918 [inlined] [15] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Mooncake.make_ad_stmts!), Tuple{Vector{Any}, Vector{Mooncake.BasicBlockCode.ID}, Base.RefValue{Mooncake.ADInfo}}}) @ Base.Broadcast ./broadcast.jl:893 [16] (::Mooncake.var"#254#255"{Mooncake.ADInfo})(primal_blk::Mooncake.BasicBlockCode.BBlock) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1206 [17] iterate @ ./generator.jl:48 [inlined] [18] collect_to!(dest::Vector{Tuple{Mooncake.BasicBlockCode.ID, Vector{Mooncake.ADStmtInfo}}}, itr::Base.Generator{Vector{Mooncake.BasicBlockCode.BBlock}, Mooncake.var"#254#255"{Mooncake.ADInfo}}, offs::Int64, st::Int64) @ Base ./array.jl:886 [19] collect_to_with_first!(dest::Vector{Tuple{Mooncake.BasicBlockCode.ID, Vector{Mooncake.ADStmtInfo}}}, v1::Tuple{Mooncake.BasicBlockCode.ID, Vector{Mooncake.ADStmtInfo}}, itr::Base.Generator{Vector{Mooncake.BasicBlockCode.BBlock}, Mooncake.var"#254#255"{Mooncake.ADInfo}}, st::Int64) @ Base ./array.jl:864 [20] _collect(c::Vector{Mooncake.BasicBlockCode.BBlock}, itr::Base.Generator{Vector{Mooncake.BasicBlockCode.BBlock}, Mooncake.var"#254#255"{Mooncake.ADInfo}}, ::Base.EltypeUnknown, isz::Base.HasShape{1}) @ Base ./array.jl:858 [21] collect_similar @ ./array.jl:763 [inlined] [22] map @ ./abstractarray.jl:3390 [inlined] [23] generate_ir(interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Type; debug_mode::Bool, do_inline::Bool) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1203 [24] generate_ir @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1177 [inlined] [25] build_rrule(interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Type; debug_mode::Bool, silence_debug_messages::Bool) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1142 [26] kwcall(::@NamedTuple{debug_mode::Bool}, ::typeof(Mooncake.build_rrule), interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Type) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1105 [27] (::Mooncake.DynamicDerivedRule{Dict{Any, Any}})(::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}, ::Mooncake.CoDual{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}, ::Mooncake.CoDual{Tuple{}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1800 [28] (::Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}})(::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}, ::Mooncake.CoDual{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}, ::Mooncake.CoDual{Tuple{}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [29] CoDual @ ~/.julia/packages/Mooncake/pjlQh/src/tangents/codual.jl:2 [inlined] [30] rrule!! @ ~/.julia/packages/Mooncake/pjlQh/src/rules/misc.jl:95 [inlined] [31] map @ ./namedtuple.jl:260 [inlined] [32] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{typeof(map), Nothing}, Mooncake.LazyZeroRData{Function, Any}, Mooncake.LazyZeroRData{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Nothing}, Mooncake.LazyZeroRData{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.CoDual{Tuple{Symbol, Symbol}, Mooncake.NoFData}, Mooncake.Stack{Tuple{Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{Mooncake.TuplePullback{2}, Tl} where Tl<:(Mooncake.LazyZeroRData{P} where P<:Tuple{Any, Any})}, Mooncake.NoPullback, Mooncake.NoPullback, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, _3::Mooncake.CoDual, _4::Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, _5::Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}) @ Base.Experimental ./:0 [33] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual}})(::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, ::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, ::Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [34] DerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [inlined] [35] _build_rule!(rule::Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}, args::Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1893 [36] LazyDerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1887 [inlined] [37] (::Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}})(::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, ::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [38] CoDual @ ~/.julia/packages/Mooncake/pjlQh/src/tangents/codual.jl:2 [inlined] [39] rrule!! @ ~/.julia/packages/Mooncake/pjlQh/src/rules/new.jl:44 [inlined] [40] _Trainable_biwalk @ ~/.julia/packages/Optimisers/ZOK0f/src/destructure.jl:108 [inlined] [41] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{Optimisers._Trainable_biwalk, Nothing}, Mooncake.LazyZeroRData{Function, Any}, Mooncake.LazyZeroRData{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Nothing}, Mooncake.LazyZeroRData{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.Stack{Tuple{Mooncake.NoPullback, Mooncake.NoPullback, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb}, Mooncake.RRuleWrapperPb{Mooncake.Pullback{Tuple{typeof(map), Function, @NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Tuple{@NamedTuple{dist::MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, transform::ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, 5}, Tl} where Tl<:Mooncake.LazyZeroRData, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, _3::Mooncake.CoDual, _4::Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, _5::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ Base.Experimental ./:0 [42] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual}})(::Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, ::Mooncake.CoDual{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}, Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}, ::Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [43] DerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [inlined] [44] _build_rule!(rule::Mooncake.LazyDerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, Val{4}}}, args::Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float32}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}, Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float32}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}, Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1893 [45] LazyDerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1887 [inlined] [46] RRuleZeroWrapper @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [inlined] [47] loss @ ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:69 [inlined] [48] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Nothing}, Mooncake.LazyZeroRData{Vector{Float32}, Nothing}, Mooncake.LazyZeroRData{TaskLocalRNG, Nothing}, Mooncake.LazyZeroRData{Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, Val{4}}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.Stack{Tuple{Mooncake.RRuleWrapperPb{Mooncake.Pullback{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, 4}, Tl} where Tl<:Mooncake.LazyZeroRData}}, Mooncake.Stack{Tuple{Any}}, Mooncake.Stack{Tuple{Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, _3::Mooncake.CoDual{Vector{Float32}, Vector{Float32}}, _4::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, _5::Mooncake.CoDual{Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}}, Mooncake.NoFData}}) @ Base.Experimental ./:0 [49] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, Mooncake.CoDual{Vector{Float32}, Vector{Float32}}, Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, Mooncake.CoDual{Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual}})(::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, ::Mooncake.CoDual{Vector{Float32}, Vector{Float32}}, ::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, ::Mooncake.CoDual{Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}}, Mooncake.NoFData}}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [50] (::Mooncake.DerivedRule{Tuple{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Vector{Float32}, TaskLocalRNG, Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}}, Tuple{Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, Mooncake.CoDual{Vector{Float32}, Vector{Float32}}, Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, Mooncake.CoDual{Tuple{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, NTuple{4, Mooncake.NoRData}, true, Val{4}})(::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float32}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, ::Mooncake.CoDual{Vector{Float32}, Vector{Float32}}, ::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, ::Mooncake.CoDual{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float32}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float32}}}}}}}}, ::Mooncake.CoDual{Int64, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [51] prepare_gradient_cache(::Function, ::Vararg{Any}; friendly_tangents::Bool, kwargs::@Kwargs{debug_mode::Bool, silence_debug_messages::Bool}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interface.jl:584 [52] prepare_gradient_cache @ ~/.julia/packages/Mooncake/pjlQh/src/interface.jl:581 [inlined] [53] prepare_gradient_nokwarg(::Val{true}, ::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::AutoMooncake{Mooncake.Config}, ::Vector{Float32}, ::DifferentiationInterface.Constant{TaskLocalRNG}, ::DifferentiationInterface.Constant{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}}, ::DifferentiationInterface.Constant{Int64}) @ DifferentiationInterfaceMooncakeExt ~/.julia/packages/DifferentiationInterface/6H4dc/ext/DifferentiationInterfaceMooncakeExt/onearg.jl:124 [54] #prepare_gradient#45 @ ~/.julia/packages/DifferentiationInterface/6H4dc/src/first_order/gradient.jl:11 [inlined] [55] prepare_gradient(::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::AutoMooncake{Mooncake.Config}, ::Vector{Float32}, ::DifferentiationInterface.Constant{TaskLocalRNG}, ::DifferentiationInterface.Constant{var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}}, ::DifferentiationInterface.Constant{Int64}) @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/6H4dc/src/first_order/gradient.jl:8 [56] _prepare_gradient(::Function, ::AutoMooncake{Mooncake.Config}, ::Vector{Float32}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:9 [57] optimize(::AutoMooncake{Mooncake.Config}, ::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::Vector{Float32}, ::Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}, prog::ProgressMeter.Progress) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:77 [58] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}, ::typeof(NormalizingFlows.optimize), ::AutoMooncake{Mooncake.Config}, ::Function, ::Vector{Float32}, ::Optimisers.Restructure{MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:57 [59] train_flow(::TaskLocalRNG, ::typeof(elbo), ::MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, ::var"#logp#logp##1"{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}}, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, kwargs::@Kwargs{show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:72 [60] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}, ::typeof(train_flow), ::TaskLocalRNG, ::Function, ::MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, ::Function, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:54 [61] #train_flow#1 @ ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:52 [inlined] [62] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float32, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float32}}}, ::typeof(train_flow), ::Function, ::MultivariateTransformed{MvNormal{Float32, PDMats.PDiagMat{Float32, Vector{Float32}}, Vector{Float32}}, ComposedFunction{Bijectors.Shift{Vector{Float32}}, Bijectors.Scale{Vector{Float32}}}}, ::Function, ::Int64) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:51 [63] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:2 [64] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1961 [inlined] [65] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:3 [inlined] [66] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [67] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:14 [inlined] [68] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [69] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:30 [inlined] [70] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [71] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/runtests.jl:15 [72] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [73] top-level scope @ none:6 [74] eval(m::Module, e::Any) @ Core ./boot.jl:489 [75] exec_options(opts::Base.JLOptions) @ Base ./client.jl:310 [76] _start() @ Base ./client.jl:577 WARNING: Method definition functor(Type{var"#s116"} where var"#s116"<:(Distributions.MvNormal{T, Cov, Mean} where Mean<:(AbstractArray{T, 1} where T) where Cov<:(PDMats.AbstractPDMat{T} where T<:Real) where T<:Real), Any) in module Main at /home/pkgeval/.julia/packages/Functors/LbNAu/src/functor.jl:11 overwritten on the same line (check for duplicate calls to `include`). Float64: Error During Test at /home/pkgeval/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:14 Got exception outside of a @test MooncakeRuleCompilationError: an error occurred while Mooncake was compiling a rule to differentiate something. If the `caused by` error message below does not make it clear to you how the problem can be fixed, please open an issue at github.com/chalk-lab/Mooncake.jl describing your problem. To replicate this error run the following: Mooncake.build_rrule(Mooncake.MooncakeInterpreter(Mooncake.ReverseMode), Tuple{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, DiagNormal, DiagNormal, Tuple{}}; debug_mode=false) Note that you may need to `using` some additional packages if not all of the names printed in the above signature are available currently in your environment. Stacktrace: [1] build_rrule(interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Type; debug_mode::Bool, silence_debug_messages::Bool) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1164 [2] kwcall(::@NamedTuple{debug_mode::Bool}, ::typeof(Mooncake.build_rrule), interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Type) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1105 [3] (::Mooncake.DynamicDerivedRule{Dict{Any, Any}})(::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{DiagNormal, Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}, ::Mooncake.CoDual{DiagNormal, Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}, ::Mooncake.CoDual{Tuple{}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1800 [4] (::Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}})(::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{DiagNormal, Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}, ::Mooncake.CoDual{DiagNormal, Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}, ::Mooncake.CoDual{Tuple{}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [5] CoDual @ ~/.julia/packages/Mooncake/pjlQh/src/tangents/codual.jl:2 [inlined] [6] rrule!! @ ~/.julia/packages/Mooncake/pjlQh/src/rules/misc.jl:95 [inlined] [7] map @ ./namedtuple.jl:260 [inlined] [8] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{typeof(map), Nothing}, Mooncake.LazyZeroRData{Function, Any}, Mooncake.LazyZeroRData{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Nothing}, Mooncake.LazyZeroRData{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.CoDual{Tuple{Symbol, Symbol}, Mooncake.NoFData}, Mooncake.Stack{Tuple{Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{Mooncake.TuplePullback{2}, Tl} where Tl<:(Mooncake.LazyZeroRData{P} where P<:Tuple{Any, Any})}, Mooncake.NoPullback, Mooncake.NoPullback, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, _3::Mooncake.CoDual, _4::Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, _5::Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}) @ Base.Experimental ./:0 [9] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual}})(::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, ::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, ::Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [10] DerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [inlined] [11] _build_rule!(rule::Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}, args::Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1893 [12] LazyDerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1887 [inlined] [13] (::Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}})(::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, ::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [14] CoDual @ ~/.julia/packages/Mooncake/pjlQh/src/tangents/codual.jl:2 [inlined] [15] rrule!! @ ~/.julia/packages/Mooncake/pjlQh/src/rules/new.jl:44 [inlined] [16] _Trainable_biwalk @ ~/.julia/packages/Optimisers/ZOK0f/src/destructure.jl:108 [inlined] [17] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{Optimisers._Trainable_biwalk, Nothing}, Mooncake.LazyZeroRData{Function, Any}, Mooncake.LazyZeroRData{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Nothing}, Mooncake.LazyZeroRData{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.Stack{Tuple{Mooncake.NoPullback, Mooncake.NoPullback, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb}, Mooncake.RRuleWrapperPb{Mooncake.Pullback{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, 5}, Tl} where Tl<:Mooncake.LazyZeroRData, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, _3::Mooncake.CoDual, _4::Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, _5::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ Base.Experimental ./:0 [18] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual}})(::Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, ::Mooncake.CoDual{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}, Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}, ::Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [19] DerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [inlined] [20] _build_rule!(rule::Mooncake.LazyDerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, Val{4}}}, args::Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}, Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}, Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1893 [21] LazyDerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1887 [inlined] [22] RRuleZeroWrapper @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [inlined] [23] loss @ ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:69 [inlined] [24] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Nothing}, Mooncake.LazyZeroRData{Vector{Float64}, Nothing}, Mooncake.LazyZeroRData{TaskLocalRNG, Nothing}, Mooncake.LazyZeroRData{Tuple{var"#logp#logp##1"{DiagNormal}, Int64}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, Val{4}}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.Stack{Tuple{Mooncake.RRuleWrapperPb{Mooncake.Pullback{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, 4}, Tl} where Tl<:Mooncake.LazyZeroRData}}, Mooncake.Stack{Tuple{Any}}, Mooncake.Stack{Tuple{Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, _3::Mooncake.CoDual{Vector{Float64}, Vector{Float64}}, _4::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, _5::Mooncake.CoDual{Tuple{var"#logp#logp##1"{DiagNormal}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}}, Mooncake.NoFData}}) @ Base.Experimental ./:0 [25] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, Mooncake.CoDual{Vector{Float64}, Vector{Float64}}, Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, Mooncake.CoDual{Tuple{var"#logp#logp##1"{DiagNormal}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual}})(::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, ::Mooncake.CoDual{Vector{Float64}, Vector{Float64}}, ::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, ::Mooncake.CoDual{Tuple{var"#logp#logp##1"{DiagNormal}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}}, Mooncake.NoFData}}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [26] (::Mooncake.DerivedRule{Tuple{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Vector{Float64}, TaskLocalRNG, Tuple{var"#logp#logp##1"{DiagNormal}, Int64}}, Tuple{Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, Mooncake.CoDual{Vector{Float64}, Vector{Float64}}, Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, Mooncake.CoDual{Tuple{var"#logp#logp##1"{DiagNormal}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, NTuple{4, Mooncake.NoRData}, true, Val{4}})(::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, ::Mooncake.CoDual{Vector{Float64}, Vector{Float64}}, ::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, ::Mooncake.CoDual{var"#logp#logp##1"{DiagNormal}, Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}}}, ::Mooncake.CoDual{Int64, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [27] prepare_gradient_cache(::Function, ::Vararg{Any}; friendly_tangents::Bool, kwargs::@Kwargs{debug_mode::Bool, silence_debug_messages::Bool}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interface.jl:584 [28] prepare_gradient_cache @ ~/.julia/packages/Mooncake/pjlQh/src/interface.jl:581 [inlined] [29] prepare_gradient_nokwarg(::Val{true}, ::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::AutoMooncake{Mooncake.Config}, ::Vector{Float64}, ::DifferentiationInterface.Constant{TaskLocalRNG}, ::DifferentiationInterface.Constant{var"#logp#logp##1"{DiagNormal}}, ::DifferentiationInterface.Constant{Int64}) @ DifferentiationInterfaceMooncakeExt ~/.julia/packages/DifferentiationInterface/6H4dc/ext/DifferentiationInterfaceMooncakeExt/onearg.jl:124 [30] #prepare_gradient#45 @ ~/.julia/packages/DifferentiationInterface/6H4dc/src/first_order/gradient.jl:11 [inlined] [31] prepare_gradient(::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::AutoMooncake{Mooncake.Config}, ::Vector{Float64}, ::DifferentiationInterface.Constant{TaskLocalRNG}, ::DifferentiationInterface.Constant{var"#logp#logp##1"{DiagNormal}}, ::DifferentiationInterface.Constant{Int64}) @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/6H4dc/src/first_order/gradient.jl:8 [32] _prepare_gradient(::Function, ::AutoMooncake{Mooncake.Config}, ::Vector{Float64}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:9 [33] optimize(::AutoMooncake{Mooncake.Config}, ::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::Vector{Float64}, ::Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}, prog::ProgressMeter.Progress) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:77 [34] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}, ::typeof(NormalizingFlows.optimize), ::AutoMooncake{Mooncake.Config}, ::Function, ::Vector{Float64}, ::Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:57 [35] train_flow(::TaskLocalRNG, ::typeof(elbo), ::MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, ::var"#logp#logp##1"{DiagNormal}, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, kwargs::@Kwargs{show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:72 [36] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}, ::typeof(train_flow), ::TaskLocalRNG, ::Function, ::MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, ::Function, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:54 [37] #train_flow#1 @ ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:52 [inlined] [38] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}, ::typeof(train_flow), ::Function, ::MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, ::Function, ::Int64) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:51 [39] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:2 [40] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1961 [inlined] [41] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:3 [inlined] [42] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [43] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:14 [inlined] [44] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [45] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:30 [inlined] [46] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [47] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/runtests.jl:15 [48] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [49] top-level scope @ none:6 [50] eval(m::Module, e::Any) @ Core ./boot.jl:489 [51] exec_options(opts::Base.JLOptions) @ Base ./client.jl:310 [52] _start() @ Base ./client.jl:577 caused by: MethodError: no method matching compute_ir_rettype(::Nothing) The function `compute_ir_rettype` exists, but no method is defined for this combination of argument types. Closest candidates are: compute_ir_rettype(!Matched::Compiler.IRCode) @ Base /opt/julia/share/julia/Compiler/src/opaque_closure.jl:3 Stacktrace: [1] compute_ir_rettype(ir::Nothing) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/utils.jl:381 [2] rule_type(interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Core.MethodInstance; debug_mode::Bool) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1910 [3] kwcall(::@NamedTuple{debug_mode::Bool}, ::typeof(Mooncake.rule_type), interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Core.MethodInstance) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1903 [4] Mooncake.LazyDerivedRule(mi::Core.MethodInstance, debug_mode::Bool) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1874 [5] make_ad_stmts!(stmt::Expr, line::Mooncake.BasicBlockCode.ID, info::Mooncake.ADInfo) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:710 [6] _broadcast_getindex_evalf @ ./broadcast.jl:698 [inlined] [7] _broadcast_getindex @ ./broadcast.jl:671 [inlined] [8] _getindex @ ./broadcast.jl:619 [inlined] [9] getindex @ ./broadcast.jl:615 [inlined] [10] macro expansion @ ./broadcast.jl:994 [inlined] [11] macro expansion @ ./simdloop.jl:77 [inlined] [12] copyto! @ ./broadcast.jl:993 [inlined] [13] copyto! @ ./broadcast.jl:946 [inlined] [14] copy @ ./broadcast.jl:918 [inlined] [15] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Mooncake.make_ad_stmts!), Tuple{Vector{Any}, Vector{Mooncake.BasicBlockCode.ID}, Base.RefValue{Mooncake.ADInfo}}}) @ Base.Broadcast ./broadcast.jl:893 [16] (::Mooncake.var"#254#255"{Mooncake.ADInfo})(primal_blk::Mooncake.BasicBlockCode.BBlock) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1206 [17] iterate @ ./generator.jl:48 [inlined] [18] collect_to!(dest::Vector{Tuple{Mooncake.BasicBlockCode.ID, Vector{Mooncake.ADStmtInfo}}}, itr::Base.Generator{Vector{Mooncake.BasicBlockCode.BBlock}, Mooncake.var"#254#255"{Mooncake.ADInfo}}, offs::Int64, st::Int64) @ Base ./array.jl:886 [19] collect_to_with_first!(dest::Vector{Tuple{Mooncake.BasicBlockCode.ID, Vector{Mooncake.ADStmtInfo}}}, v1::Tuple{Mooncake.BasicBlockCode.ID, Vector{Mooncake.ADStmtInfo}}, itr::Base.Generator{Vector{Mooncake.BasicBlockCode.BBlock}, Mooncake.var"#254#255"{Mooncake.ADInfo}}, st::Int64) @ Base ./array.jl:864 [20] _collect(c::Vector{Mooncake.BasicBlockCode.BBlock}, itr::Base.Generator{Vector{Mooncake.BasicBlockCode.BBlock}, Mooncake.var"#254#255"{Mooncake.ADInfo}}, ::Base.EltypeUnknown, isz::Base.HasShape{1}) @ Base ./array.jl:858 [21] collect_similar @ ./array.jl:763 [inlined] [22] map @ ./abstractarray.jl:3390 [inlined] [23] generate_ir(interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Type; debug_mode::Bool, do_inline::Bool) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1203 [24] generate_ir @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1177 [inlined] [25] build_rrule(interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Type; debug_mode::Bool, silence_debug_messages::Bool) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1142 [26] kwcall(::@NamedTuple{debug_mode::Bool}, ::typeof(Mooncake.build_rrule), interp::Mooncake.MooncakeInterpreter{Mooncake.DefaultCtx, Mooncake.ReverseMode}, sig_or_mi::Type) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1105 [27] (::Mooncake.DynamicDerivedRule{Dict{Any, Any}})(::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{DiagNormal, Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}, ::Mooncake.CoDual{DiagNormal, Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}, ::Mooncake.CoDual{Tuple{}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1800 [28] (::Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}})(::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{DiagNormal, Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}, ::Mooncake.CoDual{DiagNormal, Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}, ::Mooncake.CoDual{Tuple{}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [29] CoDual @ ~/.julia/packages/Mooncake/pjlQh/src/tangents/codual.jl:2 [inlined] [30] rrule!! @ ~/.julia/packages/Mooncake/pjlQh/src/rules/misc.jl:95 [inlined] [31] map @ ./namedtuple.jl:260 [inlined] [32] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{typeof(map), Nothing}, Mooncake.LazyZeroRData{Function, Any}, Mooncake.LazyZeroRData{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Nothing}, Mooncake.LazyZeroRData{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.CoDual{Tuple{Symbol, Symbol}, Mooncake.NoFData}, Mooncake.Stack{Tuple{Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{Mooncake.TuplePullback{2}, Tl} where Tl<:(Mooncake.LazyZeroRData{P} where P<:Tuple{Any, Any})}, Mooncake.NoPullback, Mooncake.NoPullback, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, _3::Mooncake.CoDual, _4::Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, _5::Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}) @ Base.Experimental ./:0 [33] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual}})(::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, ::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, ::Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [34] DerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [inlined] [35] _build_rule!(rule::Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}, args::Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1893 [36] LazyDerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1887 [inlined] [37] (::Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}})(::Mooncake.CoDual{typeof(map), Mooncake.NoFData}, ::Mooncake.CoDual{Optimisers.var"#_trainmap##0#_trainmap##1"{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}}, Mooncake.FData{@NamedTuple{f::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [38] CoDual @ ~/.julia/packages/Mooncake/pjlQh/src/tangents/codual.jl:2 [inlined] [39] rrule!! @ ~/.julia/packages/Mooncake/pjlQh/src/rules/new.jl:44 [inlined] [40] _Trainable_biwalk @ ~/.julia/packages/Optimisers/ZOK0f/src/destructure.jl:108 [inlined] [41] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{Optimisers._Trainable_biwalk, Nothing}, Mooncake.LazyZeroRData{Function, Any}, Mooncake.LazyZeroRData{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Nothing}, Mooncake.LazyZeroRData{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Mooncake.CoDual{typeof(map), Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, Mooncake.CoDual{Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, Val{4}}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.Stack{Tuple{Mooncake.NoPullback, Mooncake.NoPullback, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb}, Mooncake.RRuleWrapperPb{Mooncake.Pullback{Tuple{typeof(map), Function, @NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Tuple{@NamedTuple{dist::DiagNormal, transform::ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, true, 5}, Tl} where Tl<:Mooncake.LazyZeroRData, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, _3::Mooncake.CoDual, _4::Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, _5::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ Base.Experimental ./:0 [42] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual}})(::Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, ::Mooncake.CoDual{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}, Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}, ::Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, ::Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [43] DerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [inlined] [44] _build_rule!(rule::Mooncake.LazyDerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, Val{4}}}, args::Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual{Functors.var"#recurse#execute##0"{Functors.CachedWalk{Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, Functors.NoKeyword, Functors.WalkCache{Any, Any, Functors.ExcludeWalk{Optimisers._Trainable_biwalk, Optimisers.var"#42#43"{Vector{Float64}}, typeof(Optimisers.isnumeric)}, IdDict{Any, Any}}}}, Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, prune::Mooncake.NoFData, cache::Mooncake.FData{@NamedTuple{walk::Mooncake.FData{@NamedTuple{walk::Mooncake.NoFData, fn::Mooncake.FData{@NamedTuple{flat::Vector{Float64}}}, exclude::Mooncake.NoFData}}, cache::IdDict{Any, Any}}}}}}}}, Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1893 [45] LazyDerivedRule @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:1887 [inlined] [46] RRuleZeroWrapper @ ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:327 [inlined] [47] loss @ ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:69 [inlined] [48] (::Tuple{Mooncake.Stack{Int32}, Base.RefValue{Tuple{Mooncake.LazyZeroRData{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Nothing}, Mooncake.LazyZeroRData{Vector{Float64}, Nothing}, Mooncake.LazyZeroRData{TaskLocalRNG, Nothing}, Mooncake.LazyZeroRData{Tuple{var"#logp#logp##1"{DiagNormal}, Int64}, Nothing}}}, Mooncake.RRuleZeroWrapper{Mooncake.LazyDerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Mooncake.DerivedRule{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Mooncake.CoDual{Optimisers._Trainable_biwalk, Mooncake.NoFData}, Mooncake.CoDual, Mooncake.CoDual{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}}, Mooncake.CoDual{@NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}, Mooncake.NoFData}}, Mooncake.CoDual, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, Val{4}}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.RRuleZeroWrapper{Mooncake.DynamicDerivedRule{Dict{Any, Any}}}, Mooncake.Stack{Tuple{Mooncake.RRuleWrapperPb{Mooncake.Pullback{Tuple{Optimisers._Trainable_biwalk, Function, MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, Tuple{Any}, Tuple{Mooncake.NoRData, Any, Mooncake.NoRData, Mooncake.NoRData}, false, 4}, Tl} where Tl<:Mooncake.LazyZeroRData}}, Mooncake.Stack{Tuple{Any}}, Mooncake.Stack{Tuple{Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}, Union{Mooncake.NoPullback, Mooncake.RRuleWrapperPb{_A, Tl} where {_A, Tl<:Mooncake.LazyZeroRData}}}}})(_2::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, _3::Mooncake.CoDual{Vector{Float64}, Vector{Float64}}, _4::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, _5::Mooncake.CoDual{Tuple{var"#logp#logp##1"{DiagNormal}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}}, Mooncake.NoFData}}) @ Base.Experimental ./:0 [49] (::MistyClosures.MistyClosure{Core.OpaqueClosure{Tuple{Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, Mooncake.CoDual{Vector{Float64}, Vector{Float64}}, Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, Mooncake.CoDual{Tuple{var"#logp#logp##1"{DiagNormal}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual}})(::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, ::Mooncake.CoDual{Vector{Float64}, Vector{Float64}}, ::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, ::Mooncake.CoDual{Tuple{var"#logp#logp##1"{DiagNormal}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}}, Mooncake.NoFData}}) @ MistyClosures ~/.julia/packages/MistyClosures/2vtLL/src/MistyClosures.jl:22 [50] (::Mooncake.DerivedRule{Tuple{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Vector{Float64}, TaskLocalRNG, Tuple{var"#logp#logp##1"{DiagNormal}, Int64}}, Tuple{Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, Mooncake.CoDual{Vector{Float64}, Vector{Float64}}, Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, Mooncake.CoDual{Tuple{var"#logp#logp##1"{DiagNormal}, Int64}, Tuple{Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}}, Mooncake.NoFData}}}, Mooncake.CoDual, Tuple{Any}, NTuple{4, Mooncake.NoRData}, true, Val{4}})(::Mooncake.CoDual{NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, Mooncake.FData{@NamedTuple{vo::Mooncake.NoFData, re::Mooncake.FData{@NamedTuple{model::Mooncake.FData{@NamedTuple{dist::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}, transform::Mooncake.FData{@NamedTuple{outer::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}, inner::Mooncake.FData{@NamedTuple{a::Vector{Float64}}}}}}}, offsets::Mooncake.NoFData, length::Mooncake.NoFData}}}}}, ::Mooncake.CoDual{Vector{Float64}, Vector{Float64}}, ::Mooncake.CoDual{TaskLocalRNG, Mooncake.NoFData}, ::Mooncake.CoDual{var"#logp#logp##1"{DiagNormal}, Mooncake.FData{@NamedTuple{target::Mooncake.FData{@NamedTuple{μ::Vector{Float64}, Σ::Mooncake.FData{@NamedTuple{diag::Vector{Float64}}}}}}}}, ::Mooncake.CoDual{Int64, Mooncake.NoFData}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interpreter/reverse_mode.jl:990 [51] prepare_gradient_cache(::Function, ::Vararg{Any}; friendly_tangents::Bool, kwargs::@Kwargs{debug_mode::Bool, silence_debug_messages::Bool}) @ Mooncake ~/.julia/packages/Mooncake/pjlQh/src/interface.jl:584 [52] prepare_gradient_cache @ ~/.julia/packages/Mooncake/pjlQh/src/interface.jl:581 [inlined] [53] prepare_gradient_nokwarg(::Val{true}, ::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::AutoMooncake{Mooncake.Config}, ::Vector{Float64}, ::DifferentiationInterface.Constant{TaskLocalRNG}, ::DifferentiationInterface.Constant{var"#logp#logp##1"{DiagNormal}}, ::DifferentiationInterface.Constant{Int64}) @ DifferentiationInterfaceMooncakeExt ~/.julia/packages/DifferentiationInterface/6H4dc/ext/DifferentiationInterfaceMooncakeExt/onearg.jl:124 [54] #prepare_gradient#45 @ ~/.julia/packages/DifferentiationInterface/6H4dc/src/first_order/gradient.jl:11 [inlined] [55] prepare_gradient(::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::AutoMooncake{Mooncake.Config}, ::Vector{Float64}, ::DifferentiationInterface.Constant{TaskLocalRNG}, ::DifferentiationInterface.Constant{var"#logp#logp##1"{DiagNormal}}, ::DifferentiationInterface.Constant{Int64}) @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/6H4dc/src/first_order/gradient.jl:8 [56] _prepare_gradient(::Function, ::AutoMooncake{Mooncake.Config}, ::Vector{Float64}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:9 [57] optimize(::AutoMooncake{Mooncake.Config}, ::NormalizingFlows.var"#loss#3"{typeof(elbo), Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}}, ::Vector{Float64}, ::Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}, prog::ProgressMeter.Progress) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:77 [58] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}, ::typeof(NormalizingFlows.optimize), ::AutoMooncake{Mooncake.Config}, ::Function, ::Vector{Float64}, ::Optimisers.Restructure{MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, @NamedTuple{dist::Tuple{}, transform::@NamedTuple{outer::@NamedTuple{a::Int64}, inner::@NamedTuple{a::Int64}}}}, ::TaskLocalRNG, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/optimize.jl:57 [59] train_flow(::TaskLocalRNG, ::typeof(elbo), ::MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, ::var"#logp#logp##1"{DiagNormal}, ::Vararg{Any}; max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, kwargs::@Kwargs{show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:72 [60] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}, ::typeof(train_flow), ::TaskLocalRNG, ::Function, ::MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, ::Function, ::Vararg{Any}) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:54 [61] #train_flow#1 @ ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:52 [inlined] [62] kwcall(::@NamedTuple{max_iters::Int64, optimiser::Adam{Float64, Tuple{Float64, Float64}, Float64}, ADbackend::AutoMooncake{Mooncake.Config}, show_progress::Bool, callback::var"#cb#cb##0"{AutoMooncake{Mooncake.Config}, Int64}, hasconverged::var"#checkconv#checkconv##0"{Type{Float64}}}, ::typeof(train_flow), ::Function, ::MultivariateTransformed{DiagNormal, ComposedFunction{Bijectors.Shift{Vector{Float64}}, Bijectors.Scale{Vector{Float64}}}}, ::Function, ::Int64) @ NormalizingFlows ~/.julia/packages/NormalizingFlows/ydaBx/src/NormalizingFlows.jl:51 [63] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:2 [64] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1961 [inlined] [65] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:3 [inlined] [66] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [67] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:14 [inlined] [68] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:2042 [inlined] [69] macro expansion @ ~/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:30 [inlined] [70] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [71] top-level scope @ ~/.julia/packages/NormalizingFlows/ydaBx/test/runtests.jl:15 [72] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:310 [73] top-level scope @ none:6 [74] eval(m::Module, e::Any) @ Core ./boot.jl:489 [75] exec_options(opts::Base.JLOptions) @ Base ./client.jl:310 [76] _start() @ Base ./client.jl:577 Test Summary: | Pass Error Total Time testing mean-field Gaussian VI | 32 4 36 11m20.2s AutoZygote() | 8 8 2m56.6s AutoForwardDiff(chunksize=4) | 8 8 9.5s AutoForwardDiff() | 8 8 4.2s AutoReverseDiff() | 8 8 17.7s AutoEnzyme(mode=ReverseMode{false, true, false, FFIABI, false, false}(), function_annotation=Const) | 2 2 3m06.3s Float32 | 1 1 3m03.3s Float64 | 1 1 2.9s AutoMooncake(config=Mooncake.Config(false, false, false)) | 2 2 4m45.1s Float32 | 1 1 4m08.8s Float64 | 1 1 36.3s RNG of the outermost testset: Xoshiro(0x8d54d96732b58b25, 0x19126ddcc368ba6f, 0xe05d1a8882165cdf, 0x4d01e528086fb982, 0x556aebc0426d9d5b) ERROR: LoadError: Some tests did not pass: 32 passed, 0 failed, 4 errored, 0 broken. in expression starting at /home/pkgeval/.julia/packages/NormalizingFlows/ydaBx/test/interface.jl:1 in expression starting at /home/pkgeval/.julia/packages/NormalizingFlows/ydaBx/test/runtests.jl:15 Testing failed after 1495.43s ERROR: LoadError: Package NormalizingFlows errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Operations.jl:3010 [3] test @ /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Operations.jl:2859 [inlined] [4] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:572 [5] kwcall(::@NamedTuple{julia_args::Cmd, io::IOContext{IO}}, ::typeof(Pkg.API.test), ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:548 [6] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:172 [7] kwcall(::@NamedTuple{julia_args::Cmd}, ::typeof(Pkg.API.test), pkgs::Vector{PackageSpec}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:161 [8] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:160 [9] test @ /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:160 [inlined] [10] kwcall(::@NamedTuple{julia_args::Cmd}, ::typeof(Pkg.API.test), pkg::String) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:159 [11] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:237 [12] include(mod::Module, _path::String) @ Base ./Base.jl:309 [13] exec_options(opts::Base.JLOptions) @ Base ./client.jl:344 [14] _start() @ Base ./client.jl:577 in expression starting at /PkgEval.jl/scripts/evaluate.jl:228 PkgEval failed after 1828.25s: package tests unexpectedly errored