Package evaluation of InvertibleNetworks on Julia 1.10.8 (92f03a4775*) started at 2025-02-25T15:02:21.985 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 5.13s ################################################################################ # Installation # Installing InvertibleNetworks... Resolving package versions... Installed Conda ── v1.10.2 Installed PyCall ─ v1.96.4 Updating `~/.julia/environments/v1.10/Project.toml` [b7115f24] + InvertibleNetworks v2.3.0 Updating `~/.julia/environments/v1.10/Manifest.toml` [621f4979] + AbstractFFTs v1.5.0 [7f219486] + AbstractNFFTs v0.8.2 [7d9f7c33] + Accessors v0.1.41 [79e6a3ab] + Adapt v4.2.0 [66dad0bd] + AliasTables v1.1.3 [dce04be8] + ArgCheck v2.4.0 [a9b6321e] + Atomix v1.1.0 [ab4f0b2a] + BFloat16s v0.5.0 [198e06fe] + BangBang v0.4.3 [9718e550] + Baselet v0.1.1 [26cce99e] + BasicInterpolators v0.7.1 [fa961155] + CEnum v0.5.0 [052768ef] + CUDA v5.6.1 [1af6417a] + CUDA_Runtime_Discovery v0.3.5 [082447d4] + ChainRules v1.72.2 [d360d2e6] + ChainRulesCore v1.25.1 [3da002f7] + ColorTypes v0.12.0 [5ae59095] + Colors v0.13.0 [bbf7d656] + CommonSubexpressions v0.3.1 [34da2185] + Compat v4.16.0 [a33af91c] + CompositionsBase v0.1.2 [8f4d0f93] + Conda v1.10.2 [187b0558] + ConstructionBase v1.5.8 [6add18c4] + ContextVariablesX v0.1.3 [a8cc5b0e] + Crayons v4.1.1 ⌅ [717857b8] + DSP v0.7.10 [9a962f9c] + DataAPI v1.16.0 [a93c6f00] + DataFrames v1.7.0 [864edb3b] + DataStructures v0.18.20 [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 [aaf54ef3] + DistributedArrays v0.6.7 [ffbed154] + DocStringExtensions v0.9.3 [e2ba6199] + ExprTools v0.1.10 [7a1cc6ca] + FFTW v1.8.1 [cc61a311] + FLoops v0.2.2 [b9860ae5] + FLoopsBase v0.1.1 [1a297f60] + FillArrays v1.13.0 [53c48c17] + FixedPointNumbers v0.8.5 ⌅ [587475ba] + Flux v0.14.25 [f6369f11] + ForwardDiff v0.10.38 ⌅ [d9f16b24] + Functors v0.4.12 [0c68f7d7] + GPUArrays v11.2.2 [46192b85] + GPUArraysCore v0.2.0 [61eb1bfa] + GPUCompiler v1.2.0 [076d061b] + HashArrayMappedTries v0.2.0 [7869d1d1] + IRTools v0.4.14 [22cec73e] + InitialValues v0.3.1 [842dd82b] + InlineStrings v1.4.3 [505f98c9] + InplaceOps v0.3.0 [18e54dd8] + IntegerMathUtils v0.1.2 [3587e190] + InverseFunctions v0.1.17 [41ab1584] + InvertedIndices v1.3.1 [b7115f24] + InvertibleNetworks v2.3.0 [92d709cd] + IrrationalConstants v0.2.4 [c8e1da08] + IterTools v1.10.0 [42fd0dbc] + IterativeSolvers v0.9.4 [82899510] + IteratorInterfaceExtensions v1.0.0 [692b3bcd] + JLLWrappers v1.7.0 ⌅ [bb331ad6] + JOLI v0.8.5 [682c06a0] + JSON v0.21.4 [b14d175d] + JuliaVariables v0.2.4 [63c18a36] + KernelAbstractions v0.9.34 [929cbde3] + LLVM v9.2.0 [8b046642] + LLVMLoopInfo v1.0.0 [b964fa9f] + LaTeXStrings v1.4.0 [2ab3a3ac] + LogExpFunctions v0.3.29 [c2834f40] + MLCore v1.0.0 ⌃ [7e8f7934] + MLDataDevices v1.5.3 [d8e11817] + MLStyle v0.4.17 [f1d291b0] + MLUtils v0.4.7 [1914dd2f] + MacroTools v0.5.15 [c03570c3] + Memoize v0.4.4 [128add7d] + MicroCollections v0.2.0 [e1d29d7a] + Missings v1.2.0 [efe261a4] + NFFT v0.13.6 [872c559c] + NNlib v0.9.27 ⌅ [5da4648a] + NVTX v0.3.5 [77ba4419] + NaNMath v1.1.2 [71a1bf82] + NameResolution v0.1.5 [4d1e1d77] + Nullables v1.0.0 [0b1bfda6] + OneHotArrays v0.2.6 ⌅ [3bd65402] + Optimisers v0.3.4 [bac558e1] + OrderedCollections v1.8.0 [69de0a69] + Parsers v2.8.1 [f27b6e38] + Polynomials v4.0.17 [2dfb63ee] + PooledArrays v1.4.3 [aea7be01] + PrecompileTools v1.2.1 [21216c6a] + Preferences v1.4.3 [8162dcfd] + PrettyPrint v0.2.0 [08abe8d2] + PrettyTables v2.4.0 [27ebfcd6] + Primes v0.5.6 [33c8b6b6] + ProgressLogging v0.1.4 [43287f4e] + PtrArrays v1.3.0 [438e738f] + PyCall v1.96.4 [74087812] + Random123 v1.7.0 [e6cf234a] + RandomNumbers v1.6.0 [c1ae055f] + RealDot v0.1.0 [3cdcf5f2] + RecipesBase v1.3.4 [189a3867] + Reexport v1.2.2 [ae029012] + Requires v1.3.0 [7e506255] + ScopedValues v1.3.0 [6c6a2e73] + Scratch v1.2.1 [91c51154] + SentinelArrays v1.4.8 [efcf1570] + Setfield v1.1.1 [605ecd9f] + ShowCases v0.1.0 [699a6c99] + SimpleTraits v0.9.4 [a2af1166] + SortingAlgorithms v1.2.1 [dc90abb0] + SparseInverseSubset v0.1.2 [276daf66] + SpecialFunctions v2.5.0 [171d559e] + SplittablesBase v0.1.15 [90137ffa] + StaticArrays v1.9.12 [1e83bf80] + StaticArraysCore v1.4.3 [82ae8749] + StatsAPI v1.7.0 [2913bbd2] + StatsBase v0.34.4 [892a3eda] + StringManipulation v0.4.1 ⌃ [09ab397b] + StructArrays v0.6.21 [3783bdb8] + TableTraits v1.0.1 [bd369af6] + Tables v1.12.0 [a759f4b9] + TimerOutputs v0.5.27 [28d57a85] + Transducers v0.4.84 [013be700] + UnsafeAtomics v0.3.0 [81def892] + VersionParsing v1.3.0 ⌅ [29a6e085] + Wavelets v0.9.5 ⌅ [e88e6eb3] + Zygote v0.6.75 [700de1a5] + ZygoteRules v0.2.7 [02a925ec] + cuDNN v1.4.1 ⌅ [4ee394cb] + CUDA_Driver_jll v0.10.4+0 ⌅ [76a88914] + CUDA_Runtime_jll v0.15.5+0 ⌅ [62b44479] + CUDNN_jll v9.4.0+0 [f5851436] + FFTW_jll v3.3.10+3 [1d5cc7b8] + IntelOpenMP_jll v2025.0.4+0 [9c1d0b0a] + JuliaNVTXCallbacks_jll v0.2.1+0 [dad2f222] + LLVMExtra_jll v0.0.35+0 [856f044c] + MKL_jll v2025.0.1+1 [e98f9f5b] + NVTX_jll v3.1.1+0 [efe28fd5] + OpenSpecFun_jll v0.5.6+0 [1e29f10c] + demumble_jll v1.3.0+0 [1317d2d5] + oneTBB_jll v2022.0.0+0 [0dad84c5] + ArgTools v1.1.1 [56f22d72] + Artifacts [2a0f44e3] + Base64 [ade2ca70] + Dates [8ba89e20] + Distributed [f43a241f] + Downloads v1.6.0 [7b1f6079] + FileWatching [9fa8497b] + Future [b77e0a4c] + InteractiveUtils [4af54fe1] + LazyArtifacts [b27032c2] + LibCURL v0.6.4 [76f85450] + LibGit2 [8f399da3] + Libdl [37e2e46d] + LinearAlgebra [56ddb016] + Logging [d6f4376e] + Markdown [a63ad114] + Mmap [ca575930] + NetworkOptions v1.2.0 [44cfe95a] + Pkg v1.10.0 [de0858da] + Printf [3fa0cd96] + REPL [9a3f8284] + Random [ea8e919c] + SHA v0.7.0 [9e88b42a] + Serialization [1a1011a3] + SharedArrays [6462fe0b] + Sockets [2f01184e] + SparseArrays v1.10.0 [10745b16] + Statistics v1.10.0 [4607b0f0] + SuiteSparse [fa267f1f] + TOML v1.0.3 [a4e569a6] + Tar v1.10.0 [8dfed614] + Test [cf7118a7] + UUIDs [4ec0a83e] + Unicode [e66e0078] + CompilerSupportLibraries_jll v1.1.1+0 [deac9b47] + LibCURL_jll v8.4.0+0 [e37daf67] + LibGit2_jll v1.6.4+0 [29816b5a] + LibSSH2_jll v1.11.0+1 [c8ffd9c3] + MbedTLS_jll v2.28.2+1 [14a3606d] + MozillaCACerts_jll v2023.1.10 [4536629a] + OpenBLAS_jll v0.3.23+4 [05823500] + OpenLibm_jll v0.8.1+4 [bea87d4a] + SuiteSparse_jll v7.2.1+1 [83775a58] + Zlib_jll v1.2.13+1 [8e850b90] + libblastrampoline_jll v5.11.0+0 [8e850ede] + nghttp2_jll v1.52.0+1 [3f19e933] + p7zip_jll v17.4.0+2 Info Packages marked with ⌃ and ⌅ have new versions available. Those with ⌃ may be upgradable, but those with ⌅ are restricted by compatibility constraints from upgrading. To see why use `status --outdated -m` Building Conda ─→ `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/b19db3927f0db4151cb86d073689f2428e524576/build.log` Building PyCall → `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/9816a3826b0ebf49ab4926e2b18842ad8b5c8f04/build.log` Installation completed after 78.72s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 583.12s ################################################################################ # Testing # Testing InvertibleNetworks Status `/tmp/jl_HzMkS2/Project.toml` [052768ef] CUDA v5.6.1 [d360d2e6] ChainRulesCore v1.25.1 ⌅ [587475ba] Flux v0.14.25 [b7115f24] InvertibleNetworks v2.3.0 ⌅ [bb331ad6] JOLI v0.8.5 [872c559c] NNlib v0.9.27 [a759f4b9] TimerOutputs v0.5.27 ⌅ [29a6e085] Wavelets v0.9.5 [02a925ec] cuDNN v1.4.1 [37e2e46d] LinearAlgebra [9a3f8284] Random [10745b16] Statistics v1.10.0 [8dfed614] Test Status `/tmp/jl_HzMkS2/Manifest.toml` [621f4979] AbstractFFTs v1.5.0 [7f219486] AbstractNFFTs v0.8.2 [7d9f7c33] Accessors v0.1.41 [79e6a3ab] Adapt v4.2.0 [66dad0bd] AliasTables v1.1.3 [dce04be8] ArgCheck v2.4.0 [a9b6321e] Atomix v1.1.0 [ab4f0b2a] BFloat16s v0.5.0 [198e06fe] BangBang v0.4.3 [9718e550] Baselet v0.1.1 [26cce99e] BasicInterpolators v0.7.1 [fa961155] CEnum v0.5.0 [052768ef] CUDA v5.6.1 [1af6417a] CUDA_Runtime_Discovery v0.3.5 [082447d4] ChainRules v1.72.2 [d360d2e6] ChainRulesCore v1.25.1 [3da002f7] ColorTypes v0.12.0 [5ae59095] Colors v0.13.0 [bbf7d656] CommonSubexpressions v0.3.1 [34da2185] Compat v4.16.0 [a33af91c] CompositionsBase v0.1.2 [8f4d0f93] Conda v1.10.2 [187b0558] ConstructionBase v1.5.8 [6add18c4] ContextVariablesX v0.1.3 [a8cc5b0e] Crayons v4.1.1 ⌅ [717857b8] DSP v0.7.10 [9a962f9c] DataAPI v1.16.0 [a93c6f00] DataFrames v1.7.0 [864edb3b] DataStructures v0.18.20 [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 [aaf54ef3] DistributedArrays v0.6.7 [ffbed154] DocStringExtensions v0.9.3 [e2ba6199] ExprTools v0.1.10 [7a1cc6ca] FFTW v1.8.1 [cc61a311] FLoops v0.2.2 [b9860ae5] FLoopsBase v0.1.1 [1a297f60] FillArrays v1.13.0 [53c48c17] FixedPointNumbers v0.8.5 ⌅ [587475ba] Flux v0.14.25 [f6369f11] ForwardDiff v0.10.38 ⌅ [d9f16b24] Functors v0.4.12 [0c68f7d7] GPUArrays v11.2.2 [46192b85] GPUArraysCore v0.2.0 [61eb1bfa] GPUCompiler v1.2.0 [076d061b] HashArrayMappedTries v0.2.0 [7869d1d1] IRTools v0.4.14 [22cec73e] InitialValues v0.3.1 [842dd82b] InlineStrings v1.4.3 [505f98c9] InplaceOps v0.3.0 [18e54dd8] IntegerMathUtils v0.1.2 [3587e190] InverseFunctions v0.1.17 [41ab1584] InvertedIndices v1.3.1 [b7115f24] InvertibleNetworks v2.3.0 [92d709cd] IrrationalConstants v0.2.4 [c8e1da08] IterTools v1.10.0 [42fd0dbc] IterativeSolvers v0.9.4 [82899510] IteratorInterfaceExtensions v1.0.0 [692b3bcd] JLLWrappers v1.7.0 ⌅ [bb331ad6] JOLI v0.8.5 [682c06a0] JSON v0.21.4 [b14d175d] JuliaVariables v0.2.4 [63c18a36] KernelAbstractions v0.9.34 [929cbde3] LLVM v9.2.0 [8b046642] LLVMLoopInfo v1.0.0 [b964fa9f] LaTeXStrings v1.4.0 [2ab3a3ac] LogExpFunctions v0.3.29 [c2834f40] MLCore v1.0.0 ⌃ [7e8f7934] MLDataDevices v1.5.3 [d8e11817] MLStyle v0.4.17 [f1d291b0] MLUtils v0.4.7 [1914dd2f] MacroTools v0.5.15 [c03570c3] Memoize v0.4.4 [128add7d] MicroCollections v0.2.0 [e1d29d7a] Missings v1.2.0 [efe261a4] NFFT v0.13.6 [872c559c] NNlib v0.9.27 ⌅ [5da4648a] NVTX v0.3.5 [77ba4419] NaNMath v1.1.2 [71a1bf82] NameResolution v0.1.5 [4d1e1d77] Nullables v1.0.0 [0b1bfda6] OneHotArrays v0.2.6 ⌅ [3bd65402] Optimisers v0.3.4 [bac558e1] OrderedCollections v1.8.0 [69de0a69] Parsers v2.8.1 [f27b6e38] Polynomials v4.0.17 [2dfb63ee] PooledArrays v1.4.3 [aea7be01] PrecompileTools v1.2.1 [21216c6a] Preferences v1.4.3 [8162dcfd] PrettyPrint v0.2.0 [08abe8d2] PrettyTables v2.4.0 [27ebfcd6] Primes v0.5.6 [33c8b6b6] ProgressLogging v0.1.4 [43287f4e] PtrArrays v1.3.0 [438e738f] PyCall v1.96.4 [74087812] Random123 v1.7.0 [e6cf234a] RandomNumbers v1.6.0 [c1ae055f] RealDot v0.1.0 [3cdcf5f2] RecipesBase v1.3.4 [189a3867] Reexport v1.2.2 [ae029012] Requires v1.3.0 [7e506255] ScopedValues v1.3.0 [6c6a2e73] Scratch v1.2.1 [91c51154] SentinelArrays v1.4.8 [efcf1570] Setfield v1.1.1 [605ecd9f] ShowCases v0.1.0 [699a6c99] SimpleTraits v0.9.4 [a2af1166] SortingAlgorithms v1.2.1 [dc90abb0] SparseInverseSubset v0.1.2 [276daf66] SpecialFunctions v2.5.0 [171d559e] SplittablesBase v0.1.15 [90137ffa] StaticArrays v1.9.12 [1e83bf80] StaticArraysCore v1.4.3 [82ae8749] StatsAPI v1.7.0 [2913bbd2] StatsBase v0.34.4 [892a3eda] StringManipulation v0.4.1 ⌃ [09ab397b] StructArrays v0.6.21 [3783bdb8] TableTraits v1.0.1 [bd369af6] Tables v1.12.0 [a759f4b9] TimerOutputs v0.5.27 [28d57a85] Transducers v0.4.84 [013be700] UnsafeAtomics v0.3.0 [81def892] VersionParsing v1.3.0 ⌅ [29a6e085] Wavelets v0.9.5 ⌅ [e88e6eb3] Zygote v0.6.75 [700de1a5] ZygoteRules v0.2.7 [02a925ec] cuDNN v1.4.1 ⌅ [4ee394cb] CUDA_Driver_jll v0.10.4+0 ⌅ [76a88914] CUDA_Runtime_jll v0.15.5+0 ⌅ [62b44479] CUDNN_jll v9.4.0+0 [f5851436] FFTW_jll v3.3.10+3 [1d5cc7b8] IntelOpenMP_jll v2025.0.4+0 [9c1d0b0a] JuliaNVTXCallbacks_jll v0.2.1+0 [dad2f222] LLVMExtra_jll v0.0.35+0 [856f044c] MKL_jll v2025.0.1+1 [e98f9f5b] NVTX_jll v3.1.1+0 [efe28fd5] OpenSpecFun_jll v0.5.6+0 [1e29f10c] demumble_jll v1.3.0+0 [1317d2d5] oneTBB_jll v2022.0.0+0 [0dad84c5] ArgTools v1.1.1 [56f22d72] Artifacts [2a0f44e3] Base64 [ade2ca70] Dates [8ba89e20] Distributed [f43a241f] Downloads v1.6.0 [7b1f6079] FileWatching [9fa8497b] Future [b77e0a4c] InteractiveUtils [4af54fe1] LazyArtifacts [b27032c2] LibCURL v0.6.4 [76f85450] LibGit2 [8f399da3] Libdl [37e2e46d] LinearAlgebra [56ddb016] Logging [d6f4376e] Markdown [a63ad114] Mmap [ca575930] NetworkOptions v1.2.0 [44cfe95a] Pkg v1.10.0 [de0858da] Printf [3fa0cd96] REPL [9a3f8284] Random [ea8e919c] SHA v0.7.0 [9e88b42a] Serialization [1a1011a3] SharedArrays [6462fe0b] Sockets [2f01184e] SparseArrays v1.10.0 [10745b16] Statistics v1.10.0 [4607b0f0] SuiteSparse [fa267f1f] TOML v1.0.3 [a4e569a6] Tar v1.10.0 [8dfed614] Test [cf7118a7] UUIDs [4ec0a83e] Unicode [e66e0078] CompilerSupportLibraries_jll v1.1.1+0 [deac9b47] LibCURL_jll v8.4.0+0 [e37daf67] LibGit2_jll v1.6.4+0 [29816b5a] LibSSH2_jll v1.11.0+1 [c8ffd9c3] MbedTLS_jll v2.28.2+1 [14a3606d] MozillaCACerts_jll v2023.1.10 [4536629a] OpenBLAS_jll v0.3.23+4 [05823500] OpenLibm_jll v0.8.1+4 [bea87d4a] SuiteSparse_jll v7.2.1+1 [83775a58] Zlib_jll v1.2.13+1 [8e850b90] libblastrampoline_jll v5.11.0+0 [8e850ede] nghttp2_jll v1.52.0+1 [3f19e933] p7zip_jll v17.4.0+2 Info Packages marked with ⌃ and ⌅ have new versions available. Those with ⌃ may be upgradable, but those with ⌅ are restricted by compatibility constraints from upgrading. Testing Running tests... Gradient test mse loss 229.79883; 25.129562 121.181885; 6.2823105 62.161377; 1.5707207 31.473145; 0.39290428 15.834961; 0.09806347 7.9416504; 0.024861813 Gradient test log likelihood 59.04547; 6.2016144 31.073242; 1.5503006 15.924316; 0.387455 8.05957; 0.096315384 4.053955; 0.02398777 2.033081; 0.0058903694 Gradient test sequential network: input 202.74756; 93.41455 124.76465; 23.316406 68.19653; 5.843994 35.529053; 1.4912109 18.133057; 0.3770752 Gradient test sequential network: parameters 75.58472; 79.49957 21.843506; 23.800934 5.517334; 6.4960475 1.1904297; 1.6797864 0.18359375; 0.42827216 Jacobian test 120.2537; 22.813396 58.558975; 7.012685 28.92853; 2.2621448 14.3773575; 0.7489061 7.1690745; 0.24536462 Gradient test convolutions 0.0029493421; 1.4828984e-5 0.001478374; 3.7115533e-6 0.0007401258; 9.170035e-7 0.00037029386; 2.2753375e-7 0.00018520653; 5.416223e-8 9.262562e-5; 4.7293724e-9 Gradient test convolutions 13.180115; 0.06612301 6.6065674; 0.016551495 3.307434; 0.0041253567 1.6547852; 0.0009945631 0.8276367; 0.00025314093 0.41394043; 4.5001507e-6 WARNING: Method definition objective(Any, Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_nnlib_convolution.jl:69 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_nnlib_convolution.jl:136. Gradient test convolutions 0.0007096566; 3.5681878e-6 0.0003557168; 8.956122e-7 0.0001780875; 2.1870073e-7 8.909404e-5; 5.9058948e-8 4.4558197e-5; 1.8353603e-8 2.2284687e-5; 3.588866e-9 Gradient test convolutions 121.876465; 0.6123886 61.09131; 0.15311813 30.583984; 0.03822899 15.302246; 0.008860588 7.6533203; 0.0022330284 3.8276367; 0.0001399517 Gradient test leaky ReLU 0.13865846; 0.010026902 0.071787; 0.0025556833 0.03649968; 0.0006716624 0.01841247; 0.00017319992 0.009245932; 4.6903268e-5 WARNING: Method definition objective(Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:27 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:69. Gradient test ReLU 0.1386134; 0.010428384 0.07172501; 0.0027958825 0.036568522; 0.00069192424 0.018462598; 0.00016762502 0.0092763305; 3.8781203e-5 WARNING: Method definition objective(Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:69 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:116. Gradient test Sigmoid 0.029895484; 0.0015692078 0.0153401345; 0.0003922116 0.0077681392; 9.803381e-5 0.0039085597; 2.4526846e-5 0.0019604415; 6.1017927e-6 WARNING: Method definition objective(Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:116 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:163. Gradient test scaled and shifted Sigmoid 0.0075760894; 0.00039768033 0.003887482; 9.940285e-5 0.0019686073; 2.4835113e-5 0.0009905063; 6.2149484e-6 0.0004968047; 1.5558908e-6 WARNING: Method definition objective(Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:163 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:206. Gradient test GaLU 0.06599021; 0.0034770817 0.03386429; 0.0008693561 0.017149448; 0.00021737441 0.008629054; 5.4357573e-5 0.0043281317; 1.35740265e-5 WARNING: Method definition objective(Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:206 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:250. Gradient test Sigmoid2 herehere33.623505; 0.29974365 here16.903702; 0.057922363 here8.468369; 0.0124435425 here4.237549; 0.0028572083 here2.119522; 0.00068092346 WARNING: Method definition objective(Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:250 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_activations.jl:298. Gradient test ExpClamp 1.0582552; 0.055853724 0.5430875; 0.013966978 0.2750349; 0.0034923255 0.13839054; 0.00087307394 0.069413185; 0.00021862239 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_sequential.jl:67 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_flux.jl:22. ┌ Warning: This type should probably now use `Flux.@layer` instead of `@functor`: ActNorm │ caller = ip:0x0 └ @ Core :-1 ┌ Warning: Assignment to `grads` in soft scope is ambiguous because a global variable by the same name exists: `grads` will be treated as a new local. Disambiguate by using `local grads` to suppress this warning or `global grads` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_flux.jl:41 [ Info: Loss: 0.00015702673 [ Info: Loss: 0.00058343605 [ Info: Loss: 0.0012660496 [ Info: Loss: 0.0021605587 [ Info: Loss: 0.0031654276 Test Summary: | Pass Total Time Basics | 104 104 6m46.9s Test test_utils/test_objectives.jl | 4 4 14.4s Test test_utils/test_sequential.jl | 13 13 2m40.0s Test test_utils/test_nnlib_convolution.jl | 10 10 11.1s Test test_utils/test_activations.jl | 19 19 29.0s Test test_utils/test_squeeze.jl | 19 19 55.8s Test test_utils/test_jacobian.jl | 2 2 1.4s Test test_utils/test_chainrules.jl | 2 2 1m51.5s Test test_utils/test_flux.jl | 35 35 23.7s ┌ Warning: Assignment to `X` in soft scope is ambiguous because a global variable by the same name exists: `X` will be treated as a new local. Disambiguate by using `local X` to suppress this warning or `global X` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:22 ┌ Warning: Assignment to `X0` in soft scope is ambiguous because a global variable by the same name exists: `X0` will be treated as a new local. Disambiguate by using `local X0` to suppress this warning or `global X0` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:23 ┌ Warning: Assignment to `dX` in soft scope is ambiguous because a global variable by the same name exists: `dX` will be treated as a new local. Disambiguate by using `local dX` to suppress this warning or `global dX` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:24 ┌ Warning: Assignment to `Y` in soft scope is ambiguous because a global variable by the same name exists: `Y` will be treated as a new local. Disambiguate by using `local Y` to suppress this warning or `global Y` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:49 ┌ Warning: Assignment to `f0` in soft scope is ambiguous because a global variable by the same name exists: `f0` will be treated as a new local. Disambiguate by using `local f0` to suppress this warning or `global f0` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:64 ┌ Warning: Assignment to `ΔX` in soft scope is ambiguous because a global variable by the same name exists: `ΔX` will be treated as a new local. Disambiguate by using `local ΔX` to suppress this warning or `global ΔX` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:64 ┌ Warning: Assignment to `h` in soft scope is ambiguous because a global variable by the same name exists: `h` will be treated as a new local. Disambiguate by using `local h` to suppress this warning or `global h` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:65 ┌ Warning: Assignment to `maxiter` in soft scope is ambiguous because a global variable by the same name exists: `maxiter` will be treated as a new local. Disambiguate by using `local maxiter` to suppress this warning or `global maxiter` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:66 ┌ Warning: Assignment to `err1` in soft scope is ambiguous because a global variable by the same name exists: `err1` will be treated as a new local. Disambiguate by using `local err1` to suppress this warning or `global err1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:67 ┌ Warning: Assignment to `err2` in soft scope is ambiguous because a global variable by the same name exists: `err2` will be treated as a new local. Disambiguate by using `local err2` to suppress this warning or `global err2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:68 ┌ Warning: Assignment to `err3` in soft scope is ambiguous because a global variable by the same name exists: `err3` will be treated as a new local. Disambiguate by using `local err3` to suppress this warning or `global err3` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:88 ┌ Warning: Assignment to `err4` in soft scope is ambiguous because a global variable by the same name exists: `err4` will be treated as a new local. Disambiguate by using `local err4` to suppress this warning or `global err4` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:89 ┌ Warning: Assignment to `err5` in soft scope is ambiguous because a global variable by the same name exists: `err5` will be treated as a new local. Disambiguate by using `local err5` to suppress this warning or `global err5` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:112 ┌ Warning: Assignment to `err6` in soft scope is ambiguous because a global variable by the same name exists: `err6` will be treated as a new local. Disambiguate by using `local err6` to suppress this warning or `global err6` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:113 ┌ Warning: Assignment to `θ` in soft scope is ambiguous because a global variable by the same name exists: `θ` will be treated as a new local. Disambiguate by using `local θ` to suppress this warning or `global θ` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:141 ┌ Warning: Assignment to `dθ` in soft scope is ambiguous because a global variable by the same name exists: `dθ` will be treated as a new local. Disambiguate by using `local dθ` to suppress this warning or `global dθ` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:145 ┌ Warning: Assignment to `dY` in soft scope is ambiguous because a global variable by the same name exists: `dY` will be treated as a new local. Disambiguate by using `local dY` to suppress this warning or `global dY` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:149 ┌ Warning: Assignment to `dY_` in soft scope is ambiguous because a global variable by the same name exists: `dY_` will be treated as a new local. Disambiguate by using `local dY_` to suppress this warning or `global dY_` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:173 ┌ Warning: Assignment to `dX_` in soft scope is ambiguous because a global variable by the same name exists: `dX_` will be treated as a new local. Disambiguate by using `local dX_` to suppress this warning or `global dX_` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:174 ┌ Warning: Assignment to `dθ_` in soft scope is ambiguous because a global variable by the same name exists: `dθ_` will be treated as a new local. Disambiguate by using `local dθ_` to suppress this warning or `global dθ_` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:174 ┌ Warning: Assignment to `a` in soft scope is ambiguous because a global variable by the same name exists: `a` will be treated as a new local. Disambiguate by using `local a` to suppress this warning or `global a` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:175 ┌ Warning: Assignment to `b` in soft scope is ambiguous because a global variable by the same name exists: `b` will be treated as a new local. Disambiguate by using `local b` to suppress this warning or `global b` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_residual_block.jl:176 Testing activation InvertibleNetworks.ActivationFunction(InvertibleNetworks.ReLU, nothing, InvertibleNetworks.ReLUgrad) Gradient test convolutions 0.045305222; 0.0014301948 0.023012549; 0.00034981035 0.01159358; 9.003002e-5 0.005819738; 2.2596214e-5 0.0029147267; 3.731111e-6 Gradient test convolutions 83.95273; 5.8751755 43.409363; 1.5045891 22.072662; 0.38431358 11.1315; 0.096987724 5.589905; 0.024339199 Gradient test convolutions 29.625458; 0.75169086 14.947876; 0.24069834 7.534088; 0.060199022 3.7821655; 0.014978051 1.8947754; 0.0037963986 Jacobian test 10.057255; 2.4782062 5.0147734; 0.8396366 2.50392; 0.28040528 1.2519965; 0.09685614 0.62561893; 0.032558538 Testing activation InvertibleNetworks.ActivationFunction(InvertibleNetworks.LeakyReLU, InvertibleNetworks.LeakyReLUinv, InvertibleNetworks.LeakyReLUgrad) Gradient test convolutions 0.017455742; 0.0005532373 0.008866176; 0.00013829768 0.004467666; 3.4569297e-5 0.0022424608; 8.622417e-6 0.0011233389; 2.097222e-6 Gradient test convolutions 91.18118; 8.325516 47.628906; 2.124443 24.341125; 0.53554916 12.304169; 0.13416862 6.185547; 0.033621788 Gradient test convolutions 22.616955; 4.0246267 12.298904; 1.0218863 6.4029922; 0.25740314 3.2655869; 0.06461084 1.6489105; 0.016188323 Jacobian test 3.4693124; 1.0245962 1.7671852; 0.3426302 0.8923431; 0.12186899 0.44741184; 0.044567224 0.22405875; 0.01658354 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_flux.jl:22 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_flux_block.jl:37. Gradient test convolutions 0.3953874; 0.020809412 0.20289636; 0.005202055 0.10274899; 0.0013002157 0.051699877; 0.0003247261 0.02593112; 8.1181526e-5 Gradient test convolutions 0.1872629; 0.020615578 0.0987854; 0.005153835 0.050681114; 0.0012885034 0.02566266; 0.0003221482 0.012911916; 8.048862e-5 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_flux_block.jl:37 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_resnet.jl:28. Gradient test 1.3766875; 0.094723105 0.711761; 0.023944318 0.36179876; 0.0060538948 0.18251944; 0.0014068931 0.091591835; 0.0003713295 Gradient test convolutions 5.2941422; 2.8783927 1.7697768; 0.56190205 0.72754526; 0.123607874 0.33079958; 0.028830886 0.15806913; 0.007084787 WARNING: Method definition loss(Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_utils/test_chainrules.jl:49 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_layer_conv1x1.jl:97. Gradient test ΔX 126.54053; 0.63575745 63.429688; 0.1584549 31.754395; 0.039676666 15.887695; 0.009340286 7.9467773; 0.0017404556 Gradient test Δv1 (dot(Δv1, Δv1), dot(Δv2, Δv2), dot(Δv3, Δv3)) = (212595.77f0, 3.4147162f6, 1.8465046f6) 4.1030273; 0.13858986 2.0874023; 0.033406258 1.0522461; 0.008158207 0.5283203; 0.0018818378 0.26464844; 0.00045263767 WARNING: Method definition loss(Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_layer_conv1x1.jl:97 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_layer_conv1x1.jl:158. Gradient test ΔX 64.52051; 0.6362152 32.419434; 0.15892792 16.249023; 0.040157318 8.134766; 0.009824753 4.069824; 0.0024709702 Gradient test Δv1 50.98633; 3.204895 26.3042; 0.79141235 13.351074; 0.19673157 6.7248535; 0.049049377 3.3740234; 0.012928009 Jacobian test 44.56233; 7.934799 22.304296; 1.9899396 11.131738; 0.49690723 5.5575395; 0.12406407 2.7762816; 0.030985385 1.3874655; 0.007745586 0.6935638; 0.0019362196 Jacobian (inverse) test 44.725784; 8.003789 22.385923; 2.0073106 11.172319; 0.50125474 5.577747; 0.12515168 2.7863612; 0.0312582 1.3924991; 0.007814421 0.6960792; 0.0019540677 Gradient test coupling layer 305.74512; 17.10617 157.11646; 4.309189 79.606445; 1.1063766 40.05591; 0.30050278 20.104492; 0.0737133 10.072266; 0.01683712 Gradient test coupling layer 3.204895; 3.907508 0.79730225; 1.1486087 0.1638794; 0.3395326 0.008850098; 0.09667671 WARNING: Method definition loss(Any, Any, Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_basic.jl:93 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_basic.jl:164. Gradient test coupling layer 1053.634; 50.55182 540.49365; 11.599274 273.9165; 2.129959 137.6377; 0.3855362 68.9126; 0.0990181 34.461914; 0.043893814 Gradient test coupling layer 63.8468; 12.1818695 34.778687; 3.235649 18.250183; 0.7569847 9.398926; 0.10465813 Jacobian test 6.6104364; 0.8859867 3.2506096; 0.29435062 1.6108418; 0.09653996 0.7999984; 0.032375693 0.39905566; 0.013352332 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_resnet.jl:28 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_irim.jl:40. Gradient test invertible layer 2404.5254; 126.58569 1233.8984; 31.657104 624.8711; 7.9066772 314.41602; 1.9728699 157.70215; 0.4922943 Gradient test invertible layer 11.240784; 3.1740193 6.341858; 0.8655436 3.3774185; 0.22628224 1.7436256; 0.058224678 0.8863716; 0.014553547 Gradient test invertible layer 0.98441315; 0.009997129 0.49370193; 0.006493926 0.24530792; 0.001703918 0.122306824; 0.00050482154 Jacobian test 11.276266; 0.67187417 5.639334; 0.18685128 2.8196445; 0.052825127 1.4096178; 0.014610171 0.70469093; 0.0036081967 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_irim.jl:40 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:37. Gradient test coupling layer 315.87256; 17.262146 255.68506; 10.822723 206.39453; 6.811676 166.26855; 4.296417 133.72266; 2.7293243 107.43286; 1.7287292 ┌ Warning: Assignment to `X` in soft scope is ambiguous because a global variable by the same name exists: `X` will be treated as a new local. Disambiguate by using `local X` to suppress this warning or `global X` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:88 ┌ Warning: Assignment to `Y` in soft scope is ambiguous because a global variable by the same name exists: `Y` will be treated as a new local. Disambiguate by using `local Y` to suppress this warning or `global Y` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:89 ┌ Warning: Assignment to `L02` in soft scope is ambiguous because a global variable by the same name exists: `L02` will be treated as a new local. Disambiguate by using `local L02` to suppress this warning or `global L02` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:91 ┌ Warning: Assignment to `Lini` in soft scope is ambiguous because a global variable by the same name exists: `Lini` will be treated as a new local. Disambiguate by using `local Lini` to suppress this warning or `global Lini` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:92 ┌ Warning: Assignment to `dW1` in soft scope is ambiguous because a global variable by the same name exists: `dW1` will be treated as a new local. Disambiguate by using `local dW1` to suppress this warning or `global dW1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:93 ┌ Warning: Assignment to `dW2` in soft scope is ambiguous because a global variable by the same name exists: `dW2` will be treated as a new local. Disambiguate by using `local dW2` to suppress this warning or `global dW2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:94 ┌ Warning: Assignment to `dW3` in soft scope is ambiguous because a global variable by the same name exists: `dW3` will be treated as a new local. Disambiguate by using `local dW3` to suppress this warning or `global dW3` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:95 ┌ Warning: Assignment to `f0` in soft scope is ambiguous because a global variable by the same name exists: `f0` will be treated as a new local. Disambiguate by using `local f0` to suppress this warning or `global f0` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:97 ┌ Warning: Assignment to `ΔX` in soft scope is ambiguous because a global variable by the same name exists: `ΔX` will be treated as a new local. Disambiguate by using `local ΔX` to suppress this warning or `global ΔX` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:97 ┌ Warning: Assignment to `Δv1` in soft scope is ambiguous because a global variable by the same name exists: `Δv1` will be treated as a new local. Disambiguate by using `local Δv1` to suppress this warning or `global Δv1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:97 ┌ Warning: Assignment to `Δv2` in soft scope is ambiguous because a global variable by the same name exists: `Δv2` will be treated as a new local. Disambiguate by using `local Δv2` to suppress this warning or `global Δv2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:97 ┌ Warning: Assignment to `Δv3` in soft scope is ambiguous because a global variable by the same name exists: `Δv3` will be treated as a new local. Disambiguate by using `local Δv3` to suppress this warning or `global Δv3` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:97 ┌ Warning: Assignment to `ΔW1` in soft scope is ambiguous because a global variable by the same name exists: `ΔW1` will be treated as a new local. Disambiguate by using `local ΔW1` to suppress this warning or `global ΔW1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:97 ┌ Warning: Assignment to `ΔW2` in soft scope is ambiguous because a global variable by the same name exists: `ΔW2` will be treated as a new local. Disambiguate by using `local ΔW2` to suppress this warning or `global ΔW2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:97 ┌ Warning: Assignment to `ΔW3` in soft scope is ambiguous because a global variable by the same name exists: `ΔW3` will be treated as a new local. Disambiguate by using `local ΔW3` to suppress this warning or `global ΔW3` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:97 ┌ Warning: Assignment to `h` in soft scope is ambiguous because a global variable by the same name exists: `h` will be treated as a new local. Disambiguate by using `local h` to suppress this warning or `global h` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:98 ┌ Warning: Assignment to `maxiter` in soft scope is ambiguous because a global variable by the same name exists: `maxiter` will be treated as a new local. Disambiguate by using `local maxiter` to suppress this warning or `global maxiter` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:99 ┌ Warning: Assignment to `err3` in soft scope is ambiguous because a global variable by the same name exists: `err3` will be treated as a new local. Disambiguate by using `local err3` to suppress this warning or `global err3` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:100 ┌ Warning: Assignment to `err4` in soft scope is ambiguous because a global variable by the same name exists: `err4` will be treated as a new local. Disambiguate by using `local err4` to suppress this warning or `global err4` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:101 ┌ Warning: Assignment to `factor1` in soft scope is ambiguous because a global variable by the same name exists: `factor1` will be treated as a new local. Disambiguate by using `local factor1` to suppress this warning or `global factor1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:115 ┌ Warning: Assignment to `factor2` in soft scope is ambiguous because a global variable by the same name exists: `factor2` will be treated as a new local. Disambiguate by using `local factor2` to suppress this warning or `global factor2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:116 Gradient test coupling layer 5.4084473; 1.9223351 4.2021484; 1.413259 3.2226562; 0.9915447 2.4811401; 0.6962507 Gradient test coupling layer 7.447876; 0.71444416 5.948181; 0.5614357 4.687805; 0.3784089 3.692505; 0.24498796 Gradient test coupling layer 4.674988; 0.035463333 3.820984; 0.10936403 3.076477; 0.10718131 2.449707; 0.07427049 ┌ Warning: Assignment to `X` in soft scope is ambiguous because a global variable by the same name exists: `X` will be treated as a new local. Disambiguate by using `local X` to suppress this warning or `global X` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:132 ┌ Warning: Assignment to `Y` in soft scope is ambiguous because a global variable by the same name exists: `Y` will be treated as a new local. Disambiguate by using `local Y` to suppress this warning or `global Y` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:133 ┌ Warning: Assignment to `L01` in soft scope is ambiguous because a global variable by the same name exists: `L01` will be treated as a new local. Disambiguate by using `local L01` to suppress this warning or `global L01` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:134 ┌ Warning: Assignment to `Lini` in soft scope is ambiguous because a global variable by the same name exists: `Lini` will be treated as a new local. Disambiguate by using `local Lini` to suppress this warning or `global Lini` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:135 ┌ Warning: Assignment to `dv1` in soft scope is ambiguous because a global variable by the same name exists: `dv1` will be treated as a new local. Disambiguate by using `local dv1` to suppress this warning or `global dv1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:136 ┌ Warning: Assignment to `dv2` in soft scope is ambiguous because a global variable by the same name exists: `dv2` will be treated as a new local. Disambiguate by using `local dv2` to suppress this warning or `global dv2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:137 ┌ Warning: Assignment to `dv3` in soft scope is ambiguous because a global variable by the same name exists: `dv3` will be treated as a new local. Disambiguate by using `local dv3` to suppress this warning or `global dv3` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:138 ┌ Warning: Assignment to `f0` in soft scope is ambiguous because a global variable by the same name exists: `f0` will be treated as a new local. Disambiguate by using `local f0` to suppress this warning or `global f0` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:140 ┌ Warning: Assignment to `ΔX` in soft scope is ambiguous because a global variable by the same name exists: `ΔX` will be treated as a new local. Disambiguate by using `local ΔX` to suppress this warning or `global ΔX` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:140 ┌ Warning: Assignment to `Δv1` in soft scope is ambiguous because a global variable by the same name exists: `Δv1` will be treated as a new local. Disambiguate by using `local Δv1` to suppress this warning or `global Δv1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:140 ┌ Warning: Assignment to `Δv2` in soft scope is ambiguous because a global variable by the same name exists: `Δv2` will be treated as a new local. Disambiguate by using `local Δv2` to suppress this warning or `global Δv2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:140 ┌ Warning: Assignment to `Δv3` in soft scope is ambiguous because a global variable by the same name exists: `Δv3` will be treated as a new local. Disambiguate by using `local Δv3` to suppress this warning or `global Δv3` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:140 ┌ Warning: Assignment to `ΔW1` in soft scope is ambiguous because a global variable by the same name exists: `ΔW1` will be treated as a new local. Disambiguate by using `local ΔW1` to suppress this warning or `global ΔW1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:140 ┌ Warning: Assignment to `ΔW2` in soft scope is ambiguous because a global variable by the same name exists: `ΔW2` will be treated as a new local. Disambiguate by using `local ΔW2` to suppress this warning or `global ΔW2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:140 ┌ Warning: Assignment to `ΔW3` in soft scope is ambiguous because a global variable by the same name exists: `ΔW3` will be treated as a new local. Disambiguate by using `local ΔW3` to suppress this warning or `global ΔW3` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:140 ┌ Warning: Assignment to `h` in soft scope is ambiguous because a global variable by the same name exists: `h` will be treated as a new local. Disambiguate by using `local h` to suppress this warning or `global h` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:141 ┌ Warning: Assignment to `maxiter` in soft scope is ambiguous because a global variable by the same name exists: `maxiter` will be treated as a new local. Disambiguate by using `local maxiter` to suppress this warning or `global maxiter` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:142 ┌ Warning: Assignment to `err5` in soft scope is ambiguous because a global variable by the same name exists: `err5` will be treated as a new local. Disambiguate by using `local err5` to suppress this warning or `global err5` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:143 ┌ Warning: Assignment to `err6` in soft scope is ambiguous because a global variable by the same name exists: `err6` will be treated as a new local. Disambiguate by using `local err6` to suppress this warning or `global err6` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:144 ┌ Warning: Assignment to `factor1` in soft scope is ambiguous because a global variable by the same name exists: `factor1` will be treated as a new local. Disambiguate by using `local factor1` to suppress this warning or `global factor1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:158 ┌ Warning: Assignment to `factor2` in soft scope is ambiguous because a global variable by the same name exists: `factor2` will be treated as a new local. Disambiguate by using `local factor2` to suppress this warning or `global factor2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:159 Gradient test coupling layer 45.864258; 6.49531 35.88452; 4.3893623 28.015625; 2.819497 22.069336; 1.9124341 Gradient test coupling layer 19.592041; 214.82047 15.358154; 172.17186 12.182617; 137.84138 9.361084; 110.65812 Gradient test coupling layer 28.604004; 296.34155 22.998047; 236.9584 18.476562; 189.48859 14.701172; 151.67094 Jacobian test 16.323702; 4.674478 13.1139345; 3.2213886 10.519557; 2.227901 8.431119; 1.5376899 6.7572203; 1.0598322 5.416492; 0.729236 4.337446; 0.49880704 Gradient test coupling layer 9.891983; 0.6115942 5.0983887; 0.15339994 2.5874863; 0.03840804 1.3033295; 0.009617686 0.6540756; 0.0023979545 0.32764435; 0.00059244037 Gradient test coupling layer 5.050728; 0.27723122 2.5948792; 0.06910038 1.3147392; 0.017250538 0.66168976; 0.0043051243 Gradient test weights for permute=none, reverse=true, logdet=true 3.0108337; 2.787652 2.2583923; 0.64085054 1.295105; 0.15451646 0.69055176; 0.03425896 0.3544922; 0.007913172 Gradient test ΔX for permute=none, reverse=true, logdet=true 14.13501; 11.885458 4.1634216; 3.0386455 1.3605957; 0.79820764 0.48223877; 0.20104474 0.19232178; 0.05172476 Gradient test ΔX for permute=none, reverse=true, logdet=true 7.784546; 11.165292 1.1627197; 2.8530927 0.10144043; 0.7437461 0.23120117; 0.1913921 0.1616211; 0.04967554 Gradient test ΔX for permute=none, reverse=true, logdet=true 12.332336; 11.690671 3.1960144; 2.8751817 0.93362427; 0.7732079 0.2960205; 0.21581233 0.09725952; 0.05715543 Gradient test weights for permute=none, reverse=false, logdet=true 0.44430542; 0.3119377 0.17175293; 0.10556906 0.07897949; 0.045887556 0.028778076; 0.012232108 0.01083374; 0.0025607562 Gradient test ΔX for permute=none, reverse=false, logdet=true 3.6669006; 4.3880105 0.761322; 1.121877 0.100097656; 0.2803751 0.01864624; 0.07149248 0.026611328; 0.018458031 Gradient test ΔX for permute=none, reverse=false, logdet=true 4.4631653; 3.5825386 1.3358765; 0.89556307 0.44360352; 0.22344682 0.1619873; 0.051908955 0.068481445; 0.01344227 Gradient test ΔX for permute=none, reverse=false, logdet=true 4.204132; 3.9644701 1.0759583; 0.9561273 0.27011108; 0.21019562 0.0736084; 0.043650664 0.025390625; 0.010411757 Gradient test weights for permute=none, reverse=true, logdet=false 8.953348; 9.9907875 7.026106; 2.445962 4.132532; 0.6035018 2.2085457; 0.15947127 1.1428928; 0.04111564 Gradient test ΔX for permute=none, reverse=true, logdet=false 29.165527; 23.790709 8.803711; 6.1163015 2.960205; 1.6165003 1.0814819; 0.40962952 0.44213867; 0.10621247 Gradient test ΔX for permute=none, reverse=true, logdet=false 13.404419; 18.974258 2.0375977; 4.822517 0.12365723; 1.2688024 0.37298584; 0.32324398 0.26348877; 0.08462614 Gradient test ΔX for permute=none, reverse=true, logdet=false 23.749512; 20.967873 6.5480957; 5.157276 2.0905762; 1.3951664 0.73950195; 0.39179704 0.27972412; 0.10587166 Gradient test weights for permute=none, reverse=false, logdet=false 2.385327; 2.6270292 1.8618262; 0.64435196 1.09165; 0.16143906 0.58538723; 0.041157305 0.3030343; 0.010237962 Gradient test ΔX for permute=none, reverse=false, logdet=false 6.438385; 8.756319 1.0460205; 2.2049878 0.038604736; 0.5408789 0.15390015; 0.13584167 0.11010742; 0.034763485 Gradient test ΔX for permute=none, reverse=false, logdet=false 11.090912; 10.521312 2.9595947; 2.6747944 0.8081665; 0.6657664 0.23501587; 0.16381583 0.07757568; 0.04197566 Gradient test ΔX for permute=none, reverse=false, logdet=false 9.323303; 10.342289 1.9953918; 2.5048845 0.31680298; 0.5715493 0.0004272461; 0.12694593 0.03466797; 0.029018618 Gradient test weights for permute=lower, reverse=true, logdet=true 7.325592; 4.854825 5.0294495; 1.0607591 2.796051; 0.24905324 1.4597168; 0.062835336 0.74716187; 0.014114201 Gradient test ΔX for permute=lower, reverse=true, logdet=true 14.134949; 11.885398 4.163452; 3.0386767 1.3605957; 0.79820794 0.48233032; 0.20113644 0.19244385; 0.051846907 Gradient test ΔX for permute=lower, reverse=true, logdet=true 7.784668; 11.165413 1.1626587; 2.8530312 0.10116577; 0.74402046 0.23104858; 0.19154453 0.16159058; 0.049705982 Gradient test ΔX for permute=lower, reverse=true, logdet=true 12.332184; 11.690516 3.1958618; 2.8750284 0.9335022; 0.7730855 0.29580688; 0.21559851 0.09713745; 0.057033263 Gradient test weights for permute=lower, reverse=false, logdet=true 2.492859; 1.2575078 1.6025391; 0.27264428 0.86572266; 0.071869016 0.45108032; 0.017715514 0.22729492; 0.007102996 Gradient test ΔX for permute=lower, reverse=false, logdet=true 4.1612854; 4.0570865 1.0841675; 1.0320681 0.29229736; 0.2662477 0.081085205; 0.06806036 0.023864746; 0.017352324 Gradient test ΔX for permute=lower, reverse=false, logdet=true 4.625244; 3.9207382 1.3451538; 0.99290085 0.42642212; 0.25029564 0.14685059; 0.05878734 0.059570312; 0.015538689 Gradient test ΔX for permute=lower, reverse=false, logdet=true 2.595459; 2.509299 0.66519165; 0.6221117 0.17071533; 0.14917536 0.044311523; 0.033541538 0.013458252; 0.008073258 Gradient test weights for permute=lower, reverse=true, logdet=false 2.474319; 2.0979023 1.7043066; 0.58180404 0.99484634; 0.14820898 0.5359955; 0.035532176 0.27501392; 0.010749906 Gradient test ΔX for permute=lower, reverse=true, logdet=false 29.165527; 23.79071 8.803589; 6.1161804 2.960205; 1.6165009 1.0814819; 0.40962982 0.4420166; 0.106090546 Gradient test ΔX for permute=lower, reverse=true, logdet=false 13.404419; 18.974257 2.0375977; 4.8225164 0.12365723; 1.2688022 0.37298584; 0.32324386 0.26348877; 0.08462608 Gradient test ΔX for permute=lower, reverse=true, logdet=false 23.749512; 20.96787 6.548218; 5.1573973 2.0906982; 1.3952879 0.73950195; 0.39179677 0.27972412; 0.10587153 Gradient test weights for permute=lower, reverse=false, logdet=false 0.7211319; 0.59562516 0.49473166; 0.16364688 0.2837956; 0.045393676 0.15347719; 0.011117443 0.07921767; 0.0030796453 Gradient test ΔX for permute=lower, reverse=false, logdet=false 7.427109; 8.094427 1.6917572; 2.0254161 0.3457489; 0.51257837 0.04536438; 0.12877913 0.009094238; 0.032613136 Gradient test ΔX for permute=lower, reverse=false, logdet=false 11.415009; 11.197651 2.9781494; 2.8694704 0.7737732; 0.71943367 0.20462036; 0.17745061 0.0597229; 0.046138026 Gradient test ΔX for permute=lower, reverse=false, logdet=false 6.10614; 7.4321303 1.1741486; 1.8371437 0.11810303; 0.44960055 0.058685303; 0.10706346 0.058532715; 0.024341665 Gradient test weights for permute=both, reverse=true, logdet=true 2.4151306; 2.10353 1.8240356; 0.43529463 1.0346985; 0.09496665 0.53900146; 0.025831103 0.274292; 0.008124292 Gradient test ΔX for permute=both, reverse=true, logdet=true 12.21814; 12.152563 3.117157; 3.0843687 0.7748108; 0.75841665 0.18734741; 0.17915036 0.05291748; 0.048818953 Gradient test ΔX for permute=both, reverse=true, logdet=true 12.6828; 15.004396 2.59198; 3.752778 0.36904907; 0.94944805 0.05316162; 0.23703787 0.08151245; 0.06358729 Gradient test ΔX for permute=both, reverse=true, logdet=true 13.559601; 9.383762 4.744995; 2.6570761 1.6263123; 0.58235276 0.6442566; 0.12227684 0.29769897; 0.0367091 Gradient test weights for permute=both, reverse=false, logdet=true 1.329895; 1.267164 1.048523; 0.25000656 0.6157837; 0.03348106 0.32333374; 0.0012986362 0.16113281; 0.0011833757 Gradient test ΔX for permute=both, reverse=false, logdet=true 3.1001587; 2.9637327 0.796051; 0.72783804 0.21832275; 0.18421628 0.06378174; 0.0467285 0.01852417; 0.0099975495 Gradient test ΔX for permute=both, reverse=false, logdet=true 5.705017; 3.13612 2.1201782; 0.8357297 0.8708191; 0.22859484 0.38049316; 0.059381038 0.17630005; 0.015743986 Gradient test ΔX for permute=both, reverse=false, logdet=true 3.4647827; 3.6067467 0.81085205; 0.881834 0.19442749; 0.22991845 0.036987305; 0.05473279 0.0031738281; 0.01204657 Gradient test weights for permute=both, reverse=true, logdet=false 1.6433454; 2.1860068 1.3435507; 0.5711254 0.8041215; 0.15321654 0.4347868; 0.04388222 0.22629738; 0.01303713 Gradient test ΔX for permute=both, reverse=true, logdet=false 21.444092; 22.141104 5.2724915; 5.6209974 1.2105103; 1.3847632 0.23760986; 0.32473636 0.044067383; 0.08763063 Gradient test ΔX for permute=both, reverse=true, logdet=false 24.77356; 28.538267 5.285095; 7.167449 0.88964844; 1.8308254 0.010498047; 0.46009046 0.11016846; 0.1251258 Gradient test ΔX for permute=both, reverse=true, logdet=false 26.256042; 16.452938 9.6622925; 4.7607408 3.468567; 1.017791 1.4263916; 0.20100367 0.67407227; 0.0613783 Gradient test weights for permute=both, reverse=false, logdet=false 0.5848496; 0.62487864 0.4503528; 0.15451133 0.26216817; 0.04026389 0.14090538; 0.01031065 0.072466135; 0.00314188 Gradient test ΔX for permute=both, reverse=false, logdet=false 9.192505; 8.091491 2.5539856; 2.0034785 0.7760925; 0.500839 0.26480103; 0.12717427 0.099121094; 0.030307718 Gradient test ΔX for permute=both, reverse=false, logdet=false 12.00235; 7.743035 4.139984; 2.0103266 1.5904236; 0.52559483 0.66574097; 0.13332659 0.30010986; 0.033902675 Gradient test ΔX for permute=both, reverse=false, logdet=false 7.7928925; 9.52825 1.448822; 2.316501 0.17274475; 0.6065842 0.063583374; 0.15333633 0.07249451; 0.035965346 Gradient test weights for permute=full, reverse=true, logdet=true 2.9067688; 2.5906467 2.187561; 0.56114674 1.2306519; 0.14370203 0.6508484; 0.036328554 0.33377075; 0.009817719 Gradient test ΔX for permute=full, reverse=true, logdet=true 14.135193; 11.88564 4.1636963; 3.03892 1.3608398; 0.79845166 0.4824829; 0.20128882 0.19256592; 0.051968873 Gradient test ΔX for permute=full, reverse=true, logdet=true 7.784546; 11.165293 1.1626587; 2.853032 0.10128784; 0.7438988 0.23104858; 0.19154474 0.16140747; 0.049889192 Gradient test ΔX for permute=full, reverse=true, logdet=true 12.332336; 11.69067 3.195984; 2.8751504 0.9336548; 0.77323806 0.29592896; 0.2157206 0.09732056; 0.05721638 Gradient test weights for permute=full, reverse=false, logdet=true 1.329895; 1.267164 1.048523; 0.25000656 0.6157837; 0.03348106 0.32333374; 0.0012986362 0.16113281; 0.0011833757 Gradient test ΔX for permute=full, reverse=false, logdet=true 3.1001892; 2.963763 0.7961426; 0.7279295 0.21838379; 0.18427722 0.06387329; 0.046820007 0.01852417; 0.009997529 Gradient test ΔX for permute=full, reverse=false, logdet=true 5.7052307; 3.1363342 2.1201782; 0.83572996 0.8708801; 0.228656 0.3805542; 0.059442133 0.17642212; 0.015866086 Gradient test ΔX for permute=full, reverse=false, logdet=true 3.4647522; 3.6067164 0.810791; 0.8817732 0.19442749; 0.22991857 0.036956787; 0.054702327 0.0031433105; 0.012016079 Gradient test weights for permute=full, reverse=true, logdet=false 2.3083425; 2.3058472 1.7551966; 0.55189824 1.0049238; 0.14862359 0.53777313; 0.03900057 0.27929783; 0.009089023 Gradient test ΔX for permute=full, reverse=true, logdet=false 29.165466; 23.790646 8.803528; 6.1161175 2.960144; 1.616439 1.0814209; 0.40956837 0.44195557; 0.1060293 Gradient test ΔX for permute=full, reverse=true, logdet=false 13.40448; 18.97432 2.0375977; 4.8225174 0.12365723; 1.2688026 0.37298584; 0.3232441 0.26348877; 0.0846262 Gradient test ΔX for permute=full, reverse=true, logdet=false 23.749512; 20.967869 6.548279; 5.157458 2.0907593; 1.3953488 0.739563; 0.3918577 0.27978516; 0.10593252 Gradient test weights for permute=full, reverse=false, logdet=false 0.5848496; 0.6248785 0.4503528; 0.15451127 0.26216817; 0.04026386 0.14090538; 0.010310635 0.072466135; 0.0031418726 Gradient test ΔX for permute=full, reverse=false, logdet=false 9.192505; 8.09149 2.5539856; 2.003478 0.7760925; 0.50083876 0.26480103; 0.12717415 0.099121094; 0.030307658 Gradient test ΔX for permute=full, reverse=false, logdet=false 12.00235; 7.743035 4.140045; 2.0103877 1.5904236; 0.52559483 0.665802; 0.13338763 0.3001709; 0.03396371 Gradient test ΔX for permute=full, reverse=false, logdet=false 7.7928925; 9.528251 1.448822; 2.3165011 0.17277527; 0.6066148 0.063583374; 0.1533364 0.07249451; 0.035965383 Jacobian test 6.2894845; 1.2738092 3.146785; 0.45088485 1.5710182; 0.16587965 0.7847091; 0.058722984 0.39220816; 0.02033361 Gradient test coupling layer 351.9048; 19.520477 180.84375; 4.868881 91.67114; 1.185173 46.135498; 0.29265976 23.142822; 0.07125664 11.590088; 0.016951561 Gradient test coupling layer 76.5188; 18.449917 42.30017; 5.184187 22.3396; 1.4025793 11.527832; 0.34325743 Gradient test coupling layer 8.69165; 1.1126515 4.079468; 0.2899683 1.9661865; 0.07143679 0.96069336; 0.013318494 WARNING: Method definition mean(Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:7 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_conditional_layer_hint.jl:7. WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_glow.jl:37 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_conditional_layer_hint.jl:53. Conditional HINT invertibility test with permute=true, logdet=true, reverse=true Conditional HINT gradient test for input with permute=true, logdet=true, reverse=true 253.65234; 234.47545 156.26172; 140.92021 84.08984; 71.816635 42.464844; 32.64628 15.0390625; 7.184208 560.65234; 437.24908 393.65625; 294.93365 264.89453; 185.91646 174.41016; 111.22771 114.35547; 63.80951 494.79688; 469.88895 334.22656; 314.30023 198.77344; 182.83237 111.39453; 98.64168 57.625; 47.422718 Conditional HINT gradient test for weights with permute=true, logdet=true, reverse=true 5678.328; 5272.9834 1723.3672; 1520.6948 462.1875; 360.85135 144.5; 93.831924 49.710938; 24.376898 1545.1953; 4952.869 178.28125; 1525.5555 717.72656; 134.19183 453.47656; 27.517365 268.79688; 55.817276 1033.5547; 5200.0186 874.28125; 1208.9507 769.6719; 271.9441 354.26562; 166.54236 108.1875; 152.21649 Conditional HINT invertibility test with permute=true, logdet=true, reverse=false Conditional HINT gradient test for input with permute=true, logdet=true, reverse=false 7.3481445; 10.404114 4.257324; 6.7021 2.3149414; 4.2707615 1.1411133; 2.7057695 0.45361328; 1.7053382 8.515137; 8.036439 5.4365234; 5.053566 3.4726562; 3.16629 2.2426758; 1.9975829 1.4467773; 1.250703 15.729492; 10.240671 11.030273; 6.639217 7.8408203; 4.3279753 5.631836; 2.8215597 4.0961914; 1.8479705 Conditional HINT gradient test for weights with permute=true, logdet=true, reverse=false 34.58008; 30.37849 9.578125; 7.477331 2.46875; 1.4183531 0.74609375; 0.22089529 0.20800781; 0.054591417 26.871582; 24.506798 7.131836; 5.9494443 1.9804688; 1.3892729 0.71191406; 0.41631612 0.1899414; 0.042142436 3.666504; 31.839502 9.138672; 4.9478273 7.40625; 0.3630004 4.9404297; 1.4188049 3.2104492; 1.4496368 Conditional HINT invertibility test with permute=false, logdet=true, reverse=true Conditional HINT gradient test for input with permute=false, logdet=true, reverse=true 671.4375; 2301.745 342.8125; 1647.0586 130.96875; 1174.3657 62.140625; 772.5769 169.01562; 498.75842 2738.8594; 1906.7361 1887.0156; 1221.317 1288.3906; 755.8317 873.90625; 447.85913 588.9844; 248.14665 967.40625; 1190.7986 601.9219; 780.6358 290.26562; 433.2368 114.46875; 228.84567 43.21875; 134.72029 Conditional HINT gradient test for weights with permute=false, logdet=true, reverse=true 12232.055; 14150.607 2496.0938; 3455.3704 396.6797; 876.318 18.203125; 221.61601 68.48047; 51.4291 5327.5273; 11782.888 388.21484; 2839.4653 1156.5586; 457.2815 973.9336; 167.01355 591.3125; 187.85248 29209.496; 21125.803 9289.711; 5247.8643 3558.4883; 1537.5648 1679.7461; 669.28436 914.2578; 409.02695 Conditional HINT invertibility test with permute=false, logdet=true, reverse=false Conditional HINT gradient test for input with permute=false, logdet=true, reverse=false 13.243652; 13.815769 8.580078; 9.037771 5.5805664; 5.946721 3.6049805; 3.8979044 2.3364258; 2.570765 5.2929688; 12.841813 2.133789; 8.172865 0.3955078; 5.2267685 0.49853516; 3.3664734 0.95751953; 2.1344874 17.960938; 12.322996 12.469727; 7.9593744 8.8203125; 5.212031 6.3085938; 3.4219685 4.5634766; 2.2541761 Conditional HINT gradient test for weights with permute=false, logdet=true, reverse=false 31.389648; 40.339943 5.359375; 9.834523 0.25097656; 2.4885507 0.46826172; 0.65052533 0.42089844; 0.13849509 37.478516; 34.603603 9.819824; 8.382368 3.015625; 2.296897 1.3291016; 0.9697375 0.82177734; 0.6420953 36.82715; 43.253754 7.169922; 10.383224 0.29248047; 1.8991314 0.8955078; 0.09218234 0.9536133; 0.5519506 Conditional HINT invertibility test with permute=true, logdet=false, reverse=true Conditional HINT gradient test for input with permute=true, logdet=false, reverse=true 1141.75; 1629.5151 837.0469; 1227.259 530.2969; 842.4666 332.53125; 582.267 175.25; 375.0386 1244.4844; 992.2443 925.0469; 723.2548 596.71875; 435.2851 377.42188; 248.27495 230.92188; 127.60434 1052.5781; 2295.5361 509.75; 1504.1165 211.29688; 1006.79004 37.578125; 673.97266 81.3125; 427.80313 Conditional HINT gradient test for weights with permute=true, logdet=false, reverse=true 2756.3594; 15030.479 1369.8906; 4767.169 1517.8594; 1550.6704 1230.6562; 303.60864 710.4844; 56.64807 35461.72; 12917.398 16986.375; 5714.215 7449.203; 1813.123 3405.9531; 587.9131 1552.7188; 143.69873 5377.125; 10481.573 6956.9375; 972.4116 5231.75; 1267.0754 3629.5312; 1647.194 2615.4531; 1624.2844 Conditional HINT invertibility test with permute=true, logdet=false, reverse=false Conditional HINT gradient test for input with permute=true, logdet=false, reverse=false 19.44165; 26.46093 11.451416; 17.066841 6.5043945; 10.996734 3.4711914; 7.065063 1.6237793; 4.4988766 17.555908; 20.637024 10.606445; 13.071338 6.2470703; 8.218985 3.621338; 5.198869 2.0234375; 3.2854624 39.128418; 24.516361 27.639893; 15.950246 19.729736; 10.378019 14.177246; 6.695873 10.312256; 4.3271565 Conditional HINT gradient test for weights with permute=true, logdet=false, reverse=false 97.16406; 71.291405 32.059326; 19.122997 10.667969; 4.199805 4.022217; 0.7881348 1.6799316; 0.06289065 70.77954; 70.50941 17.199219; 17.06415 3.0021973; 2.934663 0.17651367; 0.2102808 1.192627; 1.2095106 27.424805; 82.211914 11.284912; 16.108643 12.822266; 0.8745117 9.457031; 2.6086426 6.5964355; 3.1722412 Conditional HINT invertibility test with permute=false, logdet=false, reverse=true Conditional HINT gradient test for input with permute=false, logdet=false, reverse=true 1335.2812; 4597.335 680.8125; 3290.4556 258.9375; 2346.652 126.375; 1543.7966 339.5; 996.6373 5473.9375; 3809.0986 3771.625; 2439.7537 2575.0625; 1509.5656 1746.625; 894.2274 1177.3125; 495.3944 1926.6875; 2375.9895 1197.8125; 1557.254 575.84375; 863.39703 225.40625; 455.44888 83.84375; 267.87787 Conditional HINT gradient test for weights with permute=false, logdet=false, reverse=true 24451.023; 28306.945 4982.9062; 6910.8667 787.46875; 1751.449 39.523438; 442.4667 138.57031; 102.42476 10612.0; 23575.941 798.4375; 5683.5327 2324.211; 916.7742 1952.5312; 332.0387 1184.0859; 373.83966 58372.695; 42259.61 18552.703; 10496.159 7102.7266; 3074.4546 3353.2812; 1339.1453 1825.9375; 818.8695 Conditional HINT invertibility test with permute=false, logdet=false, reverse=false Conditional HINT gradient test for input with permute=false, logdet=false, reverse=false 34.546875; 32.605423 22.800781; 21.247622 15.181641; 13.939112 10.125244; 9.131222 6.855713; 6.0604944 15.369629; 31.016878 7.3112793; 19.829079 2.7495117; 12.763752 0.26757812; 8.27897 1.0844727; 5.3246408 43.323975; 28.656773 30.0896; 18.355837 21.260498; 11.873489 15.2561035; 7.746496 11.076172; 5.068486 Conditional HINT gradient test for weights with permute=false, logdet=false, reverse=false 87.03931; 112.350174 15.570557; 28.225992 1.076416; 7.404134 1.2263184; 1.9375405 1.1340332; 0.44789624 108.76904; 95.875275 31.363037; 24.916151 9.857422; 6.633979 4.090332; 2.4786105 2.2563477; 1.4504869 97.47339; 110.38462 19.168457; 25.624071 0.8503418; 4.078149 2.0083008; 0.39439714 2.3134766; 1.5065248 Conditional HINT jacobian test with permute=true, logdet=true 19.220694; 6.5345316 9.372641; 2.187312 4.6465373; 0.7686729 2.3158216; 0.28033975 1.1558608; 0.09980874 Conditional HINT jacobian test with permute=false, logdet=true 17.469196; 3.857861 8.326562; 1.2412885 4.069782; 0.41852033 2.0103474; 0.1380963 0.9997722; 0.046031166 Conditional HINT jacobian test with permute=true, logdet=false 18.749294; 5.9120197 9.167557; 1.9367977 4.5475388; 0.6332978 2.2663913; 0.20675974 1.1311547; 0.072152674 Conditional HINT jacobian test with permute=false, logdet=false 13.85919; 3.401138 6.6301928; 1.1358013 3.2432723; 0.39246503 1.6047163; 0.13719784 0.79776454; 0.048769027 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_conditional_layer_hint.jl:53 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_conditional_res_block.jl:21. Gradient test convolutions 0.0865401; 0.009211995 0.04559046; 0.0022855885 0.023373574; 0.0005644504 0.011827648; 0.00014136452 0.0059500933; 3.4412835e-5 Gradient test convolutions 0.18460959; 0.05797238 0.105528355; 0.01576263 0.056518376; 0.004127117 0.02925843; 0.0010643154 0.0148822665; 0.0002791062 Jacobian test 24.13855; 5.9297175 11.641914; 2.0490713 5.712243; 0.7332319 2.8287208; 0.25972548 1.407658; 0.0872884 WARNING: Method definition loss(Any, Any, Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_basic.jl:164 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_hyperbolic_layer.jl:36. Invertibility test hyperbolic layer with action=1 Gradient test hyperbolic layer input with action=1 514.0068; 514.0068 128.4835; 128.4835 32.116287; 32.116287 8.028689; 8.028689 2.0071251; 2.0071251 0.5017608; 0.5017608 0.12543444; 0.12543444 0.03135801; 0.03135801 0.007839452; 0.007839452 0.0019598452; 0.0019598452 Gradient test hyperbolic layer weights with action=1 714.8218; 714.8218 109.758484; 109.758484 23.271055; 23.271055 5.5755115; 5.5755115 1.380296; 1.380296 0.34655976; 0.34655976 0.08732632; 0.08732632 0.021912571; 0.021912571 0.005471242; 0.005471242 0.0013662043; 0.0013662043 Invertibility test hyperbolic layer with action=-1 Gradient test hyperbolic layer input with action=-1 555.7908; 555.7908 138.95842; 138.95842 34.740723; 34.740723 8.685355; 8.685355 2.171351; 2.171351 0.5428449; 0.5428449 0.13571301; 0.13571301 0.033928294; 0.033928294 0.008482068; 0.008482068 0.0021205184; 0.0021205184 Gradient test hyperbolic layer weights with action=-1 728.6386; 728.6386 113.30383; 113.30383 24.05488; 24.05488 5.747953; 5.747953 1.4182966; 1.4182966 0.35390568; 0.35390568 0.08848839; 0.08848839 0.022070292; 0.022070292 0.005514584; 0.005514584 0.0013788928; 0.0013788928 Invertibility test hyperbolic layer with action=0 Gradient test hyperbolic layer input with action=0 531.2427; 531.2427 132.80733; 132.80733 33.20142; 33.20142 8.300876; 8.300876 2.0753624; 2.0753624 0.51888424; 0.51888424 0.1297269; 0.1297269 0.03243167; 0.03243167 0.008107954; 0.008107954 0.0020269891; 0.0020269891 Gradient test hyperbolic layer weights with action=0 865.915; 865.915 130.84053; 130.84053 27.415588; 27.415588 6.4899607; 6.4899607 1.5960143; 1.5960143 0.39700913; 0.39700913 0.099303745; 0.099303745 0.02482622; 0.02482622 0.0062061604; 0.0062061604 0.0015508579; 0.0015508579 Jacobian test 32.213413; 0.64313346 16.161001; 0.18890329 8.092939; 0.05872843 4.049744; 0.018968094 2.025657; 0.0063011595 Jacobian test 33.534607; 0.5266018 16.776693; 0.17776132 8.390964; 0.06133843 4.196215; 0.01942268 2.098268; 0.0055520986 Jacobian test 32.968697; 0.6634619 16.515188; 0.20763595 8.265312; 0.0701045 4.134541; 0.023813127 2.067668; 0.0074217585 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_conditional_res_block.jl:21 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_actnorm.jl:112. Gradient test actnorm 593.0364; 31.212463 304.3213; 7.803131 154.11157; 1.9506378 77.54346; 0.487648 38.89331; 0.122241974 19.477295; 0.030481339 Gradient test actnorm 2.277193; 6.986334 0.61058044; 1.74399 0.7415428; 0.43574238 0.47982788; 0.10881472 0.26706696; 0.027254343 0.1403656; 0.0067950487 Gradient test actnorm reverse 581.8613; 30.624023 298.5869; 7.6557617 151.20776; 1.9135742 76.082275; 0.47839355 38.16089; 0.1194458 19.110352; 0.029815674 Gradient test actnorm reverse 10.052361; 0.118299484 4.998604; 0.031573296 2.491684; 0.008168697 1.2439346; 0.002177 0.62132263; 0.00044381618 0.31058502; 0.00014561415 Jacobian test 8.177256; 0.5802178 4.101183; 0.1450545 2.0546827; 0.036263626 1.0284821; 0.00906591 0.514541; 0.0022664294 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_actnorm.jl:112 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_layer_affine.jl:45. Gradient test affine layer 0.9472656; 0.034638047 0.48242188; 0.008529961 0.24316406; 0.0023118556 0.12207031; 0.0006676465 0.061523438; 0.00015445799 Gradient test affine layer 203.67639; 15.495438 105.711914; 3.8740005 53.82422; 0.96873856 27.154175; 0.24230385 13.637451; 0.060788155 Jacobian test 1.2255951; 0.08370193 0.6016665; 0.020925475 0.29814923; 0.005231365 0.14841636; 0.0013078447 0.074045226; 0.00032695846 Test Summary: | Pass Total Time Layers | 576 576 2m06.3s Test test_layers/test_residual_block.jl | 18 18 1.8s Test test_layers/test_flux_block.jl | 4 4 4.0s Test test_layers/test_resnet.jl | 4 4 20.5s Test test_layers/test_layer_conv1x1.jl | 29 29 1.7s Test test_layers/test_coupling_layer_basic.jl | 29 29 3.0s Test test_layers/test_coupling_layer_irim.jl | 11 11 1.5s Test test_layers/test_coupling_layer_glow.jl | 17 17 33.6s Test test_layers/test_coupling_layer_hint.jl | 163 163 4.1s Test test_layers/test_conditional_layer_glow.jl | 8 8 0.9s Test test_layers/test_conditional_layer_hint.jl | 84 84 22.0s Test test_layers/test_conditional_res_block.jl | 7 7 9.3s Test test_layers/test_hyperbolic_layer.jl | 159 159 9.8s Test test_layers/test_actnorm.jl | 32 32 5.6s Test test_layers/test_layer_affine.jl | 11 11 8.3s Gradient test loop unrolling 847.2373; 46.51297 435.24365; 11.631485 220.5293; 2.9082718 110.9917; 0.7270851 55.678223; 0.18116951 27.884766; 0.044930458 Gradient test loop unrolling 240.05078; 20.002798 114.87012; 4.8461256 56.203613; 1.1916176 27.797363; 0.29136544 13.824707; 0.07170811 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_layer_affine.jl:45 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_generator.jl:72. Gradient test loop unrolling 12.51416; 1.4956894 6.628414; 0.37651062 3.4077988; 0.09466362 1.7275848; 0.023646355 Gradient test loop unrolling 1.6518745; 0.1902467 0.6915779; 0.03923601 0.35837936; 0.0070275962 0.18094254; 0.0017609447 WARNING: Method definition mean(Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_conditional_layer_hint.jl:7 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:9. ┌ Warning: Assignment to `X` in soft scope is ambiguous because a global variable by the same name exists: `X` will be treated as a new local. Disambiguate by using `local X` to suppress this warning or `global X` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:36 ┌ Warning: Assignment to `Y` in soft scope is ambiguous because a global variable by the same name exists: `Y` will be treated as a new local. Disambiguate by using `local Y` to suppress this warning or `global Y` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:40 ┌ Warning: Assignment to `X_` in soft scope is ambiguous because a global variable by the same name exists: `X_` will be treated as a new local. Disambiguate by using `local X_` to suppress this warning or `global X_` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:44 ┌ Warning: Assignment to `X0` in soft scope is ambiguous because a global variable by the same name exists: `X0` will be treated as a new local. Disambiguate by using `local X0` to suppress this warning or `global X0` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:89 ┌ Warning: Assignment to `dX` in soft scope is ambiguous because a global variable by the same name exists: `dX` will be treated as a new local. Disambiguate by using `local dX` to suppress this warning or `global dX` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:90 ┌ Warning: Assignment to `f0` in soft scope is ambiguous because a global variable by the same name exists: `f0` will be treated as a new local. Disambiguate by using `local f0` to suppress this warning or `global f0` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:92 ┌ Warning: Assignment to `ΔX` in soft scope is ambiguous because a global variable by the same name exists: `ΔX` will be treated as a new local. Disambiguate by using `local ΔX` to suppress this warning or `global ΔX` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:92 ┌ Warning: Assignment to `h` in soft scope is ambiguous because a global variable by the same name exists: `h` will be treated as a new local. Disambiguate by using `local h` to suppress this warning or `global h` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:93 ┌ Warning: Assignment to `maxiter` in soft scope is ambiguous because a global variable by the same name exists: `maxiter` will be treated as a new local. Disambiguate by using `local maxiter` to suppress this warning or `global maxiter` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:94 ┌ Warning: Assignment to `err1` in soft scope is ambiguous because a global variable by the same name exists: `err1` will be treated as a new local. Disambiguate by using `local err1` to suppress this warning or `global err1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:95 ┌ Warning: Assignment to `err2` in soft scope is ambiguous because a global variable by the same name exists: `err2` will be treated as a new local. Disambiguate by using `local err2` to suppress this warning or `global err2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:96 ┌ Warning: Assignment to `num_attempts` in soft scope is ambiguous because a global variable by the same name exists: `num_attempts` will be treated as a new local. Disambiguate by using `local num_attempts` to suppress this warning or `global num_attempts` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:110 ┌ Warning: Assignment to `results_1` in soft scope is ambiguous because a global variable by the same name exists: `results_1` will be treated as a new local. Disambiguate by using `local results_1` to suppress this warning or `global results_1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:111 ┌ Warning: Assignment to `results_2` in soft scope is ambiguous because a global variable by the same name exists: `results_2` will be treated as a new local. Disambiguate by using `local results_2` to suppress this warning or `global results_2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:112 ┌ Warning: Assignment to `dW` in soft scope is ambiguous because a global variable by the same name exists: `dW` will be treated as a new local. Disambiguate by using `local dW` to suppress this warning or `global dW` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:123 ┌ Warning: Assignment to `dv` in soft scope is ambiguous because a global variable by the same name exists: `dv` will be treated as a new local. Disambiguate by using `local dv` to suppress this warning or `global dv` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:124 ┌ Warning: Assignment to `err3` in soft scope is ambiguous because a global variable by the same name exists: `err3` will be treated as a new local. Disambiguate by using `local err3` to suppress this warning or `global err3` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:129 ┌ Warning: Assignment to `err4` in soft scope is ambiguous because a global variable by the same name exists: `err4` will be treated as a new local. Disambiguate by using `local err4` to suppress this warning or `global err4` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:130 ┌ Warning: Assignment to `factor1` in soft scope is ambiguous because a global variable by the same name exists: `factor1` will be treated as a new local. Disambiguate by using `local factor1` to suppress this warning or `global factor1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:144 ┌ Warning: Assignment to `factor2` in soft scope is ambiguous because a global variable by the same name exists: `factor2` will be treated as a new local. Disambiguate by using `local factor2` to suppress this warning or `global factor2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:145 ┌ Warning: Assignment to `θ` in soft scope is ambiguous because a global variable by the same name exists: `θ` will be treated as a new local. Disambiguate by using `local θ` to suppress this warning or `global θ` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:160 ┌ Warning: Assignment to `θ0` in soft scope is ambiguous because a global variable by the same name exists: `θ0` will be treated as a new local. Disambiguate by using `local θ0` to suppress this warning or `global θ0` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:162 ┌ Warning: Assignment to `dθ` in soft scope is ambiguous because a global variable by the same name exists: `dθ` will be treated as a new local. Disambiguate by using `local dθ` to suppress this warning or `global dθ` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:166 ┌ Warning: Assignment to `dY` in soft scope is ambiguous because a global variable by the same name exists: `dY` will be treated as a new local. Disambiguate by using `local dY` to suppress this warning or `global dY` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:172 ┌ Warning: Assignment to `err5` in soft scope is ambiguous because a global variable by the same name exists: `err5` will be treated as a new local. Disambiguate by using `local err5` to suppress this warning or `global err5` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:178 ┌ Warning: Assignment to `err6` in soft scope is ambiguous because a global variable by the same name exists: `err6` will be treated as a new local. Disambiguate by using `local err6` to suppress this warning or `global err6` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:179 ┌ Warning: Assignment to `dY_` in soft scope is ambiguous because a global variable by the same name exists: `dY_` will be treated as a new local. Disambiguate by using `local dY_` to suppress this warning or `global dY_` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:196 ┌ Warning: Assignment to `dX_` in soft scope is ambiguous because a global variable by the same name exists: `dX_` will be treated as a new local. Disambiguate by using `local dX_` to suppress this warning or `global dX_` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:197 ┌ Warning: Assignment to `dθ_` in soft scope is ambiguous because a global variable by the same name exists: `dθ_` will be treated as a new local. Disambiguate by using `local dθ_` to suppress this warning or `global dθ_` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:197 ┌ Warning: Assignment to `a` in soft scope is ambiguous because a global variable by the same name exists: `a` will be treated as a new local. Disambiguate by using `local a` to suppress this warning or `global a` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:198 ┌ Warning: Assignment to `b` in soft scope is ambiguous because a global variable by the same name exists: `b` will be treated as a new local. Disambiguate by using `local b` to suppress this warning or `global b` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_glow.jl:199 Testing Glow with dimensions=(32, 32) logdet=true and split_scales=true Gradient test glow: input 16.973389; 0.6401386 8.5720215; 0.096310616 4.362549; 0.104652405 2.2110596; 0.012572765 Gradient test glow: input 8.2561035; 0.72045815 6.6848145; 0.49643514 5.4039307; 0.34106892 4.3824463; 0.21355328 Gradient test glow: input 18.92456; 1.2446804 15.162109; 0.9732845 12.129272; 0.77904165 9.7664795; 0.56017196 Gradient test glow: input 17.849365; 0.74056536 14.5095215; 0.82248104 11.724976; 0.7753434 9.307251; 0.54754466 Jacobian test 23.693167; 19.549408 11.132732; 6.0280585 5.544935; 1.9736346 2.7734976; 0.67495644 1.3899198; 0.24006963 Testing Glow with dimensions=(32, 32, 32) logdet=true and split_scales=true Gradient test glow: input 820.97656; 43.015686 420.73828; 10.244049 212.92188; 2.285736 107.01172; 0.49985504 Gradient test glow: input 307.32812; 13.335379 248.39453; 8.136296 200.04297; 5.181684 160.84766; 3.332075 Gradient test glow: input 331.86328; 13.459518 267.76953; 8.4887085 215.57031; 5.4362764 173.32422; 3.4810615 Gradient test glow: input 492.26562; 21.498468 397.8164; 13.194906 320.70703; 8.102018 257.97656; 5.070653 Jacobian test 97.04776; 52.07937 52.95613; 18.514 27.792141; 6.5133176 14.255469; 2.2976208 7.2207384; 0.81605494 Testing Glow with dimensions=(32, 32) logdet=true and split_scales=false Gradient test glow: input 106.22644; 15.322571 56.73358; 3.7690163 29.294128; 1.0293732 14.884705; 0.21400738 Gradient test glow: input 3.0808716; 1.6346178 2.4258423; 1.3465494 2.0046387; 1.0132746 1.6907349; 0.7235956 Gradient test glow: input 5.4434814; 2.9541996 3.3217773; 1.3303516 2.3128662; 0.7197256 1.6784668; 0.4039544 Gradient test glow: input 23.731567; 2.3920896 19.116821; 1.7821046 15.455933; 1.2632085 12.444763; 0.93054914 Jacobian test 79.69341; 108.2786 48.253628; 37.41695 26.061678; 12.343957 13.430035; 3.993826 6.819765; 1.2973368 Testing Glow with dimensions=(32, 32, 32) logdet=true and split_scales=false Gradient test glow: input 4803.0996; 583.43164 2548.2559; 149.00415 1311.3164; 37.12793 664.9746; 9.422852 Gradient test glow: input 306.86328; 70.78699 254.82812; 47.292126 212.80664; 28.88955 176.44336; 16.913593 Gradient test glow: input 796.1992; 108.06546 650.8633; 72.54849 531.4238; 47.305557 431.5625; 31.421015 Gradient test glow: input 237.63281; 0.8155594 190.82422; 1.3704071 152.78125; 1.2182083 121.990234; 0.7397995 Jacobian test 211.40178; 133.2839 118.574005; 42.33533 62.53973; 13.445034 32.078316; 4.391089 16.240839; 1.4755403 Testing Glow with dimensions=(32, 32) logdet=false and split_scales=true Gradient test glow: input 0.08221787; 0.011646502 0.044183493; 0.0030883886 0.022885978; 0.0008266177 0.011645168; 0.0002177069 Gradient test glow: input 0.0029224455; 0.0011071998 0.0025279522; 0.0006957643 0.0020858943; 0.00049307896 0.0016523302; 0.0004108483 Gradient test glow: input 0.024532378; 0.0031972646 0.02024278; 0.0019409347 0.016586363; 0.0011606073 0.013531506; 0.0006660706 Gradient test glow: input 0.0111142695; 0.003220607 0.009268552; 0.0021993502 0.007747233; 0.0014270891 0.006443709; 0.0008957484 Jacobian test 23.693167; 19.549408 11.132732; 6.0280585 5.544935; 1.9736346 2.7734976; 0.67495644 1.3899198; 0.24006963 Testing Glow with dimensions=(32, 32, 32) logdet=false and split_scales=true Gradient test glow: input 0.08120811; 0.01087229 0.043353975; 0.00278005 0.022376597; 0.000702763 0.011365384; 0.00018111337 Gradient test glow: input 0.0065755546; 0.0008433494 0.005398184; 0.00053693965 0.00440374; 0.00034435873 0.0035808086; 0.00021767043 Gradient test glow: input 0.009302735; 0.001346522 0.0076387227; 0.000880684 0.006239325; 0.00057620043 0.0050800145; 0.00037240572 Gradient test glow: input 0.011101514; 0.0014617427 0.009128034; 0.0009225717 0.0074561834; 0.0005843012 0.006058514; 0.0003738733 Jacobian test 97.04776; 52.07937 52.95613; 18.514 27.792141; 6.5133176 14.255469; 2.2976208 7.2207384; 0.81605494 Testing Glow with dimensions=(32, 32) logdet=false and split_scales=false Gradient test glow: input 123.471985; 15.505135 65.82349; 4.1067505 33.900574; 0.94963837 17.18274; 0.21022224 Gradient test glow: input 17.050415; 3.7051098 14.2352295; 2.3691912 12.078857; 1.204678 10.017944; 0.6088842 Gradient test glow: input 18.270752; 3.7566566 15.192627; 2.4293013 12.3741455; 1.7233968 10.06543; 1.212604 Gradient test glow: input 41.06958; 4.144776 33.398804; 2.7726827 27.04889; 1.888299 21.75885; 1.3908999 Jacobian test 79.69341; 108.2786 48.253628; 37.41695 26.061678; 12.343957 13.430035; 3.993826 6.819765; 1.2973368 Testing Glow with dimensions=(32, 32, 32) logdet=false and split_scales=false Gradient test glow: input 5383.2266; 615.8716 2846.795; 157.2373 1462.7148; 39.84961 741.4297; 10.169983 Gradient test glow: input 818.81836; 81.870514 669.9629; 50.588223 542.85156; 33.58934 438.56836; 22.584345 Gradient test glow: input 1062.4863; 140.61218 874.8301; 87.64877 717.3418; 52.64125 585.0078; 30.978624 Gradient test glow: input 546.13477; 63.227573 451.26953; 36.220387 369.05273; 20.939177 299.90234; 12.091192 Jacobian test 211.40178; 133.2839 118.574005; 42.33533 62.53973; 13.445034 32.078316; 4.391089 16.240839; 1.4755403 ┌ Warning: Assignment to `N` in soft scope is ambiguous because a global variable by the same name exists: `N` will be treated as a new local. Disambiguate by using `local N` to suppress this warning or `global N` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:20 ┌ Warning: Assignment to `X` in soft scope is ambiguous because a global variable by the same name exists: `X` will be treated as a new local. Disambiguate by using `local X` to suppress this warning or `global X` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:24 ┌ Warning: Assignment to `Y` in soft scope is ambiguous because a global variable by the same name exists: `Y` will be treated as a new local. Disambiguate by using `local Y` to suppress this warning or `global Y` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:27 ┌ Warning: Assignment to `X_` in soft scope is ambiguous because a global variable by the same name exists: `X_` will be treated as a new local. Disambiguate by using `local X_` to suppress this warning or `global X_` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:28 ┌ Warning: Assignment to `X0` in soft scope is ambiguous because a global variable by the same name exists: `X0` will be treated as a new local. Disambiguate by using `local X0` to suppress this warning or `global X0` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:65 ┌ Warning: Assignment to `dX` in soft scope is ambiguous because a global variable by the same name exists: `dX` will be treated as a new local. Disambiguate by using `local dX` to suppress this warning or `global dX` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:66 ┌ Warning: Assignment to `f0` in soft scope is ambiguous because a global variable by the same name exists: `f0` will be treated as a new local. Disambiguate by using `local f0` to suppress this warning or `global f0` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:68 ┌ Warning: Assignment to `ΔX` in soft scope is ambiguous because a global variable by the same name exists: `ΔX` will be treated as a new local. Disambiguate by using `local ΔX` to suppress this warning or `global ΔX` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:68 ┌ Warning: Assignment to `h` in soft scope is ambiguous because a global variable by the same name exists: `h` will be treated as a new local. Disambiguate by using `local h` to suppress this warning or `global h` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:69 ┌ Warning: Assignment to `maxiter` in soft scope is ambiguous because a global variable by the same name exists: `maxiter` will be treated as a new local. Disambiguate by using `local maxiter` to suppress this warning or `global maxiter` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:70 ┌ Warning: Assignment to `err1` in soft scope is ambiguous because a global variable by the same name exists: `err1` will be treated as a new local. Disambiguate by using `local err1` to suppress this warning or `global err1` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:71 ┌ Warning: Assignment to `err2` in soft scope is ambiguous because a global variable by the same name exists: `err2` will be treated as a new local. Disambiguate by using `local err2` to suppress this warning or `global err2` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:72 ┌ Warning: Assignment to `dW` in soft scope is ambiguous because a global variable by the same name exists: `dW` will be treated as a new local. Disambiguate by using `local dW` to suppress this warning or `global dW` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:94 ┌ Warning: Assignment to `err3` in soft scope is ambiguous because a global variable by the same name exists: `err3` will be treated as a new local. Disambiguate by using `local err3` to suppress this warning or `global err3` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:99 ┌ Warning: Assignment to `err4` in soft scope is ambiguous because a global variable by the same name exists: `err4` will be treated as a new local. Disambiguate by using `local err4` to suppress this warning or `global err4` to assign to the existing global variable. └ @ ~/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_dense_glow.jl:100 Testing Dense Glow with dimensions nx=32 Gradient test glow: input 0.16273117; 0.072772585 0.10050583; 0.02655451 0.054912567; 0.0064851455 0.029319763; 0.0010421574 Gradient test glow: parameters 0.08470154; 0.04437387 0.046499252; 0.026335418 0.023281097; 0.01319918 0.011613846; 0.0065728873 Testing Dense Glow with dimensions nx=2 Gradient test glow: input 0.011595726; 0.003871609 0.007134676; 0.0017264285 0.0039999485; 0.00043376652 0.002108574; 0.00010885601 Gradient test glow: parameters 0.04665613; 0.04665613 0.01659131; 0.01659131 0.0050587654; 0.0050587654 7.8201294e-5; 7.8201294e-5 (norm(X_curr - X_curr_), norm(X_curr_)) = (6.163589f-5, 64.93195f0) (norm(X_curr - X_curr_), norm(X_curr_)) = (9.1185684f-5, 64.93195f0) WARNING: Method definition loss(Any, Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_conditional_layer_glow.jl:42 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_hyperbolic_network.jl:32. Gradient test hyperbolic network 1955.7471; 217.40723 1032.4229; 54.154297 529.72656; 13.562012 268.25586; 3.3884277 134.97168; 0.85046387 67.69531; 0.21575928 rate_1 = sum(err1[1:end - 1] ./ err1[2:end]) / (maxiter - 1) = 1.9598633f0 rate_2 = sum(err2[1:end - 1] ./ err2[2:end]) / (maxiter - 1) = 3.9872124f0 Gradient test invertible layer for layer 1 154.41406; 8.205185 79.29297; 2.016655 40.11133; 0.54348373 20.173828; 0.1535778 10.125; 0.038702965 5.078125; 0.0037264824 local rate_1 = sum(err3[1:end - 1] ./ err3[2:end]) / (maxiter - 1) = 1.9797636f0 local rate_2 = sum(err4[1:end - 1] ./ err4[2:end]) / (maxiter - 1) = 5.1344347f0 Gradient test invertible layer for layer 2 748.9238; 40.247498 384.8789; 9.706757 194.92383; 2.3690033 98.06641; 0.58000946 49.185547; 0.13766098 24.632812; 0.028791428 local rate_1 = sum(err3[1:end - 1] ./ err3[2:end]) / (maxiter - 1) = 1.9797208f0 local rate_2 = sum(err4[1:end - 1] ./ err4[2:end]) / (maxiter - 1) = 4.2645597f0 Gradient test invertible layer for layer 3 891.38086; 45.97284 457.6621; 11.01474 231.63477; 2.703659 116.49609; 0.6731186 58.41992; 0.1646843 29.253906; 0.038396835 local rate_1 = sum(err3[1:end - 1] ./ err3[2:end]) / (maxiter - 1) = 1.980587f0 local rate_2 = sum(err4[1:end - 1] ./ err4[2:end]) / (maxiter - 1) = 4.128144f0 Gradient test invertible layer for layer 4 654.0137; 21.762451 332.84668; 5.041382 167.74805; 1.1959839 84.1875; 0.28451538 42.16992; 0.066085815 21.104492; 0.013511658 local rate_1 = sum(err3[1:end - 1] ./ err3[2:end]) / (maxiter - 1) = 1.987241f0 local rate_2 = sum(err4[1:end - 1] ./ err4[2:end]) / (maxiter - 1) = 4.3863735f0 Gradient test invertible layer for layer 5 144.92676; 6.172653 74.08203; 1.4676743 37.42285; 0.3520012 18.804688; 0.08273888 9.426758; 0.016955376 4.7226562; 0.0007996559 local rate_1 = sum(err3[1:end - 1] ./ err3[2:end]) / (maxiter - 1) = 1.9833734f0 local rate_2 = sum(err4[1:end - 1] ./ err4[2:end]) / (maxiter - 1) = 7.7425513f0 Jacobian test 52.74907; 5.7840395 26.522865; 1.5720645 13.2991295; 0.44706902 6.6575; 0.1347658 3.3309917; 0.04371528 Invertibility test multiscale HINT network WARNING: Method definition loss(Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_coupling_layer_hint.jl:33 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_multiscale_hint_network.jl:37. Gradient test multiscale HINT net: input 8.808594; 37.73768 13.1015625; 10.171574 8.958984; 2.6775837 5.1191406; 0.6991434 2.7207031; 0.18843889 1.40625; 0.04832101 Jacobian test 49.503975; 30.378218 23.102898; 10.54348 11.242197; 3.6620078 5.5794253; 1.2730979 2.7834933; 0.44351527 WARNING: Method definition inv_test(Any, Any, Any, Any, Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_conditional_layer_hint.jl:22 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_multiscale_conditional_hint_network.jl:17. WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_generator.jl:72 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_multiscale_conditional_hint_network.jl:49. WARNING: Method definition grad_test_X(Any, Any, Any, Any, Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_layers/test_conditional_layer_hint.jl:74 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_multiscale_conditional_hint_network.jl:63. Multiscale Conditional HINT invertibility test with squeeze_type=ShuffleLayer, split_scales=true, logdet=false Multiscale Conditional HINT gradient test with squeeze_type=ShuffleLayer, split_scales=true, logdet=false 0.37434214; 0.4175967 0.057311743; 0.07893902 0.009936303; 0.02074994 0.00020681322; 0.0056136316 0.0013027638; 0.0014006452 Multiscale Conditional HINT invertibility test with squeeze_type=ShuffleLayer, split_scales=true, logdet=true Multiscale Conditional HINT gradient test with squeeze_type=ShuffleLayer, split_scales=true, logdet=true 147.4895; 166.8316 36.021362; 45.692413 5.5045166; 10.340042 0.11706543; 2.300697 0.6921387; 0.51674265 Multiscale Conditional HINT invertibility test with squeeze_type=ShuffleLayer, split_scales=false, logdet=false Multiscale Conditional HINT gradient test with squeeze_type=ShuffleLayer, split_scales=false, logdet=false 312.97525; 328.89798 53.283386; 61.244747 9.885315; 13.8659935 0.8001785; 2.7905183 0.61953735; 0.37563252 Multiscale Conditional HINT invertibility test with squeeze_type=ShuffleLayer, split_scales=false, logdet=true Multiscale Conditional HINT gradient test with squeeze_type=ShuffleLayer, split_scales=false, logdet=true 250.63135; 261.56384 11.25415; 16.720394 1.4077148; 4.1408367 0.3173828; 1.6839439 0.123291016; 0.80657154 Multiscale Conditional HINT invertibility test with squeeze_type=WaveletLayer, split_scales=true, logdet=false Multiscale Conditional HINT gradient test with squeeze_type=WaveletLayer, split_scales=true, logdet=false 0.1897124; 0.18912023 0.043896034; 0.043599952 0.011594623; 0.011446582 0.0033985078; 0.0033244875 0.0008973181; 0.00086030795 Multiscale Conditional HINT invertibility test with squeeze_type=WaveletLayer, split_scales=true, logdet=true Multiscale Conditional HINT gradient test with squeeze_type=WaveletLayer, split_scales=true, logdet=true 108.70618; 120.89197 30.755127; 36.848022 5.7904053; 8.836851 0.97021484; 2.493438 0.020751953; 0.7408597 Multiscale Conditional HINT invertibility test with squeeze_type=WaveletLayer, split_scales=false, logdet=false Multiscale Conditional HINT gradient test with squeeze_type=WaveletLayer, split_scales=false, logdet=false 180.88351; 199.41824 38.49398; 47.761345 8.965988; 13.59967 2.5552902; 4.8721313 0.55371094; 1.7121315 Multiscale Conditional HINT invertibility test with squeeze_type=WaveletLayer, split_scales=false, logdet=true Multiscale Conditional HINT gradient test with squeeze_type=WaveletLayer, split_scales=false, logdet=true 71.27588; 56.51244 9.1484375; 16.530159 4.158203; 7.849064 0.6489258; 2.4943562 0.18579102; 0.7369242 Multiscale Conditional HINT invertibility test with squeeze_type=HaarLayer, split_scales=true, logdet=false Multiscale Conditional HINT gradient test with squeeze_type=HaarLayer, split_scales=true, logdet=false 0.39765114; 0.4374489 0.08068308; 0.10058197 0.016768843; 0.026718285 0.0025344193; 0.00750914 0.00028339028; 0.00220397 Multiscale Conditional HINT invertibility test with squeeze_type=HaarLayer, split_scales=true, logdet=true Multiscale Conditional HINT gradient test with squeeze_type=HaarLayer, split_scales=true, logdet=true 136.47766; 113.292145 41.400024; 29.807268 12.420288; 6.623909 4.10376; 1.2055702 1.6922607; 0.24316609 Multiscale Conditional HINT invertibility test with squeeze_type=HaarLayer, split_scales=false, logdet=false Multiscale Conditional HINT gradient test with squeeze_type=HaarLayer, split_scales=false, logdet=false 390.83392; 427.20135 62.479057; 80.66277 8.682854; 17.774712 1.3056183; 3.240311 1.9436798; 0.3292848 Multiscale Conditional HINT invertibility test with squeeze_type=HaarLayer, split_scales=false, logdet=true Multiscale Conditional HINT gradient test with squeeze_type=HaarLayer, split_scales=false, logdet=true 51.945312; 64.22114 25.264404; 19.126492 10.261475; 7.192518 3.048584; 1.5141062 0.8564453; 0.0892064 Jacobian test 30.529066; 15.298814 12.53632; 4.1191573 5.745388; 1.3361905 2.777173; 0.44897848 1.3659217; 0.1444986 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_multiscale_conditional_hint_network.jl:49 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_conditional_hint_network.jl:50. Invertibility test HINT network Gradient test cond. HINT net: input 78.7323; 13.066368 42.497437; 3.4018974 22.09436; 0.8553066 11.240234; 0.23459911 5.6817627; 0.05565405 2.855713; 0.0129954815 Invertibility test HINT network Gradient test cond. HINT net: input 69.20566; 9.53241 36.957214; 2.4118195 19.095123; 0.5893936 9.706146; 0.13611221 4.8923645; 0.028764725 2.4532166; 0.0073480606 Invertibility test HINT network Gradient test cond. HINT net: input 97.983154; 7.3814545 50.767944; 1.91436 25.897339; 0.44381332 13.074951; 0.09562492 6.5720215; 0.013266563 3.2885742; 0.004069805 Invertibility test HINT network Gradient test cond. HINT net: input 78.5141; 6.162014 40.68567; 1.6523876 20.805542; 0.3634863 10.519836; 0.06467724 5.283203; 0.009053707 2.6420898; 0.0040385723 Jacobian test 21.058523; 13.525656 11.417022; 4.6037498 5.919556; 1.5742716 3.02378; 0.52976996 1.5278748; 0.17143705 WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_conditional_hint_network.jl:50 overwritten at /home/pkgeval/.julia/packages/InvertibleNetworks/NquDv/test/test_networks/test_conditional_glow_network.jl:99. Gradient test glow: input 118.4306; 14.168076 62.65277; 3.6465683 32.185364; 0.9643059 16.31903; 0.25580406 Gradient test glow: input 5.20166; 0.89034045 2.8319092; 0.21409112 1.4716187; 0.0513815 0.7475586; 0.013941482 Gradient test glow: input 137.91669; 17.088058 73.10339; 4.398979 37.586; 1.1651878 19.063232; 0.31236076 Gradient test glow: input 12.586548; 3.041328 7.1844482; 0.62948966 3.746704; 0.16026485 1.9017334; 0.051751077 Gradient test glow: input 4207.543; 491.34082 2225.3125; 124.129395 1143.5508; 31.170166 579.46875; 7.8917236 Gradient test glow: input 279.67578; 55.630196 153.96484; 13.688145 80.708984; 3.1175098 41.26172; 0.6515284 Gradient test glow: input 4116.8945; 489.3081 2180.3203; 122.781006 1120.791; 30.759644 568.06836; 7.70697 Gradient test glow: input 181.01562; 33.859337 99.203125; 8.234356 51.632812; 2.085928 26.316406; 0.5429639 Test Summary: | Pass Total Time Networks | 282 282 9m46.6s Test test_networks/test_unrolled_loop.jl | 10 10 40.2s Test test_networks/test_generator.jl | 5 5 2.7s Test test_networks/test_glow.jl | 80 80 4m36.1s Test test_networks/test_dense_glow.jl | 14 14 15.5s Test test_networks/test_hyperbolic_network.jl | 17 17 3.4s Test test_networks/test_multiscale_hint_network.jl | 7 7 15.5s Test test_networks/test_multiscale_conditional_hint_network.jl | 87 87 13.8s Test test_networks/test_conditional_hint_network.jl | 31 31 7.4s Test test_networks/test_conditional_glow_network.jl | 31 31 3m32.1s ───────────────────────────────────────────────────────────────────────────────────────────────────── Time Allocations ─────────────── ─────────────── Total measured: 1125s 96.4GiB Section ncalls time %tot alloc %tot ───────────────────────────────────────────────────────────────────────────────────────────────────── test_utils/test_objectives.jl 1 14.4s 1.3% 106MiB 0.1% test_utils/test_sequential.jl 1 160s 14.3% 5.40GiB 5.6% test_utils/test_nnlib_convolution.jl 1 11.1s 1.0% 485MiB 0.5% test_utils/test_activations.jl 1 29.0s 2.6% 184MiB 0.2% test_utils/test_squeeze.jl 1 55.8s 5.0% 749MiB 0.8% test_utils/test_jacobian.jl 1 1.37s 0.1% 63.4MiB 0.1% test_utils/test_chainrules.jl 1 112s 10.0% 4.33GiB 4.5% test_utils/test_flux.jl 1 23.7s 2.1% 384MiB 0.4% test_layers/test_residual_block.jl 1 1.77s 0.2% 175MiB 0.2% test_layers/test_flux_block.jl 1 4.04s 0.4% 140MiB 0.1% test_layers/test_resnet.jl 1 20.5s 1.8% 299MiB 0.3% test_layers/test_layer_conv1x1.jl 1 1.72s 0.2% 67.5MiB 0.1% test_layers/test_coupling_layer_basic.jl 1 3.05s 0.3% 66.3MiB 0.1% test_layers/test_coupling_layer_irim.jl 1 1.55s 0.1% 121MiB 0.1% test_layers/test_coupling_layer_glow.jl 1 33.6s 3.0% 689MiB 0.7% test_layers/test_coupling_layer_hint.jl 1 4.15s 0.4% 650MiB 0.7% test_layers/test_conditional_layer_glow.jl 1 905ms 0.1% 64.1MiB 0.1% test_layers/test_conditional_layer_hint.jl 1 22.0s 2.0% 3.87GiB 4.0% test_layers/test_conditional_res_block.jl 1 9.34s 0.8% 2.42GiB 2.5% test_layers/test_hyperbolic_layer.jl 1 9.77s 0.9% 543MiB 0.6% test_layers/test_actnorm.jl 1 5.60s 0.5% 50.0MiB 0.1% test_layers/test_layer_affine.jl 1 8.25s 0.7% 110MiB 0.1% test_networks/test_unrolled_loop.jl 1 40.2s 3.6% 662MiB 0.7% test_networks/test_generator.jl 1 2.67s 0.2% 210MiB 0.2% test_networks/test_glow.jl 1 276s 24.7% 45.5GiB 47.2% test_networks/test_dense_glow.jl 1 15.5s 1.4% 276MiB 0.3% test_networks/test_hyperbolic_network.jl 1 3.37s 0.3% 519MiB 0.5% test_networks/test_multiscale_hint_network.jl 1 15.5s 1.4% 2.87GiB 3.0% test_networks/test_multiscale_conditional_hint_network.jl 1 13.8s 1.2% 2.09GiB 2.2% test_networks/test_conditional_hint_network.jl 1 7.42s 0.7% 1.03GiB 1.1% test_networks/test_conditional_glow_network.jl 1 212s 18.9% 22.4GiB 23.2% ───────────────────────────────────────────────────────────────────────────────────────────────────── Testing InvertibleNetworks tests passed Testing completed after 1171.19s PkgEval succeeded after 1895.46s