diff --git a/.github/workflows/literate.yml b/.github/workflows/literate.yml index 3e74b21..c2f10ea 100644 --- a/.github/workflows/literate.yml +++ b/.github/workflows/literate.yml @@ -30,6 +30,6 @@ jobs: include("make.jl") ' - - uses: stefanzweifel/git-auto-commit-action@v5 + - uses: stefanzweifel/git-auto-commit-action@v6 with: commit_message: Autogenerate markdown and notebook diff --git a/.github/workflows/run_burgers.yml b/.github/workflows/run_burgers.yml index fbcb608..d28e278 100644 --- a/.github/workflows/run_burgers.yml +++ b/.github/workflows/run_burgers.yml @@ -32,6 +32,6 @@ jobs: - run: | git pull - - uses: stefanzweifel/git-auto-commit-action@v5 + - uses: stefanzweifel/git-auto-commit-action@v6 with: commit_message: Run Burgers notebook diff --git a/tutorials/burgers.ipynb b/tutorials/burgers.ipynb index 2e72b45..af9061c 100644 --- a/tutorials/burgers.ipynb +++ b/tutorials/burgers.ipynb @@ -2047,11 +2047,11 @@ "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.10.5" + "version": "1.11.5" }, "kernelspec": { - "name": "julia-1.10", - "display_name": "Julia 1.10.5", + "name": "julia-1.11", + "display_name": "Julia 1.11.5", "language": "julia" } }, diff --git a/tutorials/burgers_with_output.ipynb b/tutorials/burgers_with_output.ipynb index deb2bd9..a37c0ac 100644 --- a/tutorials/burgers_with_output.ipynb +++ b/tutorials/burgers_with_output.ipynb @@ -165,7 +165,339 @@ "execution_count": 5 }, { - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precompiling ComponentArrays...\n", + " 505.1 ms ✓ IfElse\n", + " 570.9 ms ✓ CommonWorldInvalidations\n", + " 607.4 ms ✓ ConstructionBase\n", + " 748.0 ms ✓ StaticArraysCore\n", + " 811.4 ms ✓ Requires\n", + " 591.2 ms ✓ ConstructionBase → ConstructionBaseLinearAlgebraExt\n", + " 726.5 ms ✓ Compat\n", + " 504.1 ms ✓ Adapt\n", + " 1013.7 ms ✓ Static\n", + " 415.0 ms ✓ Compat → CompatLinearAlgebraExt\n", + " 493.6 ms ✓ ArrayInterface\n", + " 457.0 ms ✓ ArrayInterface → ArrayInterfaceStaticArraysCoreExt\n", + " 809.2 ms ✓ Functors\n", + " 1417.5 ms ✓ ChainRulesCore\n", + " 1317.9 ms ✓ StaticArrayInterface\n", + " 343.2 ms ✓ ArrayInterface → ArrayInterfaceChainRulesCoreExt\n", + " 883.0 ms ✓ ComponentArrays\n", + " 17 dependencies successfully precompiled in 4 seconds. 7 already precompiled.\n", + "Precompiling FFTW...\n", + " 386.1 ms ✓ Reexport\n", + " 496.1 ms ✓ AbstractFFTs\n", + " 530.9 ms ✓ JLLWrappers\n", + " 528.3 ms ✓ oneTBB_jll\n", + " 662.4 ms ✓ FFTW_jll\n", + " 1145.3 ms ✓ IntelOpenMP_jll\n", + " 3500.1 ms ✓ MKL_jll\n", + " 9491.3 ms ✓ FFTW\n", + " 8 dependencies successfully precompiled in 15 seconds. 25 already precompiled.\n", + " 1 dependency had output during precompilation:\n", + "┌ MKL_jll\n", + "│ Downloading artifact: IntelOpenMP\n", + "└ \n", + "Precompiling AbstractFFTsChainRulesCoreExt...\n", + " 405.1 ms ✓ AbstractFFTs → AbstractFFTsChainRulesCoreExt\n", + " 1 dependency successfully precompiled in 0 seconds. 9 already precompiled.\n", + "Precompiling Lux...\n", + " 521.7 ms ✓ ConcreteStructs\n", + " 712.0 ms ✓ ArgCheck\n", + " 895.6 ms ✓ ADTypes\n", + " 1059.5 ms ✓ Statistics\n", + " 632.2 ms ✓ ManualMemory\n", + " 509.5 ms ✓ SIMDTypes\n", + " 884.5 ms ✓ DocStringExtensions\n", + " 643.5 ms ✓ HashArrayMappedTries\n", + " 612.7 ms ✓ NaNMath\n", + " 1013.6 ms ✓ EnzymeCore\n", + " 597.3 ms ✓ FastClosures\n", + " 3175.5 ms ✓ UnsafeAtomics\n", + " 1904.8 ms ✓ IrrationalConstants\n", + " 714.1 ms ✓ DiffResults\n", + " 903.1 ms ✓ GPUArraysCore\n", + " 1090.5 ms ✓ CpuId\n", + " 1420.5 ms ✓ MLDataDevices\n", + " 4311.9 ms ✓ MacroTools\n", + " 969.8 ms ✓ OpenSpecFun_jll\n", + " 796.5 ms ✓ BitTwiddlingConvenienceFunctions\n", + " 736.5 ms ✓ CloseOpenIntervals\n", + " 606.3 ms ✓ ADTypes → ADTypesChainRulesCoreExt\n", + " 755.5 ms ✓ ADTypes → ADTypesConstructionBaseExt\n", + " 630.6 ms ✓ ScopedValues\n", + " 971.9 ms ✓ LayoutPointers\n", + " 1446.9 ms ✓ Optimisers\n", + " 1271.1 ms ✓ ThreadingUtilities\n", + " 468.9 ms ✓ ADTypes → ADTypesEnzymeCoreExt\n", + " 837.0 ms ✓ EnzymeCore → AdaptExt\n", + " 786.0 ms ✓ Atomix\n", + " 587.4 ms ✓ ArrayInterface → ArrayInterfaceGPUArraysCoreExt\n", + " 945.5 ms ✓ LogExpFunctions\n", + " 786.1 ms ✓ MLDataDevices → MLDataDevicesChainRulesCoreExt\n", + " 742.1 ms ✓ CommonSubexpressions\n", + " 1630.8 ms ✓ CPUSummary\n", + " 2196.3 ms ✓ DispatchDoctor\n", + " 1677.5 ms ✓ StrideArraysCore\n", + " 2303.1 ms ✓ Setfield\n", + " 1003.1 ms ✓ PolyesterWeave\n", + " 2225.9 ms ✓ LogExpFunctions → LogExpFunctionsChainRulesCoreExt\n", + " 778.7 ms ✓ DispatchDoctor → DispatchDoctorEnzymeCoreExt\n", + " 784.8 ms ✓ DispatchDoctor → DispatchDoctorChainRulesCoreExt\n", + " 920.0 ms ✓ Polyester\n", + " 1743.0 ms ✓ LuxCore\n", + " 613.6 ms ✓ LuxCore → LuxCoreFunctorsExt\n", + " 776.6 ms ✓ LuxCore → LuxCoreChainRulesCoreExt\n", + " 865.4 ms ✓ LuxCore → LuxCoreEnzymeCoreExt\n", + " 550.5 ms ✓ LuxCore → LuxCoreSetfieldExt\n", + " 4124.0 ms ✓ SpecialFunctions\n", + " 666.8 ms ✓ LuxCore → LuxCoreMLDataDevicesExt\n", + " 1155.3 ms ✓ DiffRules\n", + " 12682.7 ms ✓ StaticArrays\n", + " 2700.8 ms ✓ SpecialFunctions → SpecialFunctionsChainRulesCoreExt\n", + " 1068.8 ms ✓ StaticArrays → StaticArraysStatisticsExt\n", + " 1077.3 ms ✓ ConstructionBase → ConstructionBaseStaticArraysExt\n", + " 1140.2 ms ✓ StaticArrays → StaticArraysChainRulesCoreExt\n", + " 821.6 ms ✓ Adapt → AdaptStaticArraysExt\n", + " 827.3 ms ✓ StaticArrayInterface → StaticArrayInterfaceStaticArraysExt\n", + " 4742.7 ms ✓ WeightInitializers\n", + " 953.2 ms ✓ WeightInitializers → WeightInitializersChainRulesCoreExt\n", + " 4816.1 ms ✓ ForwardDiff\n", + " 695.6 ms ✓ ForwardDiff → ForwardDiffStaticArraysExt\n", + " 3906.6 ms ✓ KernelAbstractions\n", + " 608.1 ms ✓ KernelAbstractions → LinearAlgebraExt\n", + " 679.1 ms ✓ KernelAbstractions → EnzymeExt\n", + " 4507.3 ms ✓ NNlib\n", + " 718.7 ms ✓ NNlib → NNlibSpecialFunctionsExt\n", + " 1010.6 ms ✓ NNlib → NNlibForwardDiffExt\n", + " 1038.2 ms ✓ NNlib → NNlibEnzymeCoreExt\n", + " 3856.1 ms ✓ LuxLib\n", + " 7626.6 ms ✓ Lux\n", + " 71 dependencies successfully precompiled in 40 seconds. 32 already precompiled.\n", + "Precompiling ComponentArraysKernelAbstractionsExt...\n", + " 1214.3 ms ✓ ComponentArrays → ComponentArraysKernelAbstractionsExt\n", + " 1 dependency successfully precompiled in 1 seconds. 37 already precompiled.\n", + "Precompiling NNlibFFTWExt...\n", + " 780.8 ms ✓ NNlib → NNlibFFTWExt\n", + " 1 dependency successfully precompiled in 1 seconds. 56 already precompiled.\n", + "Precompiling ComponentArraysOptimisersExt...\n", + " 429.9 ms ✓ ComponentArrays → ComponentArraysOptimisersExt\n", + " 1 dependency successfully precompiled in 1 seconds. 26 already precompiled.\n", + "Precompiling MLDataDevicesComponentArraysExt...\n", + " 430.5 ms ✓ MLDataDevices → MLDataDevicesComponentArraysExt\n", + " 1 dependency successfully precompiled in 0 seconds. 26 already precompiled.\n", + "Precompiling LuxComponentArraysExt...\n", + " 1061.3 ms ✓ Lux → LuxComponentArraysExt\n", + " 1 dependency successfully precompiled in 1 seconds. 107 already precompiled.\n", + "Precompiling Plots...\n", + " 489.4 ms ✓ LaTeXStrings\n", + " 560.4 ms ✓ TensorCore\n", + " 643.2 ms ✓ Contour\n", + " 679.7 ms ✓ StatsAPI\n", + " 581.5 ms ✓ Measures\n", + " 691.9 ms ✓ StableRNGs\n", + " 876.1 ms ✓ OrderedCollections\n", + " 1817.2 ms ✓ Format\n", + " 961.9 ms ✓ Unzip\n", + " 521.5 ms ✓ SimpleBufferStream\n", + " 1637.7 ms ✓ Grisu\n", + " 948.9 ms ✓ URIs\n", + " 554.2 ms ✓ PtrArrays\n", + " 550.7 ms ✓ DataAPI\n", + " 762.1 ms ✓ DelimitedFiles\n", + " 550.1 ms ✓ BitFlags\n", + " 992.2 ms ✓ TranscodingStreams\n", + " 819.7 ms ✓ Statistics → SparseArraysExt\n", + " 579.7 ms ✓ Scratch\n", + " 1401.7 ms ✓ ConcurrentUtilities\n", + " 1617.5 ms ✓ MbedTLS\n", + " 974.1 ms ✓ LoggingExtras\n", + " 811.4 ms ✓ ExceptionUnwrapping\n", + " 949.1 ms ✓ OpenSSL_jll\n", + " 1216.6 ms ✓ Graphite2_jll\n", + " 1112.4 ms ✓ Libmount_jll\n", + " 2670.0 ms ✓ UnicodeFun\n", + " 4339.7 ms ✓ FixedPointNumbers\n", + " 813.7 ms ✓ LLVMOpenMP_jll\n", + " 798.2 ms ✓ Bzip2_jll\n", + " 1109.4 ms ✓ EpollShim_jll\n", + " 805.3 ms ✓ Xorg_libICE_jll\n", + " 773.8 ms ✓ libfdk_aac_jll\n", + " 889.7 ms ✓ libpng_jll\n", + " 1240.0 ms ✓ Xorg_libXau_jll\n", + " 945.2 ms ✓ LAME_jll\n", + " 886.5 ms ✓ LERC_jll\n", + " 895.4 ms ✓ fzf_jll\n", + " 1138.9 ms ✓ JpegTurbo_jll\n", + " 1126.0 ms ✓ XZ_jll\n", + " 805.2 ms ✓ mtdev_jll\n", + " 873.7 ms ✓ Ogg_jll\n", + " 846.2 ms ✓ Xorg_libXdmcp_jll\n", + " 1014.8 ms ✓ x265_jll\n", + " 972.8 ms ✓ x264_jll\n", + " 1129.6 ms ✓ libaom_jll\n", + " 895.3 ms ✓ Zstd_jll\n", + " 817.6 ms ✓ Expat_jll\n", + " 825.9 ms ✓ LZO_jll\n", + " 1018.7 ms ✓ Opus_jll\n", + " 689.2 ms ✓ libevdev_jll\n", + " 1051.1 ms ✓ Xorg_xtrans_jll\n", + " 766.5 ms ✓ Libiconv_jll\n", + " 898.5 ms ✓ Libffi_jll\n", + " 694.1 ms ✓ Wayland_protocols_jll\n", + " 912.6 ms ✓ eudev_jll\n", + " 1125.5 ms ✓ Libuuid_jll\n", + " 869.8 ms ✓ FriBidi_jll\n", + " 737.1 ms ✓ Showoff\n", + " 746.6 ms ✓ AliasTables\n", + " 2851.6 ms ✓ DataStructures\n", + " 2877.6 ms ✓ RecipesBase\n", + " 881.8 ms ✓ Missings\n", + " 656.6 ms ✓ CodecZlib\n", + " 659.7 ms ✓ RelocatableFolders\n", + " 1115.7 ms ✓ Pixman_jll\n", + " 1079.1 ms ✓ FreeType2_jll\n", + " 2949.4 ms ✓ ColorTypes\n", + " 3673.2 ms ✓ OpenSSL\n", + " 6351.6 ms ✓ Latexify\n", + " 1170.0 ms ✓ Xorg_libSM_jll\n", + " 1014.7 ms ✓ libvorbis_jll\n", + " 956.8 ms ✓ Libtiff_jll\n", + " 1439.0 ms ✓ JLFzf\n", + " 1093.0 ms ✓ Dbus_jll\n", + " 947.4 ms ✓ libinput_jll\n", + " 1071.9 ms ✓ XML2_jll\n", + " 2445.7 ms ✓ Xorg_libxcb_jll\n", + " 1065.5 ms ✓ SortingAlgorithms\n", + " 736.3 ms ✓ ColorTypes → StyledStringsExt\n", + " 1502.2 ms ✓ Fontconfig_jll\n", + " 1173.4 ms ✓ Latexify → SparseArraysExt\n", + " 3565.9 ms ✓ ColorVectorSpace\n", + " 1209.4 ms ✓ Gettext_jll\n", + " 1320.2 ms ✓ Wayland_jll\n", + " 1092.5 ms ✓ Xorg_xcb_util_jll\n", + " 1118.0 ms ✓ Xorg_libX11_jll\n", + " 1321.2 ms ✓ Glib_jll\n", + " 1260.7 ms ✓ Xorg_xcb_util_image_jll\n", + " 4125.2 ms ✓ StatsBase\n", + " 1662.9 ms ✓ Xorg_xcb_util_keysyms_jll\n", + " 1693.2 ms ✓ Xorg_xcb_util_renderutil_jll\n", + " 10037.4 ms ✓ Colors\n", + " 1413.6 ms ✓ Xorg_xcb_util_wm_jll\n", + " 1193.9 ms ✓ Xorg_libXrender_jll\n", + " 1276.8 ms ✓ Xorg_libXext_jll\n", + " 1292.0 ms ✓ Xorg_libXfixes_jll\n", + " 1203.7 ms ✓ Xorg_libxkbfile_jll\n", + " 1383.2 ms ✓ Xorg_xcb_util_cursor_jll\n", + " 1424.0 ms ✓ Xorg_libXinerama_jll\n", + " 1119.0 ms ✓ Xorg_libXrandr_jll\n", + " 1574.6 ms ✓ Libglvnd_jll\n", + " 1386.0 ms ✓ Cairo_jll\n", + " 1223.3 ms ✓ Xorg_libXcursor_jll\n", + " 1317.1 ms ✓ Xorg_libXi_jll\n", + " 1175.7 ms ✓ Xorg_xkbcomp_jll\n", + " 1619.4 ms ✓ HarfBuzz_jll\n", + " 962.4 ms ✓ Xorg_xkeyboard_config_jll\n", + " 7077.0 ms ✓ ColorSchemes\n", + " 1470.5 ms ✓ libass_jll\n", + " 1548.3 ms ✓ Pango_jll\n", + " 1280.7 ms ✓ xkbcommon_jll\n", + " 41641.1 ms ✓ Unitful\n", + " 1046.8 ms ✓ Vulkan_Loader_jll\n", + " 1766.0 ms ✓ FFMPEG_jll\n", + " 1176.6 ms ✓ libdecor_jll\n", + " 1149.2 ms ✓ Unitful → PrintfExt\n", + " 1088.0 ms ✓ FFMPEG\n", + " 1735.8 ms ✓ Qt6Base_jll\n", + " 1537.8 ms ✓ GLFW_jll\n", + " 1142.4 ms ✓ Qt6ShaderTools_jll\n", + " 1886.4 ms ✓ UnitfulLatexify\n", + " 1753.0 ms ✓ GR_jll\n", + " 3253.7 ms ✓ Qt6Declarative_jll\n", + " 611.7 ms ✓ Qt6Wayland_jll\n", + " 35703.7 ms ✓ HTTP\n", + " 16748.8 ms ✓ PlotUtils\n", + " 4156.4 ms ✓ PlotThemes\n", + " 5648.1 ms ✓ GR\n", + " 5391.2 ms ✓ RecipesPipeline\n", + " 69522.1 ms ✓ Plots\n", + " 3008.1 ms ✓ Plots → UnitfulExt\n", + " 132 dependencies successfully precompiled in 138 seconds. 50 already precompiled.\n", + "Precompiling ChainRulesCoreSparseArraysExt...\n", + " 491.0 ms ✓ ChainRulesCore → ChainRulesCoreSparseArraysExt\n", + " 1 dependency successfully precompiled in 1 seconds. 11 already precompiled.\n", + "Precompiling ArrayInterfaceSparseArraysExt...\n", + " 469.4 ms ✓ Adapt → AdaptSparseArraysExt\n", + " 494.9 ms ✓ ArrayInterface → ArrayInterfaceSparseArraysExt\n", + " 2 dependencies successfully precompiled in 1 seconds. 7 already precompiled.\n", + "Precompiling SparseArraysExt...\n", + " 738.7 ms ✓ KernelAbstractions → SparseArraysExt\n", + " 1 dependency successfully precompiled in 1 seconds. 32 already precompiled.\n", + "Precompiling MLDataDevicesSparseArraysExt...\n", + " 507.7 ms ✓ MLDataDevices → MLDataDevicesSparseArraysExt\n", + " 1 dependency successfully precompiled in 1 seconds. 18 already precompiled.\n", + "Precompiling SpecialFunctionsExt...\n", + " 560.2 ms ✓ ColorVectorSpace → SpecialFunctionsExt\n", + " 1 dependency successfully precompiled in 1 seconds. 20 already precompiled.\n", + "Precompiling Zygote...\n", + " 496.9 ms ✓ IteratorInterfaceExtensions\n", + " 516.4 ms ✓ DataValueInterfaces\n", + " 577.4 ms ✓ RealDot\n", + " 610.6 ms ✓ CEnum\n", + " 852.1 ms ✓ SuiteSparse\n", + " 1617.0 ms ✓ FillArrays\n", + " 1221.6 ms ✓ ZygoteRules\n", + " 496.5 ms ✓ TableTraits\n", + " 667.9 ms ✓ FillArrays → FillArraysStatisticsExt\n", + " 996.5 ms ✓ SparseInverseSubset\n", + " 2064.3 ms ✓ LLVMExtra_jll\n", + " 913.0 ms ✓ FillArrays → FillArraysSparseArraysExt\n", + " 2678.5 ms ✓ IRTools\n", + " 895.3 ms ✓ Tables\n", + " 706.9 ms ✓ StructArrays\n", + " 553.3 ms ✓ StructArrays → StructArraysAdaptExt\n", + " 1035.2 ms ✓ StructArrays → StructArraysSparseArraysExt\n", + " 1164.4 ms ✓ StructArrays → StructArraysStaticArraysExt\n", + " 636.4 ms ✓ StructArrays → StructArraysLinearAlgebraExt\n", + " 1225.7 ms ✓ StructArrays → StructArraysGPUArraysCoreExt\n", + " 7149.6 ms ✓ LLVM\n", + " 5332.2 ms ✓ ChainRules\n", + " 1547.1 ms ✓ UnsafeAtomics → UnsafeAtomicsLLVM\n", + " 3453.5 ms ✓ GPUArrays\n", + " 33618.7 ms ✓ Zygote\n", + " 25 dependencies successfully precompiled in 49 seconds. 78 already precompiled.\n", + "Precompiling ArrayInterfaceChainRulesExt...\n", + " 568.9 ms ✓ ArrayInterface → ArrayInterfaceChainRulesExt\n", + " 1 dependency successfully precompiled in 1 seconds. 40 already precompiled.\n", + "Precompiling MLDataDevicesChainRulesExt...\n", + " 622.5 ms ✓ MLDataDevices → MLDataDevicesChainRulesExt\n", + " 1 dependency successfully precompiled in 1 seconds. 41 already precompiled.\n", + "Precompiling MLDataDevicesFillArraysExt...\n", + " 392.3 ms ✓ MLDataDevices → MLDataDevicesFillArraysExt\n", + " 1 dependency successfully precompiled in 0 seconds. 15 already precompiled.\n", + "Precompiling ComponentArraysZygoteExt...\n", + " 1222.2 ms ✓ ComponentArrays → ComponentArraysZygoteExt\n", + " 1582.8 ms ✓ ComponentArrays → ComponentArraysGPUArraysExt\n", + " 2 dependencies successfully precompiled in 2 seconds. 117 already precompiled.\n", + "Precompiling MLDataDevicesZygoteExt...\n", + " 1257.8 ms ✓ MLDataDevices → MLDataDevicesZygoteExt\n", + " 1305.5 ms ✓ MLDataDevices → MLDataDevicesGPUArraysExt\n", + " 2 dependencies successfully precompiled in 2 seconds. 109 already precompiled.\n", + "Precompiling LuxZygoteExt...\n", + " 1331.8 ms ✓ WeightInitializers → WeightInitializersGPUArraysExt\n", + " 1856.0 ms ✓ Lux → LuxZygoteExt\n", + " 2 dependencies successfully precompiled in 2 seconds. 163 already precompiled.\n", + "Precompiling ZygoteColorsExt...\n", + " 1283.9 ms ✓ Zygote → ZygoteColorsExt\n", + " 1 dependency successfully precompiled in 1 seconds. 106 already precompiled.\n" + ] + } + ], "cell_type": "code", "source": [ "using ComponentArrays\n", @@ -572,13 +904,13 @@ "output_type": "stream", "text": [ "GKS: cannot open display - headless operation mode active\n", - "[ Info: Saved animation to /tmp/jl_1mV4halcb2.gif\n" + "[ Info: Saved animation to /tmp/jl_yDQt2f45Gv.gif\n" ] }, { "output_type": "execute_result", "data": { - "text/plain": "Plots.AnimatedGif(\"/tmp/jl_1mV4halcb2.gif\")", + "text/plain": "Plots.AnimatedGif(\"/tmp/jl_yDQt2f45Gv.gif\")", "text/html": [ "" ] @@ -901,47 +1233,47 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -2517,13 +2849,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ Info: Saved animation to /tmp/jl_Vs7cvwDedY.gif\n" + "[ Info: Saved animation to /tmp/jl_SXYFArATql.gif\n" ] }, { "output_type": "execute_result", "data": { - "text/plain": "Plots.AnimatedGif(\"/tmp/jl_Vs7cvwDedY.gif\")", + "text/plain": "Plots.AnimatedGif(\"/tmp/jl_SXYFArATql.gif\")", "text/html": [ "" ] @@ -2927,7 +3259,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "Main.var\"##225\".train" + "text/plain": "Main.var\"##230\".train" }, "metadata": {}, "execution_count": 27 @@ -3035,7 +3367,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "Main.var\"##225\".create_cnn" + "text/plain": "Main.var\"##230\".create_cnn" }, "metadata": {}, "execution_count": 29 @@ -3224,7 +3556,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "Main.var\"##225\".FourierLayer" + "text/plain": "Main.var\"##230\".FourierLayer" }, "metadata": {}, "execution_count": 31 @@ -3411,7 +3743,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "Main.var\"##225\".create_fno" + "text/plain": "Main.var\"##230\".create_fno" }, "metadata": {}, "execution_count": 35 @@ -3523,7 +3855,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "Chain(\n layer_1 = WrappedFunction(#56),\n layer_2 = WrappedFunction(#57),\n layer_3 = WrappedFunction(#59),\n layer_4 = Conv((5,), 2 => 8, leakyrelu), \u001b[90m# 88 parameters\u001b[39m\n layer_5 = Conv((5,), 8 => 8, leakyrelu), \u001b[90m# 328 parameters\u001b[39m\n layer_6 = Conv((5,), 8 => 8, leakyrelu), \u001b[90m# 328 parameters\u001b[39m\n layer_7 = Conv((5,), 8 => 1, gelu, use_bias=false), \u001b[90m# 40 parameters\u001b[39m\n layer_8 = WrappedFunction(#61),\n) \u001b[90m # Total: \u001b[39m784 parameters,\n\u001b[90m # plus \u001b[39m0 states." + "text/plain": "Chain(\n layer_1 = WrappedFunction(#56),\n layer_2 = WrappedFunction(#57),\n layer_3 = WrappedFunction(#59),\n layer_4 = Conv((5,), 2 => 8, leakyrelu), \u001b[90m# 88 parameters\u001b[39m\n layer_5 = Conv((5,), 8 => 8, leakyrelu), \u001b[90m# 328 parameters\u001b[39m\n layer_6 = Conv((5,), 8 => 8, leakyrelu), \u001b[90m# 328 parameters\u001b[39m\n layer_7 = Conv((5,), 8 => 1, gelu_tanh, use_bias=false), \u001b[90m# 40 parameters\u001b[39m\n layer_8 = WrappedFunction(#61),\n) \u001b[90m # Total: \u001b[39m784 parameters,\n\u001b[90m # plus \u001b[39m0 states." }, "metadata": {}, "execution_count": 37 @@ -3551,7 +3883,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "Chain(\n layer_1 = WrappedFunction(#75),\n layer_2 = WrappedFunction(#76),\n layer_3 = FourierLayer(16, 2 => 5; σ = gelu), \u001b[90m# 350 parameters\u001b[39m\n layer_4 = FourierLayer(16, 5 => 5; σ = gelu), \u001b[90m# 875 parameters\u001b[39m\n layer_5 = FourierLayer(16, 5 => 5; σ = gelu), \u001b[90m# 875 parameters\u001b[39m\n layer_6 = FourierLayer(8, 5 => 5; σ = identity), \u001b[90m# 475 parameters\u001b[39m\n layer_7 = WrappedFunction(#79),\n layer_8 = Dense(5 => 10, gelu), \u001b[90m# 60 parameters\u001b[39m\n layer_9 = Dense(10 => 1, use_bias=false), \u001b[90m# 10 parameters\u001b[39m\n layer_10 = WrappedFunction(#80),\n layer_11 = WrappedFunction(#81),\n) \u001b[90m # Total: \u001b[39m2_645 parameters,\n\u001b[90m # plus \u001b[39m0 states." + "text/plain": "Chain(\n layer_1 = WrappedFunction(#75),\n layer_2 = WrappedFunction(#76),\n layer_3 = FourierLayer(16, 2 => 5; σ = gelu_tanh), \u001b[90m# 350 parameters\u001b[39m\n layer_4 = FourierLayer(16, 5 => 5; σ = gelu_tanh), \u001b[90m# 875 parameters\u001b[39m\n layer_5 = FourierLayer(16, 5 => 5; σ = gelu_tanh), \u001b[90m# 875 parameters\u001b[39m\n layer_6 = FourierLayer(8, 5 => 5; σ = identity), \u001b[90m# 475 parameters\u001b[39m\n layer_7 = WrappedFunction(#79),\n layer_8 = Dense(5 => 10, gelu_tanh), \u001b[90m# 60 parameters\u001b[39m\n layer_9 = Dense(10 => 1, use_bias=false), \u001b[90m# 10 parameters\u001b[39m\n layer_10 = WrappedFunction(#80),\n layer_11 = WrappedFunction(#81),\n) \u001b[90m # Total: \u001b[39m2_645 parameters,\n\u001b[90m # plus \u001b[39m0 states." }, "metadata": {}, "execution_count": 38 @@ -3649,8 +3981,8 @@ "name": "stdout", "output_type": "stream", "text": [ - " 0.001081 seconds (389 allocations: 1.139 MiB)\n", - " 0.005515 seconds (2.21 k allocations: 3.477 MiB)\n" + " 0.001205 seconds (277 allocations: 1.127 MiB)\n", + " 0.004764 seconds (2.29 k allocations: 3.458 MiB)\n" ] } ], @@ -3680,162 +4012,162 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 20,\t\tprior error: 0.985,\t\tposterior error: 0.02898\n", - "Iteration 40,\t\tprior error: 0.9562,\t\tposterior error: 0.02801\n", - "Iteration 60,\t\tprior error: 0.8898,\t\tposterior error: 0.02574\n", - "Iteration 80,\t\tprior error: 0.8638,\t\tposterior error: 0.02533\n", - "Iteration 100,\t\tprior error: 0.8146,\t\tposterior error: 0.02337\n", - "Iteration 120,\t\tprior error: 0.7755,\t\tposterior error: 0.02224\n", - "Iteration 140,\t\tprior error: 0.7387,\t\tposterior error: 0.02093\n", - "Iteration 160,\t\tprior error: 0.6819,\t\tposterior error: 0.0196\n", - "Iteration 180,\t\tprior error: 0.623,\t\tposterior error: 0.01819\n", - "Iteration 200,\t\tprior error: 0.6038,\t\tposterior error: 0.01772\n", - "Iteration 220,\t\tprior error: 0.5712,\t\tposterior error: 0.01675\n", - "Iteration 240,\t\tprior error: 0.5329,\t\tposterior error: 0.0157\n", - "Iteration 260,\t\tprior error: 0.5587,\t\tposterior error: 0.01624\n", - "Iteration 280,\t\tprior error: 0.5146,\t\tposterior error: 0.01502\n", - "Iteration 300,\t\tprior error: 0.508,\t\tposterior error: 0.0148\n", - "Iteration 320,\t\tprior error: 0.5132,\t\tposterior error: 0.01481\n", - "Iteration 340,\t\tprior error: 0.4726,\t\tposterior error: 0.01358\n", - "Iteration 360,\t\tprior error: 0.4677,\t\tposterior error: 0.01327\n", - "Iteration 380,\t\tprior error: 0.4688,\t\tposterior error: 0.01357\n", - "Iteration 400,\t\tprior error: 0.4757,\t\tposterior error: 0.01344\n", - "Iteration 420,\t\tprior error: 0.4599,\t\tposterior error: 0.01304\n", - "Iteration 440,\t\tprior error: 0.4512,\t\tposterior error: 0.01256\n", - "Iteration 460,\t\tprior error: 0.4402,\t\tposterior error: 0.01234\n", - "Iteration 480,\t\tprior error: 0.4566,\t\tposterior error: 0.0125\n", - "Iteration 500,\t\tprior error: 0.4454,\t\tposterior error: 0.0121\n", - "Iteration 520,\t\tprior error: 0.4241,\t\tposterior error: 0.0116\n", - "Iteration 540,\t\tprior error: 0.4467,\t\tposterior error: 0.01196\n", - "Iteration 560,\t\tprior error: 0.4382,\t\tposterior error: 0.01177\n", - "Iteration 580,\t\tprior error: 0.4126,\t\tposterior error: 0.0111\n", - "Iteration 600,\t\tprior error: 0.4117,\t\tposterior error: 0.01057\n", - "Iteration 620,\t\tprior error: 0.3793,\t\tposterior error: 0.01004\n", - "Iteration 640,\t\tprior error: 0.4124,\t\tposterior error: 0.01106\n", - "Iteration 660,\t\tprior error: 0.3938,\t\tposterior error: 0.01038\n", - "Iteration 680,\t\tprior error: 0.3718,\t\tposterior error: 0.009838\n", - "Iteration 700,\t\tprior error: 0.3842,\t\tposterior error: 0.01001\n", - "Iteration 720,\t\tprior error: 0.3869,\t\tposterior error: 0.00993\n", - "Iteration 740,\t\tprior error: 0.3804,\t\tposterior error: 0.009704\n", - "Iteration 760,\t\tprior error: 0.3824,\t\tposterior error: 0.01034\n", - "Iteration 780,\t\tprior error: 0.3699,\t\tposterior error: 0.009565\n", - "Iteration 800,\t\tprior error: 0.3757,\t\tposterior error: 0.009733\n", - "Iteration 820,\t\tprior error: 0.3615,\t\tposterior error: 0.009383\n", - "Iteration 840,\t\tprior error: 0.3816,\t\tposterior error: 0.009849\n", - "Iteration 860,\t\tprior error: 0.35,\t\tposterior error: 0.008966\n", - "Iteration 880,\t\tprior error: 0.362,\t\tposterior error: 0.009223\n", - "Iteration 900,\t\tprior error: 0.3605,\t\tposterior error: 0.009269\n", - "Iteration 920,\t\tprior error: 0.3573,\t\tposterior error: 0.009031\n", - "Iteration 940,\t\tprior error: 0.3489,\t\tposterior error: 0.008913\n", - "Iteration 960,\t\tprior error: 0.3518,\t\tposterior error: 0.009243\n", - "Iteration 980,\t\tprior error: 0.372,\t\tposterior error: 0.009713\n", - "Iteration 1000,\t\tprior error: 0.363,\t\tposterior error: 0.00972\n" + "Iteration 20,\t\tprior error: 0.9851,\t\tposterior error: 0.02899\n", + "Iteration 40,\t\tprior error: 0.9571,\t\tposterior error: 0.02805\n", + "Iteration 60,\t\tprior error: 0.8839,\t\tposterior error: 0.02552\n", + "Iteration 80,\t\tprior error: 0.8529,\t\tposterior error: 0.02496\n", + "Iteration 100,\t\tprior error: 0.8379,\t\tposterior error: 0.02431\n", + "Iteration 120,\t\tprior error: 0.7718,\t\tposterior error: 0.0221\n", + "Iteration 140,\t\tprior error: 0.781,\t\tposterior error: 0.02197\n", + "Iteration 160,\t\tprior error: 0.6839,\t\tposterior error: 0.01964\n", + "Iteration 180,\t\tprior error: 0.6457,\t\tposterior error: 0.01889\n", + "Iteration 200,\t\tprior error: 0.5755,\t\tposterior error: 0.01733\n", + "Iteration 220,\t\tprior error: 0.5542,\t\tposterior error: 0.01661\n", + "Iteration 240,\t\tprior error: 0.5233,\t\tposterior error: 0.01575\n", + "Iteration 260,\t\tprior error: 0.5368,\t\tposterior error: 0.01606\n", + "Iteration 280,\t\tprior error: 0.4858,\t\tposterior error: 0.01466\n", + "Iteration 300,\t\tprior error: 0.4998,\t\tposterior error: 0.01484\n", + "Iteration 320,\t\tprior error: 0.4839,\t\tposterior error: 0.01404\n", + "Iteration 340,\t\tprior error: 0.4811,\t\tposterior error: 0.014\n", + "Iteration 360,\t\tprior error: 0.4444,\t\tposterior error: 0.0129\n", + "Iteration 380,\t\tprior error: 0.4802,\t\tposterior error: 0.01401\n", + "Iteration 400,\t\tprior error: 0.464,\t\tposterior error: 0.01325\n", + "Iteration 420,\t\tprior error: 0.4613,\t\tposterior error: 0.01301\n", + "Iteration 440,\t\tprior error: 0.4084,\t\tposterior error: 0.01162\n", + "Iteration 460,\t\tprior error: 0.4371,\t\tposterior error: 0.01238\n", + "Iteration 480,\t\tprior error: 0.4387,\t\tposterior error: 0.01243\n", + "Iteration 500,\t\tprior error: 0.4181,\t\tposterior error: 0.01148\n", + "Iteration 520,\t\tprior error: 0.4066,\t\tposterior error: 0.01099\n", + "Iteration 540,\t\tprior error: 0.3964,\t\tposterior error: 0.01125\n", + "Iteration 560,\t\tprior error: 0.4092,\t\tposterior error: 0.01126\n", + "Iteration 580,\t\tprior error: 0.3921,\t\tposterior error: 0.01066\n", + "Iteration 600,\t\tprior error: 0.3846,\t\tposterior error: 0.01081\n", + "Iteration 620,\t\tprior error: 0.387,\t\tposterior error: 0.01059\n", + "Iteration 640,\t\tprior error: 0.3961,\t\tposterior error: 0.01077\n", + "Iteration 660,\t\tprior error: 0.3645,\t\tposterior error: 0.009986\n", + "Iteration 680,\t\tprior error: 0.3893,\t\tposterior error: 0.01059\n", + "Iteration 700,\t\tprior error: 0.3774,\t\tposterior error: 0.01014\n", + "Iteration 720,\t\tprior error: 0.3646,\t\tposterior error: 0.009251\n", + "Iteration 740,\t\tprior error: 0.3582,\t\tposterior error: 0.009743\n", + "Iteration 760,\t\tprior error: 0.3405,\t\tposterior error: 0.009082\n", + "Iteration 780,\t\tprior error: 0.3619,\t\tposterior error: 0.009652\n", + "Iteration 800,\t\tprior error: 0.3739,\t\tposterior error: 0.009978\n", + "Iteration 820,\t\tprior error: 0.3567,\t\tposterior error: 0.009628\n", + "Iteration 840,\t\tprior error: 0.3567,\t\tposterior error: 0.00969\n", + "Iteration 860,\t\tprior error: 0.3496,\t\tposterior error: 0.009647\n", + "Iteration 880,\t\tprior error: 0.3556,\t\tposterior error: 0.009806\n", + "Iteration 900,\t\tprior error: 0.3522,\t\tposterior error: 0.009302\n", + "Iteration 920,\t\tprior error: 0.3604,\t\tposterior error: 0.009843\n", + "Iteration 940,\t\tprior error: 0.3428,\t\tposterior error: 0.009023\n", + "Iteration 960,\t\tprior error: 0.353,\t\tposterior error: 0.009525\n", + "Iteration 980,\t\tprior error: 0.3583,\t\tposterior error: 0.009818\n", + "Iteration 1000,\t\tprior error: 0.3562,\t\tposterior error: 0.009983\n" ] }, { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=4}", - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, "metadata": {}, @@ -3890,7 +4222,7 @@ "text": [ "Relative posterior errors:\n", "m=0:\t0.1170540997945787\n", - "CNN:\t0.022370874785168183\n" + "CNN:\t0.02099419131771638\n" ] } ], @@ -3918,15 +4250,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ Info: Saved animation to /tmp/jl_9gHWLKv03Y.gif\n" + "[ Info: Saved animation to /tmp/jl_07cNQFUBCR.gif\n" ] }, { "output_type": "execute_result", "data": { - "text/plain": "Plots.AnimatedGif(\"/tmp/jl_9gHWLKv03Y.gif\")", + "text/plain": "Plots.AnimatedGif(\"/tmp/jl_07cNQFUBCR.gif\")", "text/html": [ - "" + "" ] }, "metadata": {}, @@ -4121,11 +4453,11 @@ "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.10.5" + "version": "1.11.5" }, "kernelspec": { - "name": "julia-1.10", - "display_name": "Julia 1.10.5", + "name": "julia-1.11", + "display_name": "Julia 1.11.5", "language": "julia" } }, diff --git a/tutorials/navier_stokes_spectral.ipynb b/tutorials/navier_stokes_spectral.ipynb index 2751a38..6322d59 100644 --- a/tutorials/navier_stokes_spectral.ipynb +++ b/tutorials/navier_stokes_spectral.ipynb @@ -1363,11 +1363,11 @@ "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.10.5" + "version": "1.11.5" }, "kernelspec": { - "name": "julia-1.10", - "display_name": "Julia 1.10.5", + "name": "julia-1.11", + "display_name": "Julia 1.11.5", "language": "julia" } },