diff --git a/.github/workflows/Tests.yml b/.github/workflows/Tests.yml index f648f8b103..54806c2f2d 100644 --- a/.github/workflows/Tests.yml +++ b/.github/workflows/Tests.yml @@ -24,8 +24,6 @@ jobs: test: # Run some of the slower test files individually. The last one catches everything # not included in the others. - - name: "essential/ad" - args: "essential/ad.jl" - name: "mcmc/gibbs" args: "mcmc/gibbs.jl" - name: "mcmc/hmc" @@ -37,7 +35,7 @@ jobs: - name: "mcmc/ess" args: "mcmc/ess.jl" - name: "everything else" - args: "--skip essential/ad.jl mcmc/gibbs.jl mcmc/hmc.jl mcmc/abstractmcmc.jl mcmc/Inference.jl mcmc/ess.jl" + args: "--skip mcmc/gibbs.jl mcmc/hmc.jl mcmc/abstractmcmc.jl mcmc/Inference.jl mcmc/ess.jl" runner: # Default - version: '1' diff --git a/Manifest.toml b/Manifest.toml new file mode 100644 index 0000000000..540a7da842 --- /dev/null +++ b/Manifest.toml @@ -0,0 +1,1685 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.11.3" +manifest_format = "2.0" +project_hash = "afdf28a30966aaa4af542a30879dd92074661565" + +[[deps.ADTypes]] +git-tree-sha1 = "fb97701c117c8162e84dfcf80215caa904aef44f" +uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +version = "1.13.0" + + [deps.ADTypes.extensions] + ADTypesChainRulesCoreExt = "ChainRulesCore" + ADTypesConstructionBaseExt = "ConstructionBase" + ADTypesEnzymeCoreExt = "EnzymeCore" + + [deps.ADTypes.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" +weakdeps = ["ChainRulesCore", "Test"] + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + +[[deps.AbstractMCMC]] +deps = ["BangBang", "ConsoleProgressMonitor", "Distributed", "FillArrays", "LogDensityProblems", "Logging", "LoggingExtras", "ProgressLogging", "Random", "StatsBase", "TerminalLoggers", "Transducers"] +git-tree-sha1 = "aa469a7830413bd4c855963e3f648bd9d145c2c3" +uuid = "80f14c24-f653-4e6a-9b94-39d6b0f70001" +version = "5.6.0" + +[[deps.AbstractPPL]] +deps = ["AbstractMCMC", "Accessors", "DensityInterface", "JSON", "Random", "StatsBase"] +git-tree-sha1 = "b155685b5daa9d9d19dfe42684a53fa8cbbb83b8" +uuid = "7a57a42e-76ec-4ea3-a279-07e840d6d9cf" +version = "0.10.1" + +[[deps.AbstractTrees]] +git-tree-sha1 = "2d9c9a55f9c93e8887ad391fbae72f8ef55e1177" +uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c" +version = "0.4.5" + +[[deps.Accessors]] +deps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "MacroTools"] +git-tree-sha1 = "0ba8f4c1f06707985ffb4804fdad1bf97b233897" +uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" +version = "0.1.41" + + [deps.Accessors.extensions] + AxisKeysExt = "AxisKeys" + IntervalSetsExt = "IntervalSets" + LinearAlgebraExt = "LinearAlgebra" + StaticArraysExt = "StaticArrays" + StructArraysExt = "StructArrays" + TestExt = "Test" + UnitfulExt = "Unitful" + + [deps.Accessors.weakdeps] + AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5" + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Requires = "ae029012-a4dd-5104-9daa-d747884805df" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.Adapt]] +deps = ["LinearAlgebra", "Requires"] +git-tree-sha1 = "50c3c56a52972d78e8be9fd135bfb91c9574c140" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.1.1" +weakdeps = ["StaticArrays"] + + [deps.Adapt.extensions] + AdaptStaticArraysExt = "StaticArrays" + +[[deps.AdvancedHMC]] +deps = ["AbstractMCMC", "ArgCheck", "DocStringExtensions", "InplaceOps", "LinearAlgebra", "LogDensityProblems", "LogDensityProblemsAD", "ProgressMeter", "Random", "Requires", "Setfield", "SimpleUnPack", "Statistics", "StatsBase", "StatsFuns"] +git-tree-sha1 = "6f6a228808fe00ad05b47d74747c800d3df18acb" +uuid = "0bf59076-c3b1-5ca4-86bd-e02cd72cde3d" +version = "0.6.4" + + [deps.AdvancedHMC.extensions] + AdvancedHMCCUDAExt = "CUDA" + AdvancedHMCMCMCChainsExt = "MCMCChains" + AdvancedHMCOrdinaryDiffEqExt = "OrdinaryDiffEq" + + [deps.AdvancedHMC.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" + OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" + +[[deps.AdvancedMH]] +deps = ["AbstractMCMC", "Distributions", "DocStringExtensions", "FillArrays", "LinearAlgebra", "LogDensityProblems", "Random", "Requires"] +git-tree-sha1 = "6e3d18037861bf220ed77f1a2c5f24a21a68d4b7" +uuid = "5b7e9947-ddc0-4b3f-9b55-0d8042f74170" +version = "0.8.5" +weakdeps = ["DiffResults", "ForwardDiff", "MCMCChains", "StructArrays"] + + [deps.AdvancedMH.extensions] + AdvancedMHForwardDiffExt = ["DiffResults", "ForwardDiff"] + AdvancedMHMCMCChainsExt = "MCMCChains" + AdvancedMHStructArraysExt = "StructArrays" + +[[deps.AdvancedPS]] +deps = ["AbstractMCMC", "Distributions", "Random", "Random123", "Requires", "SSMProblems", "StatsFuns"] +git-tree-sha1 = "c017e6cded5495294ff82d5c8a176492f752b22e" +uuid = "576499cb-2369-40b2-a588-c64705576edc" +version = "0.6.1" +weakdeps = ["Libtask"] + + [deps.AdvancedPS.extensions] + AdvancedPSLibtaskExt = "Libtask" + +[[deps.AdvancedVI]] +deps = ["ADTypes", "Bijectors", "DiffResults", "Distributions", "DistributionsAD", "DocStringExtensions", "ForwardDiff", "LinearAlgebra", "ProgressMeter", "Random", "Requires", "StatsBase", "StatsFuns", "Tracker"] +git-tree-sha1 = "e45e57cea1879400952fe34b0cbc971950408af8" +uuid = "b5ca4192-6429-45e5-a2d9-87aec30a685c" +version = "0.2.11" + + [deps.AdvancedVI.extensions] + AdvancedVIEnzymeExt = ["Enzyme"] + AdvancedVIFluxExt = ["Flux"] + AdvancedVIReverseDiffExt = ["ReverseDiff"] + AdvancedVIZygoteExt = ["Zygote"] + + [deps.AdvancedVI.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.AliasTables]] +deps = ["PtrArrays", "Random"] +git-tree-sha1 = "9876e1e164b144ca45e9e3198d0b689cadfed9ff" +uuid = "66dad0bd-aa9a-41b7-9441-69ab47430ed8" +version = "1.1.3" + +[[deps.ArgCheck]] +git-tree-sha1 = "680b3b8759bd4c54052ada14e52355ab69e07876" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.4.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "017fcb757f8e921fb44ee063a7aafe5f89b86dd1" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.18.0" + + [deps.ArrayInterface.extensions] + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = "CUDSS" + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "93da6c8228993b0052e358ad592ee7c1eccaa639" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.1.0" + + [deps.Atomix.extensions] + AtomixCUDAExt = "CUDA" + AtomixMetalExt = "Metal" + AtomixOpenCLExt = "OpenCL" + AtomixoneAPIExt = "oneAPI" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.AxisAlgorithms]] +deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"] +git-tree-sha1 = "01b8ccb13d68535d73d2b0c23e39bd23155fb712" +uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950" +version = "1.1.0" + +[[deps.AxisArrays]] +deps = ["Dates", "IntervalSets", "IterTools", "RangeArrays"] +git-tree-sha1 = "16351be62963a67ac4083f748fdb3cca58bfd52f" +uuid = "39de3d68-74b9-583c-8d2d-e117c070f3a9" +version = "0.4.7" + +[[deps.BangBang]] +deps = ["Accessors", "ConstructionBase", "InitialValues", "LinearAlgebra", "Requires"] +git-tree-sha1 = "e2144b631226d9eeab2d746ca8880b7ccff504ae" +uuid = "198e06fe-97b7-11e9-32a5-e1d131e6ad66" +version = "0.4.3" + + [deps.BangBang.extensions] + BangBangChainRulesCoreExt = "ChainRulesCore" + BangBangDataFramesExt = "DataFrames" + BangBangStaticArraysExt = "StaticArrays" + BangBangStructArraysExt = "StructArrays" + BangBangTablesExt = "Tables" + BangBangTypedTablesExt = "TypedTables" + + [deps.BangBang.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.Baselet]] +git-tree-sha1 = "aebf55e6d7795e02ca500a689d326ac979aaf89e" +uuid = "9718e550-a3fa-408a-8086-8db961cd8217" +version = "0.1.1" + +[[deps.Bijectors]] +deps = ["ArgCheck", "ChainRulesCore", "ChangesOfVariables", "Distributions", "DocStringExtensions", "Functors", "InverseFunctions", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "MappedArrays", "Random", "Reexport", "Roots", "SparseArrays", "Statistics"] +git-tree-sha1 = "af42d5383609f5cd167a2f9b1b2371c2d6604d02" +uuid = "76274a88-744f-5084-9051-94815aaf08c4" +version = "0.15.4" + + [deps.Bijectors.extensions] + BijectorsDistributionsADExt = "DistributionsAD" + BijectorsEnzymeCoreExt = "EnzymeCore" + BijectorsForwardDiffExt = "ForwardDiff" + BijectorsLazyArraysExt = "LazyArrays" + BijectorsMooncakeExt = "Mooncake" + BijectorsReverseDiffExt = "ReverseDiff" + BijectorsTrackerExt = "Tracker" + BijectorsZygoteExt = "Zygote" + + [deps.Bijectors.weakdeps] + DistributionsAD = "ced4e74d-a319-5a8a-b0ac-84af2272839c" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.ChainRules]] +deps = ["Adapt", "ChainRulesCore", "Compat", "Distributed", "GPUArraysCore", "IrrationalConstants", "LinearAlgebra", "Random", "RealDot", "SparseArrays", "SparseInverseSubset", "Statistics", "StructArrays", "SuiteSparse"] +git-tree-sha1 = "4312d7869590fab4a4f789e97bd82f0a04eaaa05" +uuid = "082447d4-558c-5d27-93f4-14fc19e9eca2" +version = "1.72.2" + +[[deps.ChainRulesCore]] +deps = ["Compat", "LinearAlgebra"] +git-tree-sha1 = "1713c74e00545bfe14605d2a2be1712de8fbcb58" +uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" +version = "1.25.1" +weakdeps = ["SparseArrays"] + + [deps.ChainRulesCore.extensions] + ChainRulesCoreSparseArraysExt = "SparseArrays" + +[[deps.ChangesOfVariables]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "799b25ca3a8a24936ae7b5c52ad194685fc3e6ef" +uuid = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" +version = "0.1.9" +weakdeps = ["InverseFunctions", "Test"] + + [deps.ChangesOfVariables.extensions] + ChangesOfVariablesInverseFunctionsExt = "InverseFunctions" + ChangesOfVariablesTestExt = "Test" + +[[deps.Combinatorics]] +git-tree-sha1 = "08c8b6831dc00bfea825826be0bc8336fc369860" +uuid = "861a8166-3701-5b0c-9a16-15d98fcdc6aa" +version = "1.0.2" + +[[deps.CommonSolve]] +git-tree-sha1 = "0eee5eb66b1cf62cd6ad1b460238e60e4b09400c" +uuid = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2" +version = "0.2.4" + +[[deps.CommonSubexpressions]] +deps = ["MacroTools"] +git-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.1" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "8ae8d32e09f0dcf42a36b90d4e17f5dd2e4c4215" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.16.0" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.1.1+0" + +[[deps.CompositionsBase]] +git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad" +uuid = "a33af91c-f02d-484b-be07-31d278c5ca2b" +version = "0.1.2" +weakdeps = ["InverseFunctions"] + + [deps.CompositionsBase.extensions] + CompositionsBaseInverseFunctionsExt = "InverseFunctions" + +[[deps.ConsoleProgressMonitor]] +deps = ["Logging", "ProgressMeter"] +git-tree-sha1 = "3ab7b2136722890b9af903859afcf457fa3059e8" +uuid = "88cd18e8-d9cc-4ea6-8889-5259c0d15c8b" +version = "0.1.2" + +[[deps.ConstructionBase]] +git-tree-sha1 = "76219f1ed5771adbb096743bff43fb5fdd4c1157" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.5.8" +weakdeps = ["IntervalSets", "LinearAlgebra", "StaticArrays"] + + [deps.ConstructionBase.extensions] + ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseLinearAlgebraExt = "LinearAlgebra" + ConstructionBaseStaticArraysExt = "StaticArrays" + +[[deps.Crayons]] +git-tree-sha1 = "249fe38abf76d48563e2f4556bebd215aa317e15" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.1.1" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataStructures]] +deps = ["Compat", "InteractiveUtils", "OrderedCollections"] +git-tree-sha1 = "1d0a14036acb104d9e89698bd408f63ab58cdc82" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.18.20" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.DefineSingletons]] +git-tree-sha1 = "0fba8b706d0178b4dc7fd44a96a92382c9065c2c" +uuid = "244e2a9f-e319-4986-a169-4d1fe445cd52" +version = "0.1.2" + +[[deps.DelimitedFiles]] +deps = ["Mmap"] +git-tree-sha1 = "9e2f36d3c96a820c678f2f1f1782582fcf685bae" +uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab" +version = "1.9.1" + +[[deps.DensityInterface]] +deps = ["InverseFunctions", "Test"] +git-tree-sha1 = "80c3e8639e3353e5d2912fb3a1916b8455e2494b" +uuid = "b429d917-457f-4dbc-8f4c-0cc954292b1d" +version = "0.4.0" + +[[deps.DiffResults]] +deps = ["StaticArraysCore"] +git-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621" +uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" +version = "1.1.0" + +[[deps.DiffRules]] +deps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"] +git-tree-sha1 = "23163d55f885173722d1e4cf0f6110cdbaf7e272" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.15.1" + +[[deps.DifferentiationInterface]] +deps = ["ADTypes", "LinearAlgebra"] +git-tree-sha1 = "258fa016b2d03f19e4d0d1cd8e30c84907af1528" +uuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" +version = "0.6.42" + + [deps.DifferentiationInterface.extensions] + DifferentiationInterfaceChainRulesCoreExt = "ChainRulesCore" + DifferentiationInterfaceDiffractorExt = "Diffractor" + DifferentiationInterfaceEnzymeExt = ["EnzymeCore", "Enzyme"] + DifferentiationInterfaceFastDifferentiationExt = "FastDifferentiation" + DifferentiationInterfaceFiniteDiffExt = "FiniteDiff" + DifferentiationInterfaceFiniteDifferencesExt = "FiniteDifferences" + DifferentiationInterfaceForwardDiffExt = ["ForwardDiff", "DiffResults"] + DifferentiationInterfaceGTPSAExt = "GTPSA" + DifferentiationInterfaceMooncakeExt = "Mooncake" + DifferentiationInterfacePolyesterForwardDiffExt = "PolyesterForwardDiff" + DifferentiationInterfaceReverseDiffExt = ["ReverseDiff", "DiffResults"] + DifferentiationInterfaceSparseArraysExt = "SparseArrays" + DifferentiationInterfaceSparseMatrixColoringsExt = "SparseMatrixColorings" + DifferentiationInterfaceStaticArraysExt = "StaticArrays" + DifferentiationInterfaceSymbolicsExt = "Symbolics" + DifferentiationInterfaceTrackerExt = "Tracker" + DifferentiationInterfaceZygoteExt = ["Zygote", "ForwardDiff"] + + [deps.DifferentiationInterface.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" + Diffractor = "9f5e2b26-1114-432f-b630-d3fe2085c51c" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FastDifferentiation = "eb9bf01b-bf85-4b60-bf87-ee5de06c00be" + FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" + FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + GTPSA = "b27dd330-f138-47c5-815b-40db9dd9b6e8" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PolyesterForwardDiff = "98d1487c-24ca-40b6-b7ab-df2af84e126b" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" +version = "1.11.0" + +[[deps.Distributions]] +deps = ["AliasTables", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] +git-tree-sha1 = "03aa5d44647eaec98e1920635cdfed5d5560a8b9" +uuid = "31c24e10-a181-5473-b8eb-7969acd0382f" +version = "0.25.117" +weakdeps = ["ChainRulesCore", "DensityInterface", "Test"] + + [deps.Distributions.extensions] + DistributionsChainRulesCoreExt = "ChainRulesCore" + DistributionsDensityInterfaceExt = "DensityInterface" + DistributionsTestExt = "Test" + +[[deps.DistributionsAD]] +deps = ["Adapt", "ChainRules", "ChainRulesCore", "Compat", "Distributions", "FillArrays", "LinearAlgebra", "PDMats", "Random", "Requires", "SpecialFunctions", "StaticArrays", "StatsFuns", "ZygoteRules"] +git-tree-sha1 = "02c2e6e6a137069227439fe884d729cca5b70e56" +uuid = "ced4e74d-a319-5a8a-b0ac-84af2272839c" +version = "0.6.57" + + [deps.DistributionsAD.extensions] + DistributionsADForwardDiffExt = "ForwardDiff" + DistributionsADLazyArraysExt = "LazyArrays" + DistributionsADReverseDiffExt = "ReverseDiff" + DistributionsADTrackerExt = "Tracker" + + [deps.DistributionsAD.weakdeps] + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.DocStringExtensions]] +deps = ["LibGit2"] +git-tree-sha1 = "2fb1e02f2b635d0845df5d7c167fec4dd739b00d" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.3" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.6.0" + +[[deps.DynamicPPL]] +deps = ["ADTypes", "AbstractMCMC", "AbstractPPL", "Accessors", "BangBang", "Bijectors", "Compat", "ConstructionBase", "DifferentiationInterface", "Distributions", "DocStringExtensions", "InteractiveUtils", "KernelAbstractions", "LinearAlgebra", "LogDensityProblems", "MacroTools", "OrderedCollections", "Random", "Requires", "Test"] +git-tree-sha1 = "bd761546ac3755a4d79af57cf5d14af46d197670" +repo-rev = "release-0.35" +repo-url = "https://github.com/TuringLang/DynamicPPL.jl.git" +uuid = "366bfd00-2699-11ea-058f-f148b4cae6d8" +version = "0.35.0" + + [deps.DynamicPPL.extensions] + DynamicPPLChainRulesCoreExt = ["ChainRulesCore"] + DynamicPPLEnzymeCoreExt = ["EnzymeCore"] + DynamicPPLForwardDiffExt = ["ForwardDiff"] + DynamicPPLJETExt = ["JET"] + DynamicPPLMCMCChainsExt = ["MCMCChains"] + DynamicPPLMooncakeExt = ["Mooncake"] + + [deps.DynamicPPL.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + JET = "c3a54625-cd67-489e-a8e7-0a5a0ff4e31b" + MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + +[[deps.EllipticalSliceSampling]] +deps = ["AbstractMCMC", "ArrayInterface", "Distributions", "Random", "Statistics"] +git-tree-sha1 = "e611b7fdfbfb5b18d5e98776c30daede41b44542" +uuid = "cad2338a-1db2-11e9-3401-43bc07c9ede2" +version = "2.0.0" + +[[deps.EnumX]] +git-tree-sha1 = "bdb1942cd4c45e3c678fd11569d5cccd80976237" +uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56" +version = "1.0.4" + +[[deps.ExprTools]] +git-tree-sha1 = "27415f162e6028e81c72b82ef756bf321213b6ec" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.10" + +[[deps.Expronicon]] +deps = ["MLStyle", "Pkg", "TOML"] +git-tree-sha1 = "fc3951d4d398b5515f91d7fe5d45fc31dccb3c9b" +uuid = "6b7a57c9-7cc1-4fdf-b7f5-e857abae3636" +version = "0.8.5" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "7de7c78d681078f027389e067864a8d53bd7c3c9" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.8.1" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "4d81ed14783ec49ce9f2e168208a12ce1815aa25" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.10+3" + +[[deps.FastClosures]] +git-tree-sha1 = "acebe244d53ee1b461970f8910c235b259e772ef" +uuid = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a" +version = "0.3.2" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.FillArrays]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "6a70198746448456524cb442b8af316927ff3e1a" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "1.13.0" +weakdeps = ["PDMats", "SparseArrays", "Statistics"] + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + FillArraysStatisticsExt = "Statistics" + +[[deps.FiniteDiff]] +deps = ["ArrayInterface", "LinearAlgebra", "Setfield"] +git-tree-sha1 = "f089ab1f834470c525562030c8cfde4025d5e915" +uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" +version = "2.27.0" + + [deps.FiniteDiff.extensions] + FiniteDiffBandedMatricesExt = "BandedMatrices" + FiniteDiffBlockBandedMatricesExt = "BlockBandedMatrices" + FiniteDiffSparseArraysExt = "SparseArrays" + FiniteDiffStaticArraysExt = "StaticArrays" + + [deps.FiniteDiff.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "a2df1b776752e3f344e5116c06d75a10436ab853" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "0.10.38" +weakdeps = ["StaticArrays"] + + [deps.ForwardDiff.extensions] + ForwardDiffStaticArraysExt = "StaticArrays" + +[[deps.FunctionWrappers]] +git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" +uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" +version = "1.1.3" + +[[deps.FunctionWrappersWrappers]] +deps = ["FunctionWrappers"] +git-tree-sha1 = "b104d487b34566608f8b4e1c39fb0b10aa279ff8" +uuid = "77dc65aa-8811-40c2-897b-53d922fa7daf" +version = "0.1.3" + +[[deps.Functors]] +deps = ["Compat", "ConstructionBase", "LinearAlgebra", "Random"] +git-tree-sha1 = "60a0339f28a233601cb74468032b5c302d5067de" +uuid = "d9f16b24-f501-4c13-a1f2-28368ffc5196" +version = "0.5.2" + +[[deps.Future]] +deps = ["Random"] +uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" +version = "1.11.0" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "83cf05ab16a73219e5f6bd1bdfa9848fa24ac627" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.0" + +[[deps.HypergeometricFunctions]] +deps = ["LinearAlgebra", "OpenLibm_jll", "SpecialFunctions"] +git-tree-sha1 = "2bd56245074fab4015b9174f24ceba8293209053" +uuid = "34004b35-14d8-5ef3-9330-4cdb6864b03a" +version = "0.3.27" + +[[deps.InitialValues]] +git-tree-sha1 = "4da0f88e9a39111c2fa3add390ab15f3a44f3ca3" +uuid = "22cec73e-a1b8-11e9-2c92-598750a2cf9c" +version = "0.3.1" + +[[deps.InplaceOps]] +deps = ["LinearAlgebra", "Test"] +git-tree-sha1 = "50b41d59e7164ab6fda65e71049fee9d890731ff" +uuid = "505f98c9-085e-5b2c-8e89-488be7bf1f34" +version = "0.3.0" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "0f14a5456bdc6b9731a5682f439a672750a09e48" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.0.4+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.Interpolations]] +deps = ["Adapt", "AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"] +git-tree-sha1 = "88a101217d7cb38a7b481ccd50d21876e1d1b0e0" +uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59" +version = "0.15.1" + + [deps.Interpolations.extensions] + InterpolationsUnitfulExt = "Unitful" + + [deps.Interpolations.weakdeps] + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.IntervalSets]] +git-tree-sha1 = "dba9ddf07f77f60450fe5d2e2beb9854d9a49bd0" +uuid = "8197267c-284f-5f27-9208-e0e47529a953" +version = "0.7.10" +weakdeps = ["Random", "RecipesBase", "Statistics"] + + [deps.IntervalSets.extensions] + IntervalSetsRandomExt = "Random" + IntervalSetsRecipesBaseExt = "RecipesBase" + IntervalSetsStatisticsExt = "Statistics" + +[[deps.InverseFunctions]] +git-tree-sha1 = "a779299d77cd080bf77b97535acecd73e1c5e5cb" +uuid = "3587e190-3f89-42d0-90ee-14403ec27112" +version = "0.1.17" +weakdeps = ["Dates", "Test"] + + [deps.InverseFunctions.extensions] + InverseFunctionsDatesExt = "Dates" + InverseFunctionsTestExt = "Test" + +[[deps.InvertedIndices]] +git-tree-sha1 = "6da3c4316095de0f5ee2ebd875df8721e7e0bdbe" +uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f" +version = "1.3.1" + +[[deps.IrrationalConstants]] +git-tree-sha1 = "e2222959fbc6c19554dc15174c81bf7bf3aa691c" +uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" +version = "0.2.4" + +[[deps.IterTools]] +git-tree-sha1 = "42d5f897009e7ff2cf88db414a389e5ed1bdd023" +uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e" +version = "1.10.0" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "a007feb38b422fbdab534406aeca1b86823cb4d6" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.7.0" + +[[deps.JSON]] +deps = ["Dates", "Mmap", "Parsers", "Unicode"] +git-tree-sha1 = "31e996f0a15c7b280ba9f76636b3ff9e2ae58c9a" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "0.21.4" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "InteractiveUtils", "MacroTools", "PrecompileTools", "Requires", "StaticArrays", "UUIDs"] +git-tree-sha1 = "80d268b2f4e396edc5ea004d1e0f569231c71e9e" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.9.34" + + [deps.KernelAbstractions.extensions] + EnzymeExt = "EnzymeCore" + LinearAlgebraExt = "LinearAlgebra" + SparseArraysExt = "SparseArrays" + + [deps.KernelAbstractions.weakdeps] + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.KernelDensity]] +deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"] +git-tree-sha1 = "7d703202e65efa1369de1279c162b915e245eed1" +uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b" +version = "0.6.9" + +[[deps.LBFGSB]] +deps = ["L_BFGS_B_jll"] +git-tree-sha1 = "e2e6f53ee20605d0ea2be473480b7480bd5091b5" +uuid = "5be7bae1-8223-5378-bac3-9e7378a2f6e6" +version = "0.4.1" + +[[deps.LRUCache]] +git-tree-sha1 = "b3cc6698599b10e652832c2f23db3cab99d51b59" +uuid = "8ac3fa9e-de4c-5943-b1dc-09c6b5f20637" +version = "1.6.1" +weakdeps = ["Serialization"] + + [deps.LRUCache.extensions] + SerializationExt = ["Serialization"] + +[[deps.L_BFGS_B_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "77feda930ed3f04b2b0fbb5bea89e69d3677c6b0" +uuid = "81d17ec3-03a1-5e46-b53e-bddc35a13473" +version = "3.0.1+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.0" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LeftChildRightSiblingTrees]] +deps = ["AbstractTrees"] +git-tree-sha1 = "fb6803dafae4a5d62ea5cab204b1e657d9737e7f" +uuid = "1d6d02ad-be62-4b6b-8a6d-2f90e265016e" +version = "0.2.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "0.6.4" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.6.0+0" + +[[deps.LibGit2]] +deps = ["Base64", "LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.7.2+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "MbedTLS_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.0+1" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libtask]] +deps = ["FunctionWrappers", "LRUCache", "LinearAlgebra", "Statistics"] +git-tree-sha1 = "902ece54b0cb5c5413a8a15db0ad2aa2ec4172d2" +uuid = "6f1fad26-d15e-5dc8-ae53-837a1d7b8c9f" +version = "0.8.8" + +[[deps.LineSearches]] +deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "Printf"] +git-tree-sha1 = "e4c3be53733db1051cc15ecf573b1042b3a712a1" +uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" +version = "7.3.0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.11.0" + +[[deps.LogDensityProblems]] +deps = ["ArgCheck", "DocStringExtensions", "Random"] +git-tree-sha1 = "4e0128c1590d23a50dcdb106c7e2dbca99df85c0" +uuid = "6fdf6af0-433a-55f7-b3ed-c6c6e0b8df7c" +version = "2.1.2" + +[[deps.LogDensityProblemsAD]] +deps = ["DocStringExtensions", "LogDensityProblems"] +git-tree-sha1 = "a10e798ac8c44fe1594ad7d6e02898e16e4eafa3" +uuid = "996a588d-648d-4e1f-a8f0-a84b347e47b1" +version = "1.13.0" + + [deps.LogDensityProblemsAD.extensions] + LogDensityProblemsADADTypesExt = "ADTypes" + LogDensityProblemsADDifferentiationInterfaceExt = ["ADTypes", "DifferentiationInterface"] + LogDensityProblemsADEnzymeExt = "Enzyme" + LogDensityProblemsADFiniteDifferencesExt = "FiniteDifferences" + LogDensityProblemsADForwardDiffBenchmarkToolsExt = ["BenchmarkTools", "ForwardDiff"] + LogDensityProblemsADForwardDiffExt = "ForwardDiff" + LogDensityProblemsADReverseDiffExt = "ReverseDiff" + LogDensityProblemsADTrackerExt = "Tracker" + LogDensityProblemsADZygoteExt = "Zygote" + + [deps.LogDensityProblemsAD.weakdeps] + ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b" + BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" + DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.LogExpFunctions]] +deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] +git-tree-sha1 = "13ca9e2586b89836fd20cccf56e57e2b9ae7f38f" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "0.3.29" +weakdeps = ["ChainRulesCore", "ChangesOfVariables", "InverseFunctions"] + + [deps.LogExpFunctions.extensions] + LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" + LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables" + LogExpFunctionsInverseFunctionsExt = "InverseFunctions" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.LoggingExtras]] +deps = ["Dates", "Logging"] +git-tree-sha1 = "f02b56007b064fbfddb4c9cd60161b6dd0f40df3" +uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" +version = "1.1.0" + +[[deps.MCMCChains]] +deps = ["AbstractMCMC", "AxisArrays", "Dates", "Distributions", "IteratorInterfaceExtensions", "KernelDensity", "LinearAlgebra", "MCMCDiagnosticTools", "MLJModelInterface", "NaturalSort", "OrderedCollections", "PrettyTables", "Random", "RecipesBase", "Statistics", "StatsBase", "StatsFuns", "TableTraits", "Tables"] +git-tree-sha1 = "cd7aee22384792c726e19f2a22dc060b886edded" +uuid = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" +version = "6.0.7" + +[[deps.MCMCDiagnosticTools]] +deps = ["AbstractFFTs", "DataAPI", "DataStructures", "Distributions", "LinearAlgebra", "MLJModelInterface", "Random", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns", "Tables"] +git-tree-sha1 = "a586f05dd16a50c490ed95415b2a829b8cf5d57f" +uuid = "be115224-59cd-429b-ad48-344e309966f0" +version = "0.3.14" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "5de60bc6cb3899cd318d80d627560fae2e2d99ae" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.0.1+1" + +[[deps.MLJModelInterface]] +deps = ["Random", "ScientificTypesBase", "StatisticalTraits"] +git-tree-sha1 = "ceaff6618408d0e412619321ae43b33b40c1a733" +uuid = "e80e1ace-859a-464e-9ed9-23947d8ae3ea" +version = "1.11.0" + +[[deps.MLStyle]] +git-tree-sha1 = "bc38dff0548128765760c79eb7388a4b37fae2c8" +uuid = "d8e11817-5142-5d16-987a-aa16d5891078" +version = "0.4.17" + +[[deps.MacroTools]] +git-tree-sha1 = "72aebe0b5051e5143a079a4685a46da330a40472" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.15" + +[[deps.MappedArrays]] +git-tree-sha1 = "2dab0221fe2b0f2cb6754eaa743cc266339f527e" +uuid = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900" +version = "0.4.2" + +[[deps.Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MbedTLS_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.28.6+0" + +[[deps.MicroCollections]] +deps = ["Accessors", "BangBang", "InitialValues"] +git-tree-sha1 = "44d32db644e84c75dab479f1bc15ee76a1a3618f" +uuid = "128add7d-3638-4c79-886c-908ea0c25c34" +version = "0.2.0" + +[[deps.Missings]] +deps = ["DataAPI"] +git-tree-sha1 = "ec4f7fbeab05d7747bdf98eb74d130a2a2ed298d" +uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" +version = "1.2.0" + +[[deps.Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" +version = "1.11.0" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2023.12.12" + +[[deps.NLSolversBase]] +deps = ["DiffResults", "Distributed", "FiniteDiff", "ForwardDiff"] +git-tree-sha1 = "a0b464d183da839699f4c79e7606d9d186ec172c" +uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" +version = "7.8.3" + +[[deps.NNlib]] +deps = ["Adapt", "Atomix", "ChainRulesCore", "GPUArraysCore", "KernelAbstractions", "LinearAlgebra", "Random", "Statistics"] +git-tree-sha1 = "bdc9d30f151590aca0af22690f5ab7dc18a551cb" +uuid = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" +version = "0.9.27" + + [deps.NNlib.extensions] + NNlibAMDGPUExt = "AMDGPU" + NNlibCUDACUDNNExt = ["CUDA", "cuDNN"] + NNlibCUDAExt = "CUDA" + NNlibEnzymeCoreExt = "EnzymeCore" + NNlibFFTWExt = "FFTW" + NNlibForwardDiffExt = "ForwardDiff" + + [deps.NNlib.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd" + +[[deps.NaNMath]] +deps = ["OpenLibm_jll"] +git-tree-sha1 = "cc0a5deefdb12ab3a096f00a6d42133af4560d71" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "1.1.2" + +[[deps.NamedArrays]] +deps = ["Combinatorics", "DataStructures", "DelimitedFiles", "InvertedIndices", "LinearAlgebra", "Random", "Requires", "SparseArrays", "Statistics"] +git-tree-sha1 = "58e317b3b956b8aaddfd33ff4c3e33199cd8efce" +uuid = "86f7a689-2022-50b4-a561-43c23ac3c673" +version = "0.10.3" + +[[deps.NaturalSort]] +git-tree-sha1 = "eda490d06b9f7c00752ee81cfa451efe55521e21" +uuid = "c020b1a1-e9b0-503a-9c33-f039bfc54a85" +version = "1.0.0" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.2.0" + +[[deps.OffsetArrays]] +git-tree-sha1 = "5e1897147d1ff8d98883cda2be2187dcf57d8f0c" +uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" +version = "1.15.0" +weakdeps = ["Adapt"] + + [deps.OffsetArrays.extensions] + OffsetArraysAdaptExt = "Adapt" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.27+1" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.1+2" + +[[deps.OpenSpecFun_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1346c9208249809840c91b26703912dff463d335" +uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" +version = "0.5.6+0" + +[[deps.Optim]] +deps = ["Compat", "FillArrays", "ForwardDiff", "LineSearches", "LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "PositiveFactorizations", "Printf", "SparseArrays", "StatsBase"] +git-tree-sha1 = "c1f51f704f689f87f28b33836fd460ecf9b34583" +uuid = "429524aa-4258-5aef-a3af-852621145aeb" +version = "1.11.0" + + [deps.Optim.extensions] + OptimMOIExt = "MathOptInterface" + + [deps.Optim.weakdeps] + MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" + +[[deps.Optimisers]] +deps = ["ChainRulesCore", "Functors", "LinearAlgebra", "Random", "Statistics"] +git-tree-sha1 = "53ff746a3a2b232a37dbcd262ac8bbb2b18202b8" +uuid = "3bd65402-5787-11e9-1adc-39752487f4e2" +version = "0.4.4" + + [deps.Optimisers.extensions] + OptimisersAdaptExt = ["Adapt"] + OptimisersEnzymeCoreExt = "EnzymeCore" + + [deps.Optimisers.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + +[[deps.Optimization]] +deps = ["ADTypes", "ArrayInterface", "ConsoleProgressMonitor", "DocStringExtensions", "LBFGSB", "LinearAlgebra", "Logging", "LoggingExtras", "OptimizationBase", "Printf", "ProgressLogging", "Reexport", "SciMLBase", "SparseArrays", "TerminalLoggers"] +git-tree-sha1 = "df361b5dc1f91ffb601700a2bc4bfdcd4cc584ef" +uuid = "7f7a1694-90dd-40f0-9382-eb1efda571ba" +version = "4.1.1" + +[[deps.OptimizationBase]] +deps = ["ADTypes", "ArrayInterface", "DifferentiationInterface", "DocStringExtensions", "FastClosures", "LinearAlgebra", "PDMats", "Reexport", "Requires", "SciMLBase", "SparseArrays", "SparseConnectivityTracer", "SparseMatrixColorings"] +git-tree-sha1 = "9e8569bc1c511c425fdc63f7ee41f2da057f8662" +uuid = "bca83a33-5cc9-4baa-983d-23429ab6bcbb" +version = "2.4.0" + + [deps.OptimizationBase.extensions] + OptimizationEnzymeExt = "Enzyme" + OptimizationFiniteDiffExt = "FiniteDiff" + OptimizationForwardDiffExt = "ForwardDiff" + OptimizationMLDataDevicesExt = "MLDataDevices" + OptimizationMLUtilsExt = "MLUtils" + OptimizationMTKExt = "ModelingToolkit" + OptimizationReverseDiffExt = "ReverseDiff" + OptimizationSymbolicAnalysisExt = "SymbolicAnalysis" + OptimizationZygoteExt = "Zygote" + + [deps.OptimizationBase.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + MLDataDevices = "7e8f7934-dd98-4c1a-8fe8-92b47a384d40" + MLUtils = "f1d291b0-491e-4a28-83b9-f70985020b54" + ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SymbolicAnalysis = "4297ee4d-0239-47d8-ba5d-195ecdf594fe" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.OptimizationOptimJL]] +deps = ["Optim", "Optimization", "PrecompileTools", "Reexport", "SparseArrays"] +git-tree-sha1 = "980ec7190741db164a2923dc42d6f1e7ce2cc434" +uuid = "36348300-93cb-4f02-beb5-3c3902f8871e" +version = "0.4.1" + +[[deps.OrderedCollections]] +git-tree-sha1 = "cc4054e898b852042d7b503313f7ad03de99c3dd" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.8.0" + +[[deps.PDMats]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "966b85253e959ea89c53a9abebbf2e964fbf593b" +uuid = "90014a1f-27ba-587c-ab20-58faa44d9150" +version = "0.11.32" + +[[deps.Parameters]] +deps = ["OrderedCollections", "UnPack"] +git-tree-sha1 = "34c0e9ad262e5f7fc75b10a9952ca7692cfc5fbe" +uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" +version = "0.12.3" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools", "UUIDs"] +git-tree-sha1 = "8489905bcdbcfac64d1daa51ca07c0d8f0283821" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "2.8.1" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.11.0" + + [deps.Pkg.extensions] + REPLExt = "REPL" + + [deps.Pkg.weakdeps] + REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" + +[[deps.PositiveFactorizations]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "17275485f373e6673f7e7f97051f703ed5b15b20" +uuid = "85a6dd25-e78a-55b7-8502-1745935b8125" +version = "0.2.4" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "5aa36f7049a63a1528fe8f7c3f2113413ffd4e1f" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.2.1" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "9306f6085165d270f7e3db02af26a400d580f5c6" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.4.3" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "Reexport", "StringManipulation", "Tables"] +git-tree-sha1 = "1101cd475833706e4d0e7b122218257178f48f34" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "2.4.0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.ProgressLogging]] +deps = ["Logging", "SHA", "UUIDs"] +git-tree-sha1 = "80d919dee55b9c50e8d9e2da5eeafff3fe58b539" +uuid = "33c8b6b6-d38a-422a-b730-caa89a2f386c" +version = "0.1.4" + +[[deps.ProgressMeter]] +deps = ["Distributed", "Printf"] +git-tree-sha1 = "8f6bc219586aef8baf0ff9a5fe16ee9c70cb65e4" +uuid = "92933f4c-e287-5a05-a399-4b506db050ca" +version = "1.10.2" + +[[deps.PtrArrays]] +git-tree-sha1 = "1d36ef11a9aaf1e8b74dacc6a731dd1de8fd493d" +uuid = "43287f4e-b6f4-7ad1-bb20-aadabca52c3d" +version = "1.3.0" + +[[deps.QuadGK]] +deps = ["DataStructures", "LinearAlgebra"] +git-tree-sha1 = "9da16da70037ba9d701192e27befedefb91ec284" +uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" +version = "2.11.2" + + [deps.QuadGK.extensions] + QuadGKEnzymeExt = "Enzyme" + + [deps.QuadGK.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "4743b43e5a9c4a2ede372de7061eed81795b12e7" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.0" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.RangeArrays]] +git-tree-sha1 = "b9039e93773ddcfc828f12aadf7115b4b4d225f5" +uuid = "b3c3ace0-ae52-54e7-9d0b-2c1406fd6b9d" +version = "0.3.2" + +[[deps.Ratios]] +deps = ["Requires"] +git-tree-sha1 = "1342a47bf3260ee108163042310d26f2be5ec90b" +uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439" +version = "0.4.5" + + [deps.Ratios.extensions] + RatiosFixedPointNumbersExt = "FixedPointNumbers" + + [deps.Ratios.weakdeps] + FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" + +[[deps.RealDot]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "9f0a1b71baaf7650f4fa8a1d168c7fb6ee41f0c9" +uuid = "c1ae055f-0cd5-4b69-90a6-9a35b1a98df9" +version = "0.1.0" + +[[deps.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.3.4" + +[[deps.RecursiveArrayTools]] +deps = ["Adapt", "ArrayInterface", "DocStringExtensions", "GPUArraysCore", "IteratorInterfaceExtensions", "LinearAlgebra", "RecipesBase", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables"] +git-tree-sha1 = "fe9d37a17ab4d41a98951332ee8067f8dca8c4c2" +uuid = "731186ca-8d62-57ce-b412-fbd966d074cd" +version = "3.29.0" + + [deps.RecursiveArrayTools.extensions] + RecursiveArrayToolsFastBroadcastExt = "FastBroadcast" + RecursiveArrayToolsForwardDiffExt = "ForwardDiff" + RecursiveArrayToolsMeasurementsExt = "Measurements" + RecursiveArrayToolsMonteCarloMeasurementsExt = "MonteCarloMeasurements" + RecursiveArrayToolsReverseDiffExt = ["ReverseDiff", "Zygote"] + RecursiveArrayToolsSparseArraysExt = ["SparseArrays"] + RecursiveArrayToolsStructArraysExt = "StructArrays" + RecursiveArrayToolsTrackerExt = "Tracker" + RecursiveArrayToolsZygoteExt = "Zygote" + + [deps.RecursiveArrayTools.weakdeps] + FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "838a3a4188e2ded87a4f9f184b4b0d78a1e91cb7" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.3.0" + +[[deps.Rmath]] +deps = ["Random", "Rmath_jll"] +git-tree-sha1 = "852bd0f55565a9e973fcfee83a84413270224dc4" +uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa" +version = "0.8.0" + +[[deps.Rmath_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "58cdd8fb2201a6267e1db87ff148dd6c1dbd8ad8" +uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f" +version = "0.5.1+0" + +[[deps.Roots]] +deps = ["Accessors", "CommonSolve", "Printf"] +git-tree-sha1 = "e52cf0872526c7a0b3e1af9c58a69b90e19b022e" +uuid = "f2b01f46-fcfa-551c-844a-d8ac1e96c665" +version = "2.2.5" + + [deps.Roots.extensions] + RootsChainRulesCoreExt = "ChainRulesCore" + RootsForwardDiffExt = "ForwardDiff" + RootsIntervalRootFindingExt = "IntervalRootFinding" + RootsSymPyExt = "SymPy" + RootsSymPyPythonCallExt = "SymPyPythonCall" + + [deps.Roots.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + IntervalRootFinding = "d2bf35a9-74e0-55ec-b149-d360ff49b807" + SymPy = "24249f21-da20-56a4-8eb1-6a02cf4ae2e6" + SymPyPythonCall = "bc8888f7-b21e-4b7c-a06a-5d9c9496438c" + +[[deps.RuntimeGeneratedFunctions]] +deps = ["ExprTools", "SHA", "Serialization"] +git-tree-sha1 = "04c968137612c4a5629fa531334bb81ad5680f00" +uuid = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47" +version = "0.5.13" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.SSMProblems]] +deps = ["AbstractMCMC"] +git-tree-sha1 = "f640e4e8343c9d5f470e2f6ca6ce79f708ab6376" +uuid = "26aad666-b158-4e64-9d35-0e672562fa48" +version = "0.1.1" + +[[deps.SciMLBase]] +deps = ["ADTypes", "Accessors", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "Expronicon", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "PrecompileTools", "Preferences", "Printf", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLOperators", "SciMLStructures", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface"] +git-tree-sha1 = "ffed2507209da5b42c6881944ef41a340ab5449b" +uuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462" +version = "2.74.1" + + [deps.SciMLBase.extensions] + SciMLBaseChainRulesCoreExt = "ChainRulesCore" + SciMLBaseMakieExt = "Makie" + SciMLBasePartialFunctionsExt = "PartialFunctions" + SciMLBasePyCallExt = "PyCall" + SciMLBasePythonCallExt = "PythonCall" + SciMLBaseRCallExt = "RCall" + SciMLBaseZygoteExt = "Zygote" + + [deps.SciMLBase.weakdeps] + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + PartialFunctions = "570af359-4316-4cb7-8c74-252c00c2016b" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" + RCall = "6f49c342-dc21-5d91-9882-a32aef131414" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.SciMLOperators]] +deps = ["Accessors", "ArrayInterface", "DocStringExtensions", "LinearAlgebra", "MacroTools"] +git-tree-sha1 = "6149620767866d4b0f0f7028639b6e661b6a1e44" +uuid = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" +version = "0.3.12" +weakdeps = ["SparseArrays", "StaticArraysCore"] + + [deps.SciMLOperators.extensions] + SciMLOperatorsSparseArraysExt = "SparseArrays" + SciMLOperatorsStaticArraysCoreExt = "StaticArraysCore" + +[[deps.SciMLStructures]] +deps = ["ArrayInterface"] +git-tree-sha1 = "0444a37a25fab98adbd90baa806ee492a3af133a" +uuid = "53ae85a6-f571-4167-b2af-e1d143709226" +version = "1.6.1" + +[[deps.ScientificTypesBase]] +git-tree-sha1 = "a8e18eb383b5ecf1b5e6fc237eb39255044fd92b" +uuid = "30f210dd-8aff-4c5f-94ba-8e64358c1161" +version = "3.0.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Setfield]] +deps = ["ConstructionBase", "Future", "MacroTools", "StaticArraysCore"] +git-tree-sha1 = "e2cc6d8c88613c05e1defb55170bf5ff211fbeac" +uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" +version = "1.1.1" + +[[deps.SharedArrays]] +deps = ["Distributed", "Mmap", "Random", "Serialization"] +uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" +version = "1.11.0" + +[[deps.SimpleUnPack]] +git-tree-sha1 = "58e6353e72cde29b90a69527e56df1b5c3d8c437" +uuid = "ce78b400-467f-4804-87d8-8f486da07d0a" +version = "1.1.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SortingAlgorithms]] +deps = ["DataStructures"] +git-tree-sha1 = "66e0a8e672a0bdfca2c3f5937efb8538b9ddc085" +uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" +version = "1.2.1" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.11.0" + +[[deps.SparseConnectivityTracer]] +deps = ["ADTypes", "DocStringExtensions", "FillArrays", "LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "6651f4663027f3b30a31429d257185f56a571184" +uuid = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" +version = "0.6.13" + + [deps.SparseConnectivityTracer.extensions] + SparseConnectivityTracerDataInterpolationsExt = "DataInterpolations" + SparseConnectivityTracerLogExpFunctionsExt = "LogExpFunctions" + SparseConnectivityTracerNNlibExt = "NNlib" + SparseConnectivityTracerNaNMathExt = "NaNMath" + SparseConnectivityTracerSpecialFunctionsExt = "SpecialFunctions" + + [deps.SparseConnectivityTracer.weakdeps] + DataInterpolations = "82cc6244-b520-54b8-b5a6-8a565e85f1d0" + LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688" + NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" + NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SparseInverseSubset]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "52962839426b75b3021296f7df242e40ecfc0852" +uuid = "dc90abb0-5640-4711-901d-7e5b23a2fada" +version = "0.1.2" + +[[deps.SparseMatrixColorings]] +deps = ["ADTypes", "DataStructures", "DocStringExtensions", "LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "97092c0a40d6033b7da27ea15bcf75fd5b446254" +uuid = "0a514795-09f3-496d-8182-132a7b665d35" +version = "0.4.13" + + [deps.SparseMatrixColorings.extensions] + SparseMatrixColoringsColorsExt = "Colors" + + [deps.SparseMatrixColorings.weakdeps] + Colors = "5ae59095-9a9b-59fe-a467-6f913c188581" + +[[deps.SpecialFunctions]] +deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] +git-tree-sha1 = "64cca0c26b4f31ba18f13f6c12af7c85f478cfde" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "2.5.0" +weakdeps = ["ChainRulesCore"] + + [deps.SpecialFunctions.extensions] + SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" + +[[deps.SplittablesBase]] +deps = ["Setfield", "Test"] +git-tree-sha1 = "e08a62abc517eb79667d0a29dc08a3b589516bb5" +uuid = "171d559e-b47b-412a-8079-5efa626c420e" +version = "0.1.15" + +[[deps.StaticArrays]] +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "e3be13f448a43610f978d29b7adf78c76022467a" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "1.9.12" +weakdeps = ["ChainRulesCore", "Statistics"] + + [deps.StaticArrays.extensions] + StaticArraysChainRulesCoreExt = "ChainRulesCore" + StaticArraysStatisticsExt = "Statistics" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "192954ef1208c7019899fbf8049e717f92959682" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.3" + +[[deps.StatisticalTraits]] +deps = ["ScientificTypesBase"] +git-tree-sha1 = "542d979f6e756f13f862aa00b224f04f9e445f11" +uuid = "64bff920-2084-43da-a3e6-9bb72801c0c9" +version = "3.4.0" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "ae3bb1eb3bba077cd276bc5cfc337cc65c3075c0" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.1" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StatsAPI]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "1ff449ad350c9c4cbc756624d6f8a8c3ef56d3ed" +uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" +version = "1.7.0" + +[[deps.StatsBase]] +deps = ["AliasTables", "DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] +git-tree-sha1 = "29321314c920c26684834965ec2ce0dacc9cf8e5" +uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +version = "0.34.4" + +[[deps.StatsFuns]] +deps = ["HypergeometricFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"] +git-tree-sha1 = "b423576adc27097764a90e163157bcfc9acf0f46" +uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c" +version = "1.3.2" +weakdeps = ["ChainRulesCore", "InverseFunctions"] + + [deps.StatsFuns.extensions] + StatsFunsChainRulesCoreExt = "ChainRulesCore" + StatsFunsInverseFunctionsExt = "InverseFunctions" + +[[deps.StringManipulation]] +deps = ["PrecompileTools"] +git-tree-sha1 = "725421ae8e530ec29bcbdddbe91ff8053421d023" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.4.1" + +[[deps.StructArrays]] +deps = ["ConstructionBase", "DataAPI", "Tables"] +git-tree-sha1 = "9537ef82c42cdd8c5d443cbc359110cbb36bae10" +uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" +version = "0.6.21" +weakdeps = ["Adapt", "GPUArraysCore", "KernelAbstractions", "LinearAlgebra", "SparseArrays", "StaticArrays"] + + [deps.StructArrays.extensions] + StructArraysAdaptExt = "Adapt" + StructArraysGPUArraysCoreExt = ["GPUArraysCore", "KernelAbstractions"] + StructArraysLinearAlgebraExt = "LinearAlgebra" + StructArraysSparseArraysExt = "SparseArrays" + StructArraysStaticArraysExt = "StaticArrays" + +[[deps.SuiteSparse]] +deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"] +uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.7.0+0" + +[[deps.SymbolicIndexingInterface]] +deps = ["Accessors", "ArrayInterface", "RuntimeGeneratedFunctions", "StaticArraysCore"] +git-tree-sha1 = "fd2d4f0499f6bb4a0d9f5030f5c7d61eed385e03" +uuid = "2efcf032-c050-4f8e-a9bb-153293bab1f5" +version = "0.3.37" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "598cd7c1f68d1e205689b1c2fe65a9f85846f297" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.12.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.TerminalLoggers]] +deps = ["LeftChildRightSiblingTrees", "Logging", "Markdown", "Printf", "ProgressLogging", "UUIDs"] +git-tree-sha1 = "f133fab380933d042f6796eda4e130272ba520ca" +uuid = "5d786b92-1e48-4d6f-9151-6b4477ca9bed" +version = "0.1.7" + +[[deps.Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" +version = "1.11.0" + +[[deps.Tracker]] +deps = ["Adapt", "ChainRulesCore", "DiffRules", "ForwardDiff", "Functors", "LinearAlgebra", "LogExpFunctions", "MacroTools", "NNlib", "NaNMath", "Optimisers", "Printf", "Random", "Requires", "SpecialFunctions", "Statistics"] +git-tree-sha1 = "c266e49953dadd0923caa17b3ea464ab6b97b3f2" +uuid = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" +version = "0.2.37" +weakdeps = ["PDMats"] + + [deps.Tracker.extensions] + TrackerPDMatsExt = "PDMats" + +[[deps.Transducers]] +deps = ["Accessors", "ArgCheck", "BangBang", "Baselet", "CompositionsBase", "ConstructionBase", "DefineSingletons", "Distributed", "InitialValues", "Logging", "Markdown", "MicroCollections", "Requires", "SplittablesBase", "Tables"] +git-tree-sha1 = "7deeab4ff96b85c5f72c824cae53a1398da3d1cb" +uuid = "28d57a85-8fef-5791-bfe6-a80928e7c999" +version = "0.4.84" + + [deps.Transducers.extensions] + TransducersAdaptExt = "Adapt" + TransducersBlockArraysExt = "BlockArrays" + TransducersDataFramesExt = "DataFrames" + TransducersLazyArraysExt = "LazyArrays" + TransducersOnlineStatsBaseExt = "OnlineStatsBase" + TransducersReferenceablesExt = "Referenceables" + + [deps.Transducers.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02" + OnlineStatsBase = "925886fa-5bf2-5e8e-b522-a9147a512338" + Referenceables = "42d2dcc6-99eb-4e98-b66c-637b7d73030e" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.UnPack]] +git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.2" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +git-tree-sha1 = "b13c4edda90890e5b04ba24e20a310fbe6f249ff" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.3.0" + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsLLVM = ["LLVM"] + + [deps.UnsafeAtomics.weakdeps] + LLVM = "929cbde3-209d-540e-8aea-75f648917ca0" + +[[deps.WoodburyMatrices]] +deps = ["LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "c1a7aa6219628fcd757dede0ca95e245c5cd9511" +uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6" +version = "1.0.0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.2.13+1" + +[[deps.ZygoteRules]] +deps = ["ChainRulesCore", "MacroTools"] +git-tree-sha1 = "434b3de333c75fc446aa0d19fc394edafd07ab08" +uuid = "700de1a5-db45-46bc-99cf-38207098b444" +version = "0.2.7" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.11.0+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.59.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d5a767a3bb77135a99e433afe0eb14cd7f6914c3" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2022.0.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.4.0+2" diff --git a/Project.toml b/Project.toml index 396838cef0..d72f323373 100644 --- a/Project.toml +++ b/Project.toml @@ -23,7 +23,6 @@ ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" Libtask = "6f1fad26-d15e-5dc8-ae53-837a1d7b8c9f" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" LogDensityProblems = "6fdf6af0-433a-55f7-b3ed-c6c6e0b8df7c" -LogDensityProblemsAD = "996a588d-648d-4e1f-a8f0-a84b347e47b1" MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" NamedArrays = "86f7a689-2022-50b4-a561-43c23ac3c673" Optimization = "7f7a1694-90dd-40f0-9382-eb1efda571ba" @@ -63,13 +62,12 @@ Distributions = "0.23.3, 0.24, 0.25" DistributionsAD = "0.6" DocStringExtensions = "0.8, 0.9" DynamicHMC = "3.4" -DynamicPPL = "0.34.1" +DynamicPPL = "0.35" EllipticalSliceSampling = "0.5, 1, 2" ForwardDiff = "0.10.3" Libtask = "0.8.8" LinearAlgebra = "1" LogDensityProblems = "2" -LogDensityProblemsAD = "1.7.0" MCMCChains = "5, 6" NamedArrays = "0.9, 0.10" Optim = "1" diff --git a/ext/TuringDynamicHMCExt.jl b/ext/TuringDynamicHMCExt.jl index c82f237c0c..5718e3855a 100644 --- a/ext/TuringDynamicHMCExt.jl +++ b/ext/TuringDynamicHMCExt.jl @@ -3,17 +3,10 @@ module TuringDynamicHMCExt ### DynamicHMC backend - https://github.com/tpapp/DynamicHMC.jl ### -if isdefined(Base, :get_extension) - using DynamicHMC: DynamicHMC - using Turing - using Turing: AbstractMCMC, Random, LogDensityProblems, DynamicPPL - using Turing.Inference: ADTypes, LogDensityProblemsAD, TYPEDFIELDS -else - import ..DynamicHMC - using ..Turing - using ..Turing: AbstractMCMC, Random, LogDensityProblems, DynamicPPL - using ..Turing.Inference: ADTypes, LogDensityProblemsAD, TYPEDFIELDS -end +using DynamicHMC: DynamicHMC +using Turing +using Turing: AbstractMCMC, Random, LogDensityProblems, DynamicPPL +using Turing.Inference: ADTypes, TYPEDFIELDS """ DynamicNUTS @@ -25,22 +18,15 @@ To use it, make sure you have DynamicHMC package (version >= 2) loaded: using DynamicHMC ``` """ -struct DynamicNUTS{AD,space,T<:DynamicHMC.NUTS} <: Turing.Inference.Hamiltonian +struct DynamicNUTS{AD,T<:DynamicHMC.NUTS} <: Turing.Inference.Hamiltonian sampler::T adtype::AD end -function DynamicNUTS( - spl::DynamicHMC.NUTS=DynamicHMC.NUTS(), - space::Tuple=(); - adtype::ADTypes.AbstractADType=Turing.DEFAULT_ADTYPE, -) - return DynamicNUTS{typeof(adtype),space,typeof(spl)}(spl, adtype) -end +DynamicNUTS() = DynamicNUTS(DynamicHMC.NUTS()) +DynamicNUTS(spl) = DynamicNUTS(spl, Turing.DEFAULT_ADTYPE) Turing.externalsampler(spl::DynamicHMC.NUTS) = DynamicNUTS(spl) -DynamicPPL.getspace(::DynamicNUTS{<:Any,space}) where {space} = space - """ DynamicNUTSState @@ -70,25 +56,28 @@ function DynamicPPL.initialstep( kwargs..., ) # Ensure that initial sample is in unconstrained space. - if !DynamicPPL.islinked(vi, spl) - vi = DynamicPPL.link!!(vi, spl, model) + if !DynamicPPL.islinked(vi) + vi = DynamicPPL.link!!(vi, model) vi = last(DynamicPPL.evaluate!!(model, vi, DynamicPPL.SamplingContext(rng, spl))) end # Define log-density function. - ℓ = LogDensityProblemsAD.ADgradient( - Turing.LogDensityFunction(vi, model, spl, DynamicPPL.DefaultContext()) + ℓ = DynamicPPL.LogDensityFunction( + model, + vi, + DynamicPPL.SamplingContext(spl, DynamicPPL.DefaultContext()); + adtype=spl.alg.adtype, ) # Perform initial step. results = DynamicHMC.mcmc_keep_warmup( - rng, ℓ, 0; initialization=(q=vi[spl],), reporter=DynamicHMC.NoProgressReport() + rng, ℓ, 0; initialization=(q=vi[:],), reporter=DynamicHMC.NoProgressReport() ) steps = DynamicHMC.mcmc_steps(results.sampling_logdensity, results.final_warmup_state) Q, _ = DynamicHMC.mcmc_next_step(steps, results.final_warmup_state.Q) # Update the variables. - vi = DynamicPPL.setindex!!(vi, Q.q, spl) + vi = DynamicPPL.unflatten(vi, Q.q) vi = DynamicPPL.setlogp!!(vi, Q.ℓq) # Create first sample and state. @@ -112,7 +101,7 @@ function AbstractMCMC.step( Q, _ = DynamicHMC.mcmc_next_step(steps, state.cache) # Update the variables. - vi = DynamicPPL.setindex!!(vi, Q.q, spl) + vi = DynamicPPL.unflatten(vi, Q.q) vi = DynamicPPL.setlogp!!(vi, Q.ℓq) # Create next sample and state. diff --git a/ext/TuringOptimExt.jl b/ext/TuringOptimExt.jl index 3d31af6f2a..d6c253e2a2 100644 --- a/ext/TuringOptimExt.jl +++ b/ext/TuringOptimExt.jl @@ -1,14 +1,8 @@ module TuringOptimExt -if isdefined(Base, :get_extension) - using Turing: Turing - import Turing: DynamicPPL, NamedArrays, Accessors, Optimisation - using Optim: Optim -else - import ..Turing - import ..Turing: DynamicPPL, NamedArrays, Accessors, Optimisation - import ..Optim -end +using Turing: Turing +import Turing: DynamicPPL, NamedArrays, Accessors, Optimisation +using Optim: Optim #################### # Optim.jl methods # @@ -42,7 +36,7 @@ function Optim.optimize( ) ctx = Optimisation.OptimizationContext(DynamicPPL.LikelihoodContext()) f = Optimisation.OptimLogDensity(model, ctx) - init_vals = DynamicPPL.getparams(f) + init_vals = DynamicPPL.getparams(f.ldf) optimizer = Optim.LBFGS() return _mle_optimize(model, init_vals, optimizer, options; kwargs...) end @@ -65,7 +59,7 @@ function Optim.optimize( ) ctx = Optimisation.OptimizationContext(DynamicPPL.LikelihoodContext()) f = Optimisation.OptimLogDensity(model, ctx) - init_vals = DynamicPPL.getparams(f) + init_vals = DynamicPPL.getparams(f.ldf) return _mle_optimize(model, init_vals, optimizer, options; kwargs...) end function Optim.optimize( @@ -81,7 +75,7 @@ end function _mle_optimize(model::DynamicPPL.Model, args...; kwargs...) ctx = Optimisation.OptimizationContext(DynamicPPL.LikelihoodContext()) - return _optimize(model, Optimisation.OptimLogDensity(model, ctx), args...; kwargs...) + return _optimize(Optimisation.OptimLogDensity(model, ctx), args...; kwargs...) end """ @@ -112,7 +106,7 @@ function Optim.optimize( ) ctx = Optimisation.OptimizationContext(DynamicPPL.DefaultContext()) f = Optimisation.OptimLogDensity(model, ctx) - init_vals = DynamicPPL.getparams(f) + init_vals = DynamicPPL.getparams(f.ldf) optimizer = Optim.LBFGS() return _map_optimize(model, init_vals, optimizer, options; kwargs...) end @@ -135,7 +129,7 @@ function Optim.optimize( ) ctx = Optimisation.OptimizationContext(DynamicPPL.DefaultContext()) f = Optimisation.OptimLogDensity(model, ctx) - init_vals = DynamicPPL.getparams(f) + init_vals = DynamicPPL.getparams(f.ldf) return _map_optimize(model, init_vals, optimizer, options; kwargs...) end function Optim.optimize( @@ -151,18 +145,16 @@ end function _map_optimize(model::DynamicPPL.Model, args...; kwargs...) ctx = Optimisation.OptimizationContext(DynamicPPL.DefaultContext()) - return _optimize(model, Optimisation.OptimLogDensity(model, ctx), args...; kwargs...) + return _optimize(Optimisation.OptimLogDensity(model, ctx), args...; kwargs...) end - """ - _optimize(model::Model, f::OptimLogDensity, optimizer=Optim.LBFGS(), args...; kwargs...) + _optimize(f::OptimLogDensity, optimizer=Optim.LBFGS(), args...; kwargs...) Estimate a mode, i.e., compute a MLE or MAP estimate. """ function _optimize( - model::DynamicPPL.Model, f::Optimisation.OptimLogDensity, - init_vals::AbstractArray=DynamicPPL.getparams(f), + init_vals::AbstractArray=DynamicPPL.getparams(f.ldf), optimizer::Optim.AbstractOptimizer=Optim.LBFGS(), options::Optim.Options=Optim.Options(), args...; @@ -170,9 +162,12 @@ function _optimize( ) # Convert the initial values, since it is assumed that users provide them # in the constrained space. - f = Accessors.@set f.varinfo = DynamicPPL.unflatten(f.varinfo, init_vals) - f = Accessors.@set f.varinfo = DynamicPPL.link(f.varinfo, model) - init_vals = DynamicPPL.getparams(f) + # TODO(penelopeysm): As with in src/optimisation/Optimisation.jl, unclear + # whether initialisation is really necessary at all + vi = DynamicPPL.unflatten(f.ldf.varinfo, init_vals) + vi = DynamicPPL.link(vi, f.ldf.model) + f = Optimisation.OptimLogDensity(f.ldf.model, vi, f.ldf.context; adtype=f.ldf.adtype) + init_vals = DynamicPPL.getparams(f.ldf) # Optimize! M = Optim.optimize(Optim.only_fg!(f), init_vals, optimizer, options, args...; kwargs...) @@ -186,12 +181,16 @@ function _optimize( end # Get the optimum in unconstrained space. `getparams` does the invlinking. - f = Accessors.@set f.varinfo = DynamicPPL.unflatten(f.varinfo, M.minimizer) - vns_vals_iter = Turing.Inference.getparams(model, f.varinfo) + vi = f.ldf.varinfo + vi_optimum = DynamicPPL.unflatten(vi, M.minimizer) + logdensity_optimum = Optimisation.OptimLogDensity( + f.ldf.model, vi_optimum, f.ldf.context + ) + vns_vals_iter = Turing.Inference.getparams(f.ldf.model, vi_optimum) varnames = map(Symbol ∘ first, vns_vals_iter) vals = map(last, vns_vals_iter) vmat = NamedArrays.NamedArray(vals, varnames) - return Optimisation.ModeResult(vmat, M, -M.minimum, f) + return Optimisation.ModeResult(vmat, M, -M.minimum, logdensity_optimum) end end # module diff --git a/src/Turing.jl b/src/Turing.jl index 6318e2bd52..abba580a27 100644 --- a/src/Turing.jl +++ b/src/Turing.jl @@ -9,7 +9,7 @@ using Compat: pkgversion using AdvancedVI: AdvancedVI using DynamicPPL: DynamicPPL, LogDensityFunction -import DynamicPPL: getspace, NoDist, NamedDist +import DynamicPPL: NoDist, NamedDist using LogDensityProblems: LogDensityProblems using NamedArrays: NamedArrays using Accessors: Accessors diff --git a/src/essential/container.jl b/src/essential/container.jl index bd4e21f6b5..a1012d471f 100644 --- a/src/essential/container.jl +++ b/src/essential/container.jl @@ -39,7 +39,7 @@ function AdvancedPS.advance!( end function AdvancedPS.delete_retained!(trace::TracedModel) - DynamicPPL.set_retained_vns_del_by_spl!(trace.varinfo, trace.sampler) + DynamicPPL.set_retained_vns_del!(trace.varinfo) return trace end diff --git a/src/mcmc/Inference.jl b/src/mcmc/Inference.jl index fa79656308..31308f7768 100644 --- a/src/mcmc/Inference.jl +++ b/src/mcmc/Inference.jl @@ -5,6 +5,10 @@ using DynamicPPL: Metadata, VarInfo, TypedVarInfo, + # TODO(mhauru) all_varnames_grouped_by_symbol isn't exported by DPPL. Either export it + # or use something else. + all_varnames_grouped_by_symbol, + syms, islinked, setindex!!, push!!, @@ -12,7 +16,6 @@ using DynamicPPL: getlogp, VarName, getsym, - _getvns, getdist, Model, Sampler, @@ -22,9 +25,7 @@ using DynamicPPL: PriorContext, LikelihoodContext, set_flag!, - unset_flag!, - getspace, - inspace + unset_flag! using Distributions, Libtask, Bijectors using DistributionsAD: VectorOfMultivariate using LinearAlgebra @@ -47,7 +48,6 @@ import AdvancedPS import Accessors import EllipticalSliceSampling import LogDensityProblems -import LogDensityProblemsAD import Random import MCMCChains import StatsBase: predict @@ -75,9 +75,7 @@ export InferenceAlgorithm, RepeatSampler, Prior, assume, - dot_assume, observe, - dot_observe, predict, externalsampler @@ -161,29 +159,6 @@ function externalsampler( return ExternalSampler(sampler, adtype, Val(unconstrained)) end -getADType(spl::Sampler) = getADType(spl.alg) -getADType(::SampleFromPrior) = Turing.DEFAULT_ADTYPE - -getADType(ctx::DynamicPPL.SamplingContext) = getADType(ctx.sampler) -getADType(ctx::DynamicPPL.AbstractContext) = getADType(DynamicPPL.NodeTrait(ctx), ctx) -getADType(::DynamicPPL.IsLeaf, ctx::DynamicPPL.AbstractContext) = Turing.DEFAULT_ADTYPE -function getADType(::DynamicPPL.IsParent, ctx::DynamicPPL.AbstractContext) - return getADType(DynamicPPL.childcontext(ctx)) -end - -getADType(alg::Hamiltonian) = alg.adtype - -function LogDensityProblemsAD.ADgradient(ℓ::DynamicPPL.LogDensityFunction) - return LogDensityProblemsAD.ADgradient(getADType(DynamicPPL.getcontext(ℓ)), ℓ) -end - -function LogDensityProblems.logdensity( - f::Turing.LogDensityFunction{<:AbstractVarInfo,<:Model,<:DynamicPPL.DefaultContext}, - x::NamedTuple, -) - return DynamicPPL.logjoint(f.model, DynamicPPL.unflatten(f.varinfo, x)) -end - # TODO: make a nicer `set_namedtuple!` and move these functions to DynamicPPL. function DynamicPPL.unflatten(vi::TypedVarInfo, θ::NamedTuple) set_namedtuple!(deepcopy(vi), θ) @@ -299,7 +274,7 @@ function AbstractMCMC.sample( kwargs..., ) check_model && _check_model(model, alg) - return AbstractMCMC.sample(rng, model, Sampler(alg, model), N; kwargs...) + return AbstractMCMC.sample(rng, model, Sampler(alg), N; kwargs...) end function AbstractMCMC.sample( @@ -326,9 +301,7 @@ function AbstractMCMC.sample( kwargs..., ) check_model && _check_model(model, alg) - return AbstractMCMC.sample( - rng, model, Sampler(alg, model), ensemble, N, n_chains; kwargs... - ) + return AbstractMCMC.sample(rng, model, Sampler(alg), ensemble, N, n_chains; kwargs...) end function AbstractMCMC.sample( @@ -583,11 +556,6 @@ end # Utilities # ############## -# TODO(mhauru) Remove this once DynamicPPL has removed all its Selector stuff. -DynamicPPL.getspace(::InferenceAlgorithm) = () -DynamicPPL.getspace(spl::Sampler) = getspace(spl.alg) -DynamicPPL.inspace(vn::VarName, spl::Sampler) = inspace(vn, getspace(spl.alg)) - """ transitions_from_chain( diff --git a/src/mcmc/abstractmcmc.jl b/src/mcmc/abstractmcmc.jl index aec7b153a9..b436f43579 100644 --- a/src/mcmc/abstractmcmc.jl +++ b/src/mcmc/abstractmcmc.jl @@ -1,6 +1,6 @@ -struct TuringState{S,F} +struct TuringState{S,M,V,C} state::S - logdensity::F + ldf::DynamicPPL.LogDensityFunction{M,V,C} end state_to_turing(f::DynamicPPL.LogDensityFunction, state) = TuringState(state, f) @@ -12,20 +12,10 @@ function transition_to_turing(f::DynamicPPL.LogDensityFunction, transition) return Transition(f.model, varinfo, transition) end -state_to_turing(f::LogDensityProblemsAD.ADGradientWrapper, state) = TuringState(state, f) -function transition_to_turing(f::LogDensityProblemsAD.ADGradientWrapper, transition) - return transition_to_turing(parent(f), transition) -end - -function varinfo_from_logdensityfn(f::LogDensityProblemsAD.ADGradientWrapper) - return varinfo_from_logdensityfn(parent(f)) -end -varinfo_from_logdensityfn(f::DynamicPPL.LogDensityFunction) = f.varinfo - function varinfo(state::TuringState) - θ = getparams(DynamicPPL.getmodel(state.logdensity), state.state) + θ = getparams(state.ldf.model, state.state) # TODO: Do we need to link here first? - return DynamicPPL.unflatten(varinfo_from_logdensityfn(state.logdensity), θ) + return DynamicPPL.unflatten(state.ldf.varinfo, θ) end varinfo(state::AbstractVarInfo) = state @@ -40,20 +30,6 @@ getstats(transition::AdvancedHMC.Transition) = transition.stat getparams(::DynamicPPL.Model, transition::AdvancedMH.Transition) = transition.params -getvarinfo(f::DynamicPPL.LogDensityFunction) = f.varinfo -function getvarinfo(f::LogDensityProblemsAD.ADGradientWrapper) - return getvarinfo(LogDensityProblemsAD.parent(f)) -end - -setvarinfo(f::DynamicPPL.LogDensityFunction, varinfo) = Accessors.@set f.varinfo = varinfo -function setvarinfo( - f::LogDensityProblemsAD.ADGradientWrapper, varinfo, adtype::ADTypes.AbstractADType -) - return LogDensityProblemsAD.ADgradient( - adtype, setvarinfo(LogDensityProblemsAD.parent(f), varinfo) - ) -end - # TODO: Do we also support `resume`, etc? function AbstractMCMC.step( rng::Random.AbstractRNG, @@ -66,12 +42,8 @@ function AbstractMCMC.step( alg = sampler_wrapper.alg sampler = alg.sampler - # Create a log-density function with an implementation of the - # gradient so we ensure that we're using the same AD backend as in Turing. - f = LogDensityProblemsAD.ADgradient(alg.adtype, DynamicPPL.LogDensityFunction(model)) - - # Link the varinfo if needed. - varinfo = getvarinfo(f) + # Initialise varinfo with initial params and link the varinfo if needed. + varinfo = DynamicPPL.VarInfo(model) if requires_unconstrained_space(alg) if initial_params !== nothing # If we have initial parameters, we need to set the varinfo before linking. @@ -82,9 +54,11 @@ function AbstractMCMC.step( varinfo = DynamicPPL.link(varinfo, model) end end - f = setvarinfo(f, varinfo, alg.adtype) - # Then just call `AdvancedHMC.step` with the right arguments. + # Construct LogDensityFunction + f = DynamicPPL.LogDensityFunction(model, varinfo; adtype=alg.adtype) + + # Then just call `AbstractMCMC.step` with the right arguments. if initial_state === nothing transition_inner, state_inner = AbstractMCMC.step( rng, AbstractMCMC.LogDensityModel(f), sampler; initial_params, kwargs... @@ -111,7 +85,7 @@ function AbstractMCMC.step( kwargs..., ) sampler = sampler_wrapper.alg.sampler - f = state.logdensity + f = state.ldf # Then just call `AdvancedHMC.step` with the right arguments. transition_inner, state_inner = AbstractMCMC.step( diff --git a/src/mcmc/emcee.jl b/src/mcmc/emcee.jl index 9d272f5a0a..ab68f795e1 100644 --- a/src/mcmc/emcee.jl +++ b/src/mcmc/emcee.jl @@ -53,7 +53,7 @@ function AbstractMCMC.step( length(initial_params) == n || throw(ArgumentError("initial parameters have to be specified for each walker")) vis = map(vis, initial_params) do vi, init - vi = DynamicPPL.initialize_parameters!!(vi, init, spl, model) + vi = DynamicPPL.initialize_parameters!!(vi, init, model) # Update log joint probability. last(DynamicPPL.evaluate!!(model, rng, vi, SampleFromPrior())) @@ -67,8 +67,8 @@ function AbstractMCMC.step( state = EmceeState( vis[1], map(vis) do vi - vi = DynamicPPL.link!!(vi, spl, model) - AMH.Transition(vi[spl], getlogp(vi), false) + vi = DynamicPPL.link!!(vi, model) + AMH.Transition(vi[:], getlogp(vi), false) end, ) @@ -89,7 +89,7 @@ function AbstractMCMC.step( # Compute the next transition and state. transition = map(states) do _state - vi = setindex!!(vi, _state.params, spl) + vi = DynamicPPL.unflatten(vi, _state.params) t = Transition(getparams(model, vi), _state.lp) return t end diff --git a/src/mcmc/ess.jl b/src/mcmc/ess.jl index 98d0adabc8..f07f0cd825 100644 --- a/src/mcmc/ess.jl +++ b/src/mcmc/ess.jl @@ -27,15 +27,20 @@ function DynamicPPL.initialstep( rng::AbstractRNG, model::Model, spl::Sampler{<:ESS}, vi::AbstractVarInfo; kwargs... ) # Sanity check - vns = _getvns(vi, spl) - length(vns) == 1 || - error("[ESS] does only support one variable ($(length(vns)) variables specified)") - for vn in only(vns) + # TODO(mhauru) What is the point of the first check? Why is it relevant that if there + # are multiple variables they are all under the same symbol? + vn_syms = syms(vi) + if length(vn_syms) != 1 + msg = """ + ESS only supports one variable symbol ($(length(vn_syms)) variables specified)\ + """ + error(msg) + end + for vn in keys(vi) dist = getdist(vi, vn) EllipticalSliceSampling.isgaussian(typeof(dist)) || - error("[ESS] only supports Gaussian prior distributions") + error("ESS only supports Gaussian prior distributions") end - return Transition(model, vi), vi end @@ -54,14 +59,16 @@ function AbstractMCMC.step( rng, EllipticalSliceSampling.ESSModel( ESSPrior(model, spl, vi), - Turing.LogDensityFunction(vi, model, spl, DynamicPPL.DefaultContext()), + Turing.LogDensityFunction( + model, vi, DynamicPPL.SamplingContext(spl, DynamicPPL.DefaultContext()) + ), ), EllipticalSliceSampling.ESS(), oldstate, ) # update sample and log-likelihood - vi = setindex!!(vi, sample, spl) + vi = DynamicPPL.unflatten(vi, sample) vi = setlogp!!(vi, state.loglikelihood) return Transition(model, vi), vi @@ -77,8 +84,8 @@ struct ESSPrior{M<:Model,S<:Sampler{<:ESS},V<:AbstractVarInfo,T} function ESSPrior{M,S,V}( model::M, sampler::S, varinfo::V ) where {M<:Model,S<:Sampler{<:ESS},V<:AbstractVarInfo} - vns = _getvns(varinfo, sampler) - μ = mapreduce(vcat, vns[1]) do vn + vns = keys(varinfo) + μ = mapreduce(vcat, vns) do vn dist = getdist(varinfo, vn) EllipticalSliceSampling.isgaussian(typeof(dist)) || error("[ESS] only supports Gaussian prior distributions") @@ -100,28 +107,22 @@ function Base.rand(rng::Random.AbstractRNG, p::ESSPrior) sampler = p.sampler varinfo = p.varinfo # TODO: Surely there's a better way of doing this now that we have `SamplingContext`? - vns = _getvns(varinfo, sampler) - for vn in Iterators.flatten(values(vns)) + vns = keys(varinfo) + for vn in vns set_flag!(varinfo, vn, "del") end p.model(rng, varinfo, sampler) - return varinfo[sampler] + return varinfo[:] end # Mean of prior distribution Distributions.mean(p::ESSPrior) = p.μ # Evaluate log-likelihood of proposals -const ESSLogLikelihood{M<:Model,S<:Sampler{<:ESS},V<:AbstractVarInfo} = Turing.LogDensityFunction{ - V,M,<:DynamicPPL.SamplingContext{<:S} -} - -function (ℓ::ESSLogLikelihood)(f::AbstractVector) - sampler = DynamicPPL.getsampler(ℓ) - varinfo = setindex!!(ℓ.varinfo, f, sampler) - varinfo = last(DynamicPPL.evaluate!!(ℓ.model, varinfo, sampler)) - return getlogp(varinfo) -end +const ESSLogLikelihood{M<:Model,S<:Sampler{<:ESS},V<:AbstractVarInfo} = + Turing.LogDensityFunction{M,V,<:DynamicPPL.SamplingContext{<:S},AD} where {AD} + +(ℓ::ESSLogLikelihood)(f::AbstractVector) = LogDensityProblems.logdensity(ℓ, f) function DynamicPPL.tilde_assume( rng::Random.AbstractRNG, ::DefaultContext, ::Sampler{<:ESS}, right, vn, vi @@ -131,22 +132,6 @@ function DynamicPPL.tilde_assume( ) end -function DynamicPPL.tilde_observe( - ctx::DefaultContext, sampler::Sampler{<:ESS}, right, left, vi -) +function DynamicPPL.tilde_observe(ctx::DefaultContext, ::Sampler{<:ESS}, right, left, vi) return DynamicPPL.tilde_observe(ctx, SampleFromPrior(), right, left, vi) end - -function DynamicPPL.dot_tilde_assume( - rng::Random.AbstractRNG, ::DefaultContext, ::Sampler{<:ESS}, right, left, vns, vi -) - return DynamicPPL.dot_tilde_assume( - rng, LikelihoodContext(), SampleFromPrior(), right, left, vns, vi - ) -end - -function DynamicPPL.dot_tilde_observe( - ctx::DefaultContext, sampler::Sampler{<:ESS}, right, left, vi -) - return DynamicPPL.dot_tilde_observe(ctx, SampleFromPrior(), right, left, vi) -end diff --git a/src/mcmc/gibbs.jl b/src/mcmc/gibbs.jl index c318cabe01..a75779e73e 100644 --- a/src/mcmc/gibbs.jl +++ b/src/mcmc/gibbs.jl @@ -198,58 +198,6 @@ function DynamicPPL.tilde_assume( end end -# Like the above tilde_assume methods, but with dot_tilde_assume and broadcasting of logpdf. -# See comments there for more details. -function DynamicPPL.dot_tilde_assume(context::GibbsContext, right, left, vns, vi) - child_context = DynamicPPL.childcontext(context) - return if is_target_varname(context, vns) - DynamicPPL.dot_tilde_assume(child_context, right, left, vns, vi) - elseif has_conditioned_gibbs(context, vns) - value, lp, _ = DynamicPPL.dot_tilde_assume( - child_context, right, left, vns, get_global_varinfo(context) - ) - value, lp, vi - else - value, lp, new_global_vi = DynamicPPL.dot_tilde_assume( - child_context, - DynamicPPL.SampleFromPrior(), - right, - left, - vns, - get_global_varinfo(context), - ) - set_global_varinfo!(context, new_global_vi) - value, lp, vi - end -end - -# As above but with an RNG. -function DynamicPPL.dot_tilde_assume( - rng::Random.AbstractRNG, context::GibbsContext, sampler, right, left, vns, vi -) - child_context = DynamicPPL.childcontext(context) - return if is_target_varname(context, vns) - DynamicPPL.dot_tilde_assume(rng, child_context, sampler, right, left, vns, vi) - elseif has_conditioned_gibbs(context, vns) - value, lp, _ = DynamicPPL.dot_tilde_assume( - child_context, right, left, vns, get_global_varinfo(context) - ) - value, lp, vi - else - value, lp, new_global_vi = DynamicPPL.dot_tilde_assume( - rng, - child_context, - DynamicPPL.SampleFromPrior(), - right, - left, - vns, - get_global_varinfo(context), - ) - set_global_varinfo!(context, new_global_vi) - value, lp, vi - end -end - """ make_conditional(model, target_variables, varinfo) @@ -281,16 +229,8 @@ function make_conditional( return DynamicPPL.contextualize(model, gibbs_context), gibbs_context_inner end -# All samplers are given the same Selector, so that they will sample all variables -# given to them by the Gibbs sampler. This avoids conflicts between the new and the old way -# of choosing which sampler to use. -function set_selector(x::DynamicPPL.Sampler) - return DynamicPPL.Sampler(x.alg, DynamicPPL.Selector(0)) -end -function set_selector(x::RepeatSampler) - return RepeatSampler(set_selector(x.sampler), x.num_repeat) -end -set_selector(x::InferenceAlgorithm) = DynamicPPL.Sampler(x, DynamicPPL.Selector(0)) +wrap_in_sampler(x::AbstractMCMC.AbstractSampler) = x +wrap_in_sampler(x::InferenceAlgorithm) = DynamicPPL.Sampler(x) to_varname_list(x::Union{VarName,Symbol}) = [VarName(x)] # Any other value is assumed to be an iterable of VarNames and Symbols. @@ -343,9 +283,7 @@ struct Gibbs{N,V<:NTuple{N,AbstractVector{<:VarName}},A<:NTuple{N,Any}} <: end end - # Ensure that samplers have the same selector, and that varnames are lists of - # VarNames. - samplers = tuple(map(set_selector, samplers)...) + samplers = tuple(map(wrap_in_sampler, samplers)...) varnames = tuple(map(to_varname_list, varnames)...) return new{length(samplers),typeof(varnames),typeof(samplers)}(varnames, samplers) end @@ -500,7 +438,9 @@ function setparams_varinfo!!( state::TuringState, params::AbstractVarInfo, ) - logdensity = DynamicPPL.setmodel(state.logdensity, model, sampler.alg.adtype) + logdensity = DynamicPPL.LogDensityFunction( + model, state.ldf.varinfo, state.ldf.context; adtype=sampler.alg.adtype + ) new_inner_state = setparams_varinfo!!( AbstractMCMC.LogDensityModel(logdensity), sampler, state.state, params ) diff --git a/src/mcmc/hmc.jl b/src/mcmc/hmc.jl index 524d02c6af..098e62eb22 100644 --- a/src/mcmc/hmc.jl +++ b/src/mcmc/hmc.jl @@ -148,27 +148,27 @@ function DynamicPPL.initialstep( kwargs..., ) # Transform the samples to unconstrained space and compute the joint log probability. - vi = DynamicPPL.link(vi_original, spl, model) + vi = DynamicPPL.link(vi_original, model) # Extract parameters. - theta = vi[spl] + theta = vi[:] # Create a Hamiltonian. metricT = getmetricT(spl.alg) metric = metricT(length(theta)) - ℓ = LogDensityProblemsAD.ADgradient( - Turing.LogDensityFunction( - vi, - model, - # Use the leaf-context from the `model` in case the user has - # contextualized the model with something like `PriorContext` - # to sample from the prior. - DynamicPPL.SamplingContext(rng, spl, DynamicPPL.leafcontext(model.context)), - ), + ldf = DynamicPPL.LogDensityFunction( + model, + vi, + # TODO(penelopeysm): Can we just use leafcontext(model.context)? Do we + # need to pass in the sampler? (In fact LogDensityFunction defaults to + # using leafcontext(model.context) so could we just remove the argument + # entirely?) + DynamicPPL.SamplingContext(rng, spl, DynamicPPL.leafcontext(model.context)); + adtype=spl.alg.adtype, ) - logπ = Base.Fix1(LogDensityProblems.logdensity, ℓ) - ∂logπ∂θ(x) = LogDensityProblems.logdensity_and_gradient(ℓ, x) - hamiltonian = AHMC.Hamiltonian(metric, logπ, ∂logπ∂θ) + lp_func = Base.Fix1(LogDensityProblems.logdensity, ldf) + lp_grad_func = Base.Fix1(LogDensityProblems.logdensity_and_gradient, ldf) + hamiltonian = AHMC.Hamiltonian(metric, lp_func, lp_grad_func) # Compute phase point z. z = AHMC.phasepoint(rng, theta, hamiltonian) @@ -189,9 +189,9 @@ function DynamicPPL.initialstep( # NOTE: This will sample in the unconstrained space. vi = last(DynamicPPL.evaluate!!(model, rng, vi, SampleFromUniform())) - theta = vi[spl] + theta = vi[:] - hamiltonian = AHMC.Hamiltonian(metric, logπ, ∂logπ∂θ) + hamiltonian = AHMC.Hamiltonian(metric, lp_func, lp_grad_func) z = AHMC.phasepoint(rng, theta, hamiltonian) init_attempt_count += 1 @@ -226,10 +226,10 @@ function DynamicPPL.initialstep( # Update `vi` based on acceptance if t.stat.is_accept - vi = DynamicPPL.unflatten(vi, spl, t.z.θ) + vi = DynamicPPL.unflatten(vi, t.z.θ) vi = setlogp!!(vi, t.stat.log_density) else - vi = DynamicPPL.unflatten(vi, spl, theta) + vi = DynamicPPL.unflatten(vi, theta) vi = setlogp!!(vi, log_density_old) end @@ -274,7 +274,7 @@ function AbstractMCMC.step( # Update variables vi = state.vi if t.stat.is_accept - vi = DynamicPPL.unflatten(vi, spl, t.z.θ) + vi = DynamicPPL.unflatten(vi, t.z.θ) vi = setlogp!!(vi, t.stat.log_density) end @@ -287,16 +287,19 @@ end function get_hamiltonian(model, spl, vi, state, n) metric = gen_metric(n, spl, state) - ℓ = LogDensityProblemsAD.ADgradient( - Turing.LogDensityFunction( - vi, - model, - DynamicPPL.SamplingContext(spl, DynamicPPL.leafcontext(model.context)), - ), + ldf = DynamicPPL.LogDensityFunction( + model, + vi, + # TODO(penelopeysm): Can we just use leafcontext(model.context)? Do we + # need to pass in the sampler? (In fact LogDensityFunction defaults to + # using leafcontext(model.context) so could we just remove the argument + # entirely?) + DynamicPPL.SamplingContext(spl, DynamicPPL.leafcontext(model.context)); + adtype=spl.alg.adtype, ) - ℓπ = Base.Fix1(LogDensityProblems.logdensity, ℓ) - ∂ℓπ∂θ = Base.Fix1(LogDensityProblems.logdensity_and_gradient, ℓ) - return AHMC.Hamiltonian(metric, ℓπ, ∂ℓπ∂θ) + lp_func = Base.Fix1(LogDensityProblems.logdensity, ldf) + lp_grad_func = Base.Fix1(LogDensityProblems.logdensity_and_gradient, ldf) + return AHMC.Hamiltonian(metric, lp_func, lp_grad_func) end """ @@ -493,45 +496,15 @@ end #### Compiler interface, i.e. tilde operators. #### function DynamicPPL.assume( - rng, spl::Sampler{<:Hamiltonian}, dist::Distribution, vn::VarName, vi + rng, ::Sampler{<:Hamiltonian}, dist::Distribution, vn::VarName, vi ) return DynamicPPL.assume(dist, vn, vi) end -function DynamicPPL.dot_assume( - rng, - spl::Sampler{<:Hamiltonian}, - dist::MultivariateDistribution, - vns::AbstractArray{<:VarName}, - var::AbstractMatrix, - vi, -) - return DynamicPPL.dot_assume(dist, var, vns, vi) -end -function DynamicPPL.dot_assume( - rng, - spl::Sampler{<:Hamiltonian}, - dists::Union{Distribution,AbstractArray{<:Distribution}}, - vns::AbstractArray{<:VarName}, - var::AbstractArray, - vi, -) - return DynamicPPL.dot_assume(dists, var, vns, vi) -end - -function DynamicPPL.observe(spl::Sampler{<:Hamiltonian}, d::Distribution, value, vi) +function DynamicPPL.observe(::Sampler{<:Hamiltonian}, d::Distribution, value, vi) return DynamicPPL.observe(d, value, vi) end -function DynamicPPL.dot_observe( - spl::Sampler{<:Hamiltonian}, - ds::Union{Distribution,AbstractArray{<:Distribution}}, - value::AbstractArray, - vi, -) - return DynamicPPL.dot_observe(ds, value, vi) -end - #### #### Default HMC stepsize and mass matrix adaptor #### diff --git a/src/mcmc/is.jl b/src/mcmc/is.jl index 23a7bbef19..d83abd173c 100644 --- a/src/mcmc/is.jl +++ b/src/mcmc/is.jl @@ -46,16 +46,16 @@ function getlogevidence(samples::Vector{<:Transition}, ::Sampler{<:IS}, state) return logsumexp(map(x -> x.lp, samples)) - log(length(samples)) end -function DynamicPPL.assume(rng, spl::Sampler{<:IS}, dist::Distribution, vn::VarName, vi) +function DynamicPPL.assume(rng, ::Sampler{<:IS}, dist::Distribution, vn::VarName, vi) if haskey(vi, vn) r = vi[vn] else r = rand(rng, dist) - vi = push!!(vi, vn, r, dist, spl) + vi = push!!(vi, vn, r, dist) end return r, 0, vi end -function DynamicPPL.observe(spl::Sampler{<:IS}, dist::Distribution, value, vi) +function DynamicPPL.observe(::Sampler{<:IS}, dist::Distribution, value, vi) return logpdf(dist, value), vi end diff --git a/src/mcmc/mh.jl b/src/mcmc/mh.jl index 33587f1e47..0af62e2597 100644 --- a/src/mcmc/mh.jl +++ b/src/mcmc/mh.jl @@ -186,26 +186,16 @@ end A log density function for the MH sampler. -This variant uses the `set_namedtuple!` function to update the `VarInfo`. +This variant uses the `set_namedtuple!` function to update the `VarInfo`. """ -const MHLogDensityFunction{M<:Model,S<:Sampler{<:MH},V<:AbstractVarInfo} = Turing.LogDensityFunction{ - V,M,<:DynamicPPL.SamplingContext{<:S} -} +const MHLogDensityFunction{M<:Model,S<:Sampler{<:MH},V<:AbstractVarInfo} = + Turing.LogDensityFunction{M,V,<:DynamicPPL.SamplingContext{<:S},AD} where {AD} function LogDensityProblems.logdensity(f::MHLogDensityFunction, x::NamedTuple) - # TODO: Make this work with immutable `f.varinfo` too. - sampler = DynamicPPL.getsampler(f) - vi = f.varinfo - - x_old, lj_old = vi[sampler], getlogp(vi) + vi = deepcopy(f.varinfo) set_namedtuple!(vi, x) - vi_new = last(DynamicPPL.evaluate!!(f.model, vi, DynamicPPL.getcontext(f))) + vi_new = last(DynamicPPL.evaluate!!(f.model, vi, f.context)) lj = getlogp(vi_new) - - # Reset old `vi`. - setindex!!(vi, x_old, sampler) - setlogp!!(vi, lj_old) - return lj end @@ -237,7 +227,7 @@ The first `NamedTuple` has symbols as keys and distributions as values. The second `NamedTuple` has model symbols as keys and their stored values as values. """ function dist_val_tuple(spl::Sampler{<:MH}, vi::DynamicPPL.VarInfoOrThreadSafeVarInfo) - vns = _getvns(vi, spl) + vns = all_varnames_grouped_by_symbol(vi) dt = _dist_tuple(spl.alg.proposals, vi, vns) vt = _val_tuple(vi, vns) return dt, vt @@ -297,7 +287,7 @@ end function maybe_link!!(varinfo, sampler, proposal, model) return if should_link(varinfo, sampler, proposal) - link!!(varinfo, sampler, model) + link!!(varinfo, model) else varinfo end @@ -319,8 +309,8 @@ function propose!!( Base.Fix1( LogDensityProblems.logdensity, Turing.LogDensityFunction( - vi, model, + vi, DynamicPPL.SamplingContext(rng, spl, DynamicPPL.leafcontext(model.context)), ), ), @@ -354,15 +344,15 @@ function propose!!( Base.Fix1( LogDensityProblems.logdensity, Turing.LogDensityFunction( - vi, model, + vi, DynamicPPL.SamplingContext(rng, spl, DynamicPPL.leafcontext(model.context)), ), ), ) trans, _ = AbstractMCMC.step(rng, densitymodel, mh_sampler, prev_trans) - return setlogp!!(DynamicPPL.unflatten(vi, spl, trans.params), trans.lp) + return setlogp!!(DynamicPPL.unflatten(vi, trans.params), trans.lp) end function DynamicPPL.initialstep( @@ -401,40 +391,6 @@ function DynamicPPL.assume( return retval end -function DynamicPPL.dot_assume( - rng, - spl::Sampler{<:MH}, - dist::MultivariateDistribution, - vns::AbstractVector{<:VarName}, - var::AbstractMatrix, - vi::AbstractVarInfo, -) - # Just defer to `SampleFromPrior`. - retval = DynamicPPL.dot_assume(rng, SampleFromPrior(), dist, vns[1], var, vi) - return retval -end -function DynamicPPL.dot_assume( - rng, - spl::Sampler{<:MH}, - dists::Union{Distribution,AbstractArray{<:Distribution}}, - vns::AbstractArray{<:VarName}, - var::AbstractArray, - vi::AbstractVarInfo, -) - # Just defer to `SampleFromPrior`. - retval = DynamicPPL.dot_assume(rng, SampleFromPrior(), dists, vns, var, vi) - return retval -end - function DynamicPPL.observe(spl::Sampler{<:MH}, d::Distribution, value, vi) return DynamicPPL.observe(SampleFromPrior(), d, value, vi) end - -function DynamicPPL.dot_observe( - spl::Sampler{<:MH}, - ds::Union{Distribution,AbstractArray{<:Distribution}}, - value::AbstractArray, - vi, -) - return DynamicPPL.dot_observe(SampleFromPrior(), ds, value, vi) -end diff --git a/src/mcmc/particle_mcmc.jl b/src/mcmc/particle_mcmc.jl index 733d572c73..5bb1103876 100644 --- a/src/mcmc/particle_mcmc.jl +++ b/src/mcmc/particle_mcmc.jl @@ -119,7 +119,7 @@ function DynamicPPL.initialstep( ) # Reset the VarInfo. reset_num_produce!(vi) - set_retained_vns_del_by_spl!(vi, spl) + set_retained_vns_del!(vi) resetlogp!!(vi) empty!!(vi) @@ -253,7 +253,7 @@ function DynamicPPL.initialstep( ) # Reset the VarInfo before new sweep reset_num_produce!(vi) - set_retained_vns_del_by_spl!(vi, spl) + set_retained_vns_del!(vi) resetlogp!!(vi) # Create a new set of particles @@ -291,7 +291,7 @@ function AbstractMCMC.step( reference = AdvancedPS.forkr(AdvancedPS.Trace(model, spl, vi, state.rng)) # For all other particles, do not retain the variables but resample them. - set_retained_vns_del_by_spl!(vi, spl) + set_retained_vns_del!(vi) # Create a new set of particles. num_particles = spl.alg.nparticles @@ -365,7 +365,7 @@ function DynamicPPL.assume( if ~haskey(vi, vn) r = rand(trng, dist) - push!!(vi, vn, r, dist, spl) + push!!(vi, vn, r, dist) elseif is_flagged(vi, vn, "del") unset_flag!(vi, vn, "del") # Reference particle parent r = rand(trng, dist) diff --git a/src/mcmc/sghmc.jl b/src/mcmc/sghmc.jl index 7cf5cd6e4d..0c322244eb 100644 --- a/src/mcmc/sghmc.jl +++ b/src/mcmc/sghmc.jl @@ -59,17 +59,20 @@ function DynamicPPL.initialstep( kwargs..., ) # Transform the samples to unconstrained space and compute the joint log probability. - if !DynamicPPL.islinked(vi, spl) - vi = DynamicPPL.link!!(vi, spl, model) + if !DynamicPPL.islinked(vi) + vi = DynamicPPL.link!!(vi, model) vi = last(DynamicPPL.evaluate!!(model, vi, DynamicPPL.SamplingContext(rng, spl))) end # Compute initial sample and state. sample = Transition(model, vi) - ℓ = LogDensityProblemsAD.ADgradient( - Turing.LogDensityFunction(vi, model, spl, DynamicPPL.DefaultContext()) + ℓ = DynamicPPL.LogDensityFunction( + model, + vi, + DynamicPPL.SamplingContext(spl, DynamicPPL.DefaultContext()); + adtype=spl.alg.adtype, ) - state = SGHMCState(ℓ, vi, zero(vi[spl])) + state = SGHMCState(ℓ, vi, zero(vi[:])) return sample, state end @@ -84,7 +87,7 @@ function AbstractMCMC.step( # Compute gradient of log density. ℓ = state.logdensity vi = state.vi - θ = vi[spl] + θ = vi[:] grad = last(LogDensityProblems.logdensity_and_gradient(ℓ, θ)) # Update latent variables and velocity according to @@ -96,7 +99,7 @@ function AbstractMCMC.step( newv = (1 - α) .* v .+ η .* grad .+ sqrt(2 * η * α) .* randn(rng, eltype(v), length(v)) # Save new variables and recompute log density. - vi = DynamicPPL.setindex!!(vi, θ, spl) + vi = DynamicPPL.unflatten(vi, θ) vi = last(DynamicPPL.evaluate!!(model, vi, DynamicPPL.SamplingContext(rng, spl))) # Compute next sample and state. @@ -219,15 +222,18 @@ function DynamicPPL.initialstep( kwargs..., ) # Transform the samples to unconstrained space and compute the joint log probability. - if !DynamicPPL.islinked(vi, spl) - vi = DynamicPPL.link!!(vi, spl, model) + if !DynamicPPL.islinked(vi) + vi = DynamicPPL.link!!(vi, model) vi = last(DynamicPPL.evaluate!!(model, vi, DynamicPPL.SamplingContext(rng, spl))) end # Create first sample and state. sample = SGLDTransition(model, vi, zero(spl.alg.stepsize(0))) - ℓ = LogDensityProblemsAD.ADgradient( - Turing.LogDensityFunction(vi, model, spl, DynamicPPL.DefaultContext()) + ℓ = DynamicPPL.LogDensityFunction( + model, + vi, + DynamicPPL.SamplingContext(spl, DynamicPPL.DefaultContext()); + adtype=spl.alg.adtype, ) state = SGLDState(ℓ, vi, 1) @@ -240,14 +246,14 @@ function AbstractMCMC.step( # Perform gradient step. ℓ = state.logdensity vi = state.vi - θ = vi[spl] + θ = vi[:] grad = last(LogDensityProblems.logdensity_and_gradient(ℓ, θ)) step = state.step stepsize = spl.alg.stepsize(step) θ .+= (stepsize / 2) .* grad .+ sqrt(stepsize) .* randn(rng, eltype(θ), length(θ)) # Save new variables and recompute log density. - vi = DynamicPPL.setindex!!(vi, θ, spl) + vi = DynamicPPL.unflatten(vi, θ) vi = last(DynamicPPL.evaluate!!(model, vi, DynamicPPL.SamplingContext(rng, spl))) # Compute next sample and state. diff --git a/src/optimisation/Optimisation.jl b/src/optimisation/Optimisation.jl index 414561bdef..3d8ce1d4a3 100644 --- a/src/optimisation/Optimisation.jl +++ b/src/optimisation/Optimisation.jl @@ -4,7 +4,6 @@ using ..Turing using NamedArrays: NamedArrays using DynamicPPL: DynamicPPL using LogDensityProblems: LogDensityProblems -using LogDensityProblemsAD: LogDensityProblemsAD using Optimization: Optimization using OptimizationOptimJL: OptimizationOptimJL using Random: Random @@ -88,58 +87,78 @@ function DynamicPPL.tilde_assume(ctx::OptimizationContext, dist, vn, vi) return r, lp, vi end -_loglikelihood(dist::Distribution, x) = StatsAPI.loglikelihood(dist, x) - -function _loglikelihood(dists::AbstractArray{<:Distribution}, x) - return StatsAPI.loglikelihood(arraydist(dists), x) -end - -function DynamicPPL.dot_tilde_assume(ctx::OptimizationContext, right, left, vns, vi) - # Values should be set and we're using `SampleFromPrior`, hence the `rng` argument - # shouldn't affect anything. - # TODO: Stop using `get_and_set_val!`. - r = DynamicPPL.get_and_set_val!( - Random.default_rng(), vi, vns, right, DynamicPPL.SampleFromPrior() - ) - lp = if ctx.context isa Union{DynamicPPL.DefaultContext,DynamicPPL.PriorContext} - # MAP - _loglikelihood(right, r) - else - # MLE - 0 - end - return r, lp, vi -end - function DynamicPPL.tilde_observe( ctx::OptimizationContext{<:DynamicPPL.PriorContext}, args... ) return DynamicPPL.tilde_observe(ctx.context, args...) end -function DynamicPPL.dot_tilde_observe( - ctx::OptimizationContext{<:DynamicPPL.PriorContext}, args... -) - return DynamicPPL.dot_tilde_observe(ctx.context, args...) -end - """ - OptimLogDensity{M<:DynamicPPL.Model,C<:Context,V<:DynamicPPL.VarInfo} + OptimLogDensity{ + M<:DynamicPPL.Model, + V<:DynamicPPL.VarInfo, + C<:OptimizationContext, + AD<:ADTypes.AbstractADType + } + +A struct that wraps a single LogDensityFunction. Can be invoked either using + +```julia +OptimLogDensity(model, varinfo, ctx; adtype=adtype) +``` + +or + +```julia +OptimLogDensity(model, ctx; adtype=adtype) +``` -A struct that stores the negative log density function of a `DynamicPPL` model. +If not specified, `adtype` defaults to `AutoForwardDiff()`. + +An OptimLogDensity does not, in itself, obey the LogDensityProblems interface. +Thus, if you want to calculate the log density of its contents at the point +`z`, you should manually call + +```julia +LogDensityProblems.logdensity(f.ldf, z) +``` + +However, it is a callable object which returns the *negative* log density of +the underlying LogDensityFunction at the point `z`. This is done to satisfy +the Optim.jl interface. + +```julia +optim_ld = OptimLogDensity(model, varinfo, ctx) +optim_ld(z) # returns -logp +``` """ -const OptimLogDensity{M<:DynamicPPL.Model,C<:OptimizationContext,V<:DynamicPPL.VarInfo} = Turing.LogDensityFunction{ - V,M,C +struct OptimLogDensity{ + M<:DynamicPPL.Model, + V<:DynamicPPL.VarInfo, + C<:OptimizationContext, + AD<:ADTypes.AbstractADType, } + ldf::Turing.LogDensityFunction{M,V,C,AD} +end -""" - OptimLogDensity(model::DynamicPPL.Model, context::OptimizationContext) +function OptimLogDensity( + model::DynamicPPL.Model, + vi::DynamicPPL.VarInfo, + ctx::OptimizationContext; + adtype::ADTypes.AbstractADType=AutoForwardDiff(), +) + return OptimLogDensity(Turing.LogDensityFunction(model, vi, ctx; adtype=adtype)) +end -Create a callable `OptimLogDensity` struct that evaluates a model using the given `context`. -""" -function OptimLogDensity(model::DynamicPPL.Model, context::OptimizationContext) - init = DynamicPPL.VarInfo(model) - return Turing.LogDensityFunction(init, model, context) +# No varinfo +function OptimLogDensity( + model::DynamicPPL.Model, + ctx::OptimizationContext; + adtype::ADTypes.AbstractADType=AutoForwardDiff(), +) + return OptimLogDensity( + Turing.LogDensityFunction(model, DynamicPPL.VarInfo(model), ctx; adtype=adtype) + ) end """ @@ -152,42 +171,30 @@ depends on the context of `f`. Any second argument is ignored. The two-argument method only exists to match interface the required by Optimization.jl. """ -function (f::OptimLogDensity)(z::AbstractVector) - varinfo = DynamicPPL.unflatten(f.varinfo, z) - return -DynamicPPL.getlogp( - last(DynamicPPL.evaluate!!(f.model, varinfo, DynamicPPL.getcontext(f))) - ) -end - +(f::OptimLogDensity)(z::AbstractVector) = -LogDensityProblems.logdensity(f.ldf, z) (f::OptimLogDensity)(z, _) = f(z) -# NOTE: This seems a bit weird IMO since this is the _negative_ log-likelihood. -LogDensityProblems.logdensity(f::OptimLogDensity, z::AbstractVector) = f(z) - # NOTE: The format of this function is dictated by Optim. The first argument sets whether to # compute the function value, the second whether to compute the gradient (and stores the # gradient). The last one is the actual argument of the objective function. function (f::OptimLogDensity)(F, G, z) if G !== nothing - # Calculate negative log joint and its gradient. - # TODO: Make OptimLogDensity already an LogDensityProblems.ADgradient? Allow to - # specify AD? - ℓ = LogDensityProblemsAD.ADgradient(f) - neglogp, ∇neglogp = LogDensityProblems.logdensity_and_gradient(ℓ, z) + # Calculate log joint and its gradient. + logp, ∇logp = LogDensityProblems.logdensity_and_gradient(f.ldf, z) - # Save the gradient to the pre-allocated array. - copyto!(G, ∇neglogp) + # Save the negative gradient to the pre-allocated array. + copyto!(G, -∇logp) # If F is something, the negative log joint is requested as well. # We have already computed it as a by-product above and hence return it directly. if F !== nothing - return neglogp + return -logp end end # Only negative log joint requested but no gradient. if F !== nothing - return LogDensityProblems.logdensity(f, z) + return -LogDensityProblems.logdensity(f.ldf, z) end return nothing @@ -263,9 +270,11 @@ function StatsBase.informationmatrix( # Convert the values to their unconstrained states to make sure the # Hessian is computed with respect to the untransformed parameters. - linked = DynamicPPL.istrans(m.f.varinfo) + linked = DynamicPPL.istrans(m.f.ldf.varinfo) if linked - m = Accessors.@set m.f.varinfo = DynamicPPL.invlink!!(m.f.varinfo, m.f.model) + new_vi = DynamicPPL.invlink!!(m.f.ldf.varinfo, m.f.ldf.model) + new_f = OptimLogDensity(m.f.ldf.model, new_vi, m.f.ldf.context) + m = Accessors.@set m.f = new_f end # Calculate the Hessian, which is the information matrix because the negative of the log @@ -275,7 +284,9 @@ function StatsBase.informationmatrix( # Link it back if we invlinked it. if linked - m = Accessors.@set m.f.varinfo = DynamicPPL.link!!(m.f.varinfo, m.f.model) + new_vi = DynamicPPL.link!!(m.f.ldf.varinfo, m.f.ldf.model) + new_f = OptimLogDensity(m.f.ldf.model, new_vi, m.f.ldf.context) + m = Accessors.@set m.f = new_f end return NamedArrays.NamedArray(info, (varnames, varnames)) @@ -296,7 +307,7 @@ Return the values of all the variables with the symbol(s) `var_symbol` in the mo argument should be either a `Symbol` or a vector of `Symbol`s. """ function Base.get(m::ModeResult, var_symbols::AbstractVector{Symbol}) - log_density = m.f + log_density = m.f.ldf # Get all the variable names in the model. This is the same as the list of keys in # m.values, but they are more convenient to filter when they are VarNames rather than # Symbols. @@ -328,9 +339,9 @@ richer format of `ModeResult`. It also takes care of transforming them back to t parameter space in case the optimization was done in a transformed space. """ function ModeResult(log_density::OptimLogDensity, solution::SciMLBase.OptimizationSolution) - varinfo_new = DynamicPPL.unflatten(log_density.varinfo, solution.u) + varinfo_new = DynamicPPL.unflatten(log_density.ldf.varinfo, solution.u) # `getparams` performs invlinking if needed - vns_vals_iter = Turing.Inference.getparams(log_density.model, varinfo_new) + vns_vals_iter = Turing.Inference.getparams(log_density.ldf.model, varinfo_new) syms = map(Symbol ∘ first, vns_vals_iter) vals = map(last, vns_vals_iter) return ModeResult( @@ -414,12 +425,15 @@ end OptimizationProblem(log_density::OptimLogDensity, adtype, constraints) Create an `OptimizationProblem` for the objective function defined by `log_density`. + +Note that the adtype parameter here overrides any adtype parameter the +OptimLogDensity was constructed with. """ function Optimization.OptimizationProblem(log_density::OptimLogDensity, adtype, constraints) # Note that OptimLogDensity is a callable that evaluates the model with given # parameters. Hence we can use it in the objective function as below. f = Optimization.OptimizationFunction(log_density, adtype; cons=constraints.cons) - initial_params = log_density.varinfo[:] + initial_params = log_density.ldf.varinfo[:] prob = if !has_constraints(constraints) Optimization.OptimizationProblem(f, initial_params) else @@ -485,28 +499,34 @@ function estimate_mode( end # Create an OptimLogDensity object that can be used to evaluate the objective function, - # i.e. the negative log density. Set its VarInfo to the initial parameters. - log_density = let - inner_context = if estimator isa MAP - DynamicPPL.DefaultContext() - else - DynamicPPL.LikelihoodContext() - end - ctx = OptimizationContext(inner_context) - ld = OptimLogDensity(model, ctx) - Accessors.@set ld.varinfo = DynamicPPL.unflatten(ld.varinfo, initial_params) + # i.e. the negative log density. + inner_context = if estimator isa MAP + DynamicPPL.DefaultContext() + else + DynamicPPL.LikelihoodContext() end + ctx = OptimizationContext(inner_context) + # Set its VarInfo to the initial parameters. + # TODO(penelopeysm): Unclear if this is really needed? Any time that logp is calculated + # (using `LogDensityProblems.logdensity(ldf, x)`) the parameters in the + # varinfo are completely ignored. The parameters only matter if you are calling evaluate!! + # directly on the fields of the LogDensityFunction + vi = DynamicPPL.VarInfo(model) + vi = DynamicPPL.unflatten(vi, initial_params) + + # Link the varinfo if needed. # TODO(mhauru) We currently couple together the questions of whether the user specified # bounds/constraints and whether we transform the objective function to an # unconstrained space. These should be separate concerns, but for that we need to # implement getting the bounds of the prior distributions. optimise_in_unconstrained_space = !has_constraints(constraints) if optimise_in_unconstrained_space - transformed_varinfo = DynamicPPL.link(log_density.varinfo, log_density.model) - log_density = Accessors.@set log_density.varinfo = transformed_varinfo + vi = DynamicPPL.link(vi, model) end + log_density = OptimLogDensity(model, vi, ctx) + prob = Optimization.OptimizationProblem(log_density, adtype, constraints) solution = Optimization.solve(prob, solver; kwargs...) # TODO(mhauru) We return a ModeResult for compatibility with the older Optim.jl diff --git a/test/Project.toml b/test/Project.toml index e96d505e73..6d104cbfc8 100644 --- a/test/Project.toml +++ b/test/Project.toml @@ -51,7 +51,7 @@ Combinatorics = "1" Distributions = "0.25" DistributionsAD = "0.6.3" DynamicHMC = "2.1.6, 3.0" -DynamicPPL = "0.33, 0.34" +DynamicPPL = "0.35" FiniteDifferences = "0.10.8, 0.11, 0.12" ForwardDiff = "0.10.12 - 0.10.32, 0.10" HypothesisTests = "0.11" diff --git a/test/dynamicppl/compiler.jl b/test/dynamicppl/compiler.jl index 1c50c2d9e9..062b52d894 100644 --- a/test/dynamicppl/compiler.jl +++ b/test/dynamicppl/compiler.jl @@ -269,7 +269,9 @@ const gdemo_default = gdemo_d() @model function vdemo2(x) μ ~ MvNormal(zeros(size(x, 1)), I) - return x .~ MvNormal(μ, I) + for i in axes(x, 2) + x[:, i] ~ MvNormal(μ, I) + end end D = 2 @@ -316,7 +318,7 @@ const gdemo_default = gdemo_d() @model function vdemo7() x = Array{Real}(undef, N, N) - return x .~ [InverseGamma(2, 3) for i in 1:N] + return x ~ product_distribution([InverseGamma(2, 3) for i in 1:N]) end sample(vdemo7(), alg, 1000) diff --git a/test/essential/ad.jl b/test/essential/ad.jl deleted file mode 100644 index 0c497a2cbd..0000000000 --- a/test/essential/ad.jl +++ /dev/null @@ -1,246 +0,0 @@ -module AdTests - -using ..Models: gdemo_default -using Distributions: logpdf -using DynamicPPL: getlogp, getindex_internal -using ForwardDiff -using LinearAlgebra -using LogDensityProblems: LogDensityProblems -using LogDensityProblemsAD: LogDensityProblemsAD -using ReverseDiff -using Test: @test, @testset -using Turing -using Turing: SampleFromPrior -using Zygote - -function test_model_ad(model, f, syms::Vector{Symbol}) - # Set up VI. - vi = Turing.VarInfo(model) - - # Collect symbols. - vnms = Vector(undef, length(syms)) - vnvals = Vector{Float64}() - for i in 1:length(syms) - s = syms[i] - vnms[i] = getfield(vi.metadata, s).vns[1] - - vals = getindex_internal(vi, vnms[i]) - for i in eachindex(vals) - push!(vnvals, vals[i]) - end - end - - # Compute primal. - x = vec(vnvals) - logp = f(x) - - # Call ForwardDiff's AD directly. - grad_FWAD = sort(ForwardDiff.gradient(f, x)) - - # Compare with `logdensity_and_gradient`. - z = vi[SampleFromPrior()] - for chunksize in (0, 1, 10), standardtag in (true, false, 0, 3) - ℓ = LogDensityProblemsAD.ADgradient( - Turing.AutoForwardDiff(; chunksize=chunksize, tag=standardtag), - Turing.LogDensityFunction( - vi, model, SampleFromPrior(), DynamicPPL.DefaultContext() - ), - ) - l, ∇E = LogDensityProblems.logdensity_and_gradient(ℓ, z) - - # Compare result - @test l ≈ logp - @test sort(∇E) ≈ grad_FWAD atol = 1e-9 - end -end - -@testset "ad.jl" begin - @testset "adr" begin - ad_test_f = gdemo_default - vi = Turing.VarInfo(ad_test_f) - ad_test_f(vi, SampleFromPrior()) - svn = vi.metadata.s.vns[1] - mvn = vi.metadata.m.vns[1] - _s = getindex_internal(vi, svn)[1] - _m = getindex_internal(vi, mvn)[1] - - dist_s = InverseGamma(2, 3) - - # Hand-written logp - function logp(x::Vector) - s = x[2] - # s = invlink(dist_s, s) - m = x[1] - lik_dist = Normal(m, sqrt(s)) - lp = logpdf(dist_s, s) + logpdf(Normal(0, sqrt(s)), m) - lp += logpdf(lik_dist, 1.5) + logpdf(lik_dist, 2.0) - return lp - end - - # Call ForwardDiff's AD - g = x -> ForwardDiff.gradient(logp, x) - # _s = link(dist_s, _s) - _x = [_m, _s] - grad_FWAD = sort(g(_x)) - - ℓ = Turing.LogDensityFunction( - vi, ad_test_f, SampleFromPrior(), DynamicPPL.DefaultContext() - ) - x = map(x -> Float64(x), vi[SampleFromPrior()]) - - zygoteℓ = LogDensityProblemsAD.ADgradient(Turing.AutoZygote(), ℓ) - if isdefined(Base, :get_extension) - @test zygoteℓ isa - Base.get_extension( - LogDensityProblemsAD, :LogDensityProblemsADZygoteExt - ).ZygoteGradientLogDensity - else - @test zygoteℓ isa - LogDensityProblemsAD.LogDensityProblemsADZygoteExt.ZygoteGradientLogDensity - end - @test zygoteℓ.ℓ === ℓ - ∇E2 = LogDensityProblems.logdensity_and_gradient(zygoteℓ, x)[2] - @test sort(∇E2) ≈ grad_FWAD atol = 1e-9 - end - - @testset "general AD tests" begin - # Tests gdemo gradient. - function logp1(x::Vector) - dist_s = InverseGamma(2, 3) - s = x[2] - m = x[1] - lik_dist = Normal(m, sqrt(s)) - lp = - Turing.logpdf_with_trans(dist_s, s, false) + - Turing.logpdf_with_trans(Normal(0, sqrt(s)), m, false) - lp += logpdf(lik_dist, 1.5) + logpdf(lik_dist, 2.0) - return lp - end - - test_model_ad(gdemo_default, logp1, [:m, :s]) - - # Test Wishart AD. - @model function wishart_ad() - v ~ Wishart(7, [1 0.5; 0.5 1]) - return v - end - - # Hand-written logp - function logp3(x) - dist_v = Wishart(7, [1 0.5; 0.5 1]) - v = [x[1] x[3]; x[2] x[4]] - lp = Turing.logpdf_with_trans(dist_v, v, false) - return lp - end - - test_model_ad(wishart_ad(), logp3, [:v]) - end - @testset "Simplex Zygote and ReverseDiff (with and without caching) AD" begin - @model function dir() - return theta ~ Dirichlet(1 ./ fill(4, 4)) - end - sample(dir(), HMC(0.01, 1; adtype=AutoZygote()), 1000) - sample(dir(), HMC(0.01, 1; adtype=AutoReverseDiff(; compile=false)), 1000) - sample(dir(), HMC(0.01, 1; adtype=AutoReverseDiff(; compile=true)), 1000) - end - @testset "PDMatDistribution AD" begin - @model function wishart() - return theta ~ Wishart(4, Matrix{Float64}(I, 4, 4)) - end - - sample(wishart(), HMC(0.01, 1; adtype=AutoReverseDiff(; compile=false)), 1000) - sample(wishart(), HMC(0.01, 1; adtype=AutoZygote()), 1000) - - @model function invwishart() - return theta ~ InverseWishart(4, Matrix{Float64}(I, 4, 4)) - end - - sample(invwishart(), HMC(0.01, 1; adtype=AutoReverseDiff(; compile=false)), 1000) - sample(invwishart(), HMC(0.01, 1; adtype=AutoZygote()), 1000) - end - @testset "Hessian test" begin - @model function tst(x, ::Type{TV}=Vector{Float64}) where {TV} - params = TV(undef, 2) - @. params ~ Normal(0, 1) - - return x ~ MvNormal(params, I) - end - - function make_logjoint(model::DynamicPPL.Model, ctx::DynamicPPL.AbstractContext) - # setup - varinfo_init = Turing.VarInfo(model) - spl = DynamicPPL.SampleFromPrior() - varinfo_init = DynamicPPL.link!!(varinfo_init, spl, model) - - function logπ(z; unlinked=false) - varinfo = DynamicPPL.unflatten(varinfo_init, spl, z) - - # TODO(torfjelde): Pretty sure this is a mistake. - # Why are we not linking `varinfo` rather than `varinfo_init`? - if unlinked - varinfo_init = DynamicPPL.invlink!!(varinfo_init, spl, model) - end - varinfo = last( - DynamicPPL.evaluate!!( - model, varinfo, DynamicPPL.SamplingContext(spl, ctx) - ), - ) - if unlinked - varinfo_init = DynamicPPL.link!!(varinfo_init, spl, model) - end - - return -DynamicPPL.getlogp(varinfo) - end - - return logπ - end - - data = [0.5, -0.5] - model = tst(data) - - likelihood = make_logjoint(model, DynamicPPL.LikelihoodContext()) - target(x) = likelihood(x; unlinked=true) - - H_f = ForwardDiff.hessian(target, zeros(2)) - H_r = ReverseDiff.hessian(target, zeros(2)) - @test H_f == [1.0 0.0; 0.0 1.0] - @test H_f == H_r - end - - @testset "memoization: issue #1393" begin - @model function demo(data) - sigma ~ Uniform(0.0, 20.0) - return data ~ Normal(0, sigma) - end - - N = 1000 - for i in 1:5 - d = Normal(0.0, i) - data = rand(d, N) - chn = sample( - demo(data), NUTS(0.65; adtype=AutoReverseDiff(; compile=true)), 1000 - ) - @test mean(Array(chn[:sigma])) ≈ std(data) atol = 0.5 - end - end - - @testset "ReverseDiff compiled without linking" begin - f = DynamicPPL.LogDensityFunction(gdemo_default) - θ = DynamicPPL.getparams(f) - - f_rd = LogDensityProblemsAD.ADgradient(Turing.AutoReverseDiff(; compile=false), f) - f_rd_compiled = LogDensityProblemsAD.ADgradient( - Turing.AutoReverseDiff(; compile=true), f - ) - - ℓ, ℓ_grad = LogDensityProblems.logdensity_and_gradient(f_rd, θ) - ℓ_compiled, ℓ_grad_compiled = LogDensityProblems.logdensity_and_gradient( - f_rd_compiled, θ - ) - - @test ℓ == ℓ_compiled - @test ℓ_grad == ℓ_grad_compiled - end -end - -end diff --git a/test/ext/OptimInterface.jl b/test/ext/OptimInterface.jl index d1e77c215b..163cf36c53 100644 --- a/test/ext/OptimInterface.jl +++ b/test/ext/OptimInterface.jl @@ -137,17 +137,16 @@ using Turing # because we hit NaNs, etc. To avoid this, we set the `g_tol` and the `f_tol` to # something larger than the default. allowed_incorrect_mle = [ - DynamicPPL.TestUtils.demo_dot_assume_dot_observe, + DynamicPPL.TestUtils.demo_dot_assume_observe, DynamicPPL.TestUtils.demo_assume_index_observe, DynamicPPL.TestUtils.demo_assume_multivariate_observe, DynamicPPL.TestUtils.demo_assume_multivariate_observe_literal, DynamicPPL.TestUtils.demo_dot_assume_observe_submodel, - DynamicPPL.TestUtils.demo_dot_assume_dot_observe_matrix, - DynamicPPL.TestUtils.demo_dot_assume_matrix_dot_observe_matrix, + DynamicPPL.TestUtils.demo_dot_assume_observe_matrix_index, DynamicPPL.TestUtils.demo_assume_submodel_observe_index_literal, DynamicPPL.TestUtils.demo_dot_assume_observe_index, DynamicPPL.TestUtils.demo_dot_assume_observe_index_literal, - DynamicPPL.TestUtils.demo_assume_matrix_dot_observe_matrix, + DynamicPPL.TestUtils.demo_assume_matrix_observe_matrix_index, ] @testset "MLE for $(model.f)" for model in DynamicPPL.TestUtils.DEMO_MODELS result_true = DynamicPPL.TestUtils.likelihood_optima(model) diff --git a/test/mcmc/Inference.jl b/test/mcmc/Inference.jl index 62963b4c45..fac3a2f402 100644 --- a/test/mcmc/Inference.jl +++ b/test/mcmc/Inference.jl @@ -72,7 +72,7 @@ using Turing # run sampler: progress logging should be disabled and # it should return a Chains object - sampler = Sampler(HMC(0.1, 7; adtype=adbackend), gdemo_default) + sampler = Sampler(HMC(0.1, 7; adtype=adbackend)) chains = sample(StableRNG(seed), gdemo_default, sampler, MCMCThreads(), 10, 4) @test chains isa MCMCChains.Chains end @@ -512,7 +512,7 @@ using Turing @model function vdemo2(x) μ ~ MvNormal(zeros(size(x, 1)), I) - return x .~ MvNormal(μ, I) + return x ~ filldist(MvNormal(μ, I), size(x, 2)) end D = 2 @@ -560,7 +560,7 @@ using Turing @model function vdemo7() x = Array{Real}(undef, N, N) - return x .~ [InverseGamma(2, 3) for i in 1:N] + return x ~ filldist(InverseGamma(2, 3), N, N) end sample(StableRNG(seed), vdemo7(), alg, 10) diff --git a/test/mcmc/abstractmcmc.jl b/test/mcmc/abstractmcmc.jl index 6486a86285..82baa41197 100644 --- a/test/mcmc/abstractmcmc.jl +++ b/test/mcmc/abstractmcmc.jl @@ -8,7 +8,6 @@ using DynamicPPL: DynamicPPL using ForwardDiff: ForwardDiff using LinearAlgebra: I using LogDensityProblems: LogDensityProblems -using LogDensityProblemsAD: LogDensityProblemsAD using Random: Random using ReverseDiff: ReverseDiff using StableRNGs: StableRNG @@ -18,16 +17,12 @@ using Turing using Turing.Inference: AdvancedHMC function initialize_nuts(model::Turing.Model) - # Create a log-density function with an implementation of the - # gradient so we ensure that we're using the same AD backend as in Turing. - f = LogDensityProblemsAD.ADgradient(DynamicPPL.LogDensityFunction(model)) - - # Link the varinfo. - f = Turing.Inference.setvarinfo( - f, - DynamicPPL.link!!(Turing.Inference.getvarinfo(f), model), - Turing.Inference.getADType(DynamicPPL.getcontext(LogDensityProblemsAD.parent(f))), - ) + # Create a linked varinfo + vi = DynamicPPL.VarInfo(model) + linked_vi = DynamicPPL.link!!(vi, model) + + # Create a LogDensityFunction + f = DynamicPPL.LogDensityFunction(model, linked_vi; adtype=Turing.DEFAULT_ADTYPE) # Choose parameter dimensionality and initial parameter value D = LogDensityProblems.dimension(f) @@ -122,7 +117,7 @@ end # TODO: Remove this once the constructors in the respective packages become "lazy". sampler = initialize_nuts(model) sampler_ext = DynamicPPL.Sampler( - externalsampler(sampler; adtype, unconstrained=true), model + externalsampler(sampler; adtype, unconstrained=true) ) # FIXME: Once https://github.com/TuringLang/AdvancedHMC.jl/pull/366 goes through, uncomment. # @testset "initial_params" begin @@ -148,27 +143,6 @@ end end end end - - @testset "don't drop `ADgradient` (PR: #2223)" begin - rng = Random.default_rng() - model = DynamicPPL.TestUtils.DEMO_MODELS[1] - sampler = initialize_nuts(model) - sampler_ext = externalsampler( - sampler; unconstrained=true, adtype=AutoForwardDiff() - ) - # Initial step. - state = last( - AbstractMCMC.step(rng, model, DynamicPPL.Sampler(sampler_ext); n_adapts=0) - ) - @test state.logdensity isa LogDensityProblemsAD.ADGradientWrapper - # Subsequent step. - state = last( - AbstractMCMC.step( - rng, model, DynamicPPL.Sampler(sampler_ext), state; n_adapts=0 - ), - ) - @test state.logdensity isa LogDensityProblemsAD.ADGradientWrapper - end end @testset "AdvancedMH.jl" begin @@ -178,7 +152,7 @@ end # TODO: Remove this once the constructors in the respective packages become "lazy". sampler = initialize_mh_rw(model) sampler_ext = DynamicPPL.Sampler( - externalsampler(sampler; unconstrained=true), model + externalsampler(sampler; unconstrained=true) ) @testset "initial_params" begin test_initial_params(model, sampler_ext) @@ -201,7 +175,7 @@ end # @testset "MH with prior proposal" begin # @testset "$(model.f)" for model in DynamicPPL.TestUtils.DEMO_MODELS # sampler = initialize_mh_with_prior_proposal(model); - # sampler_ext = DynamicPPL.Sampler(externalsampler(sampler; unconstrained=false), model) + # sampler_ext = DynamicPPL.Sampler(externalsampler(sampler; unconstrained=false)) # @testset "initial_params" begin # test_initial_params(model, sampler_ext) # end diff --git a/test/mcmc/emcee.jl b/test/mcmc/emcee.jl index 08ea16d2a8..49ce75ac97 100644 --- a/test/mcmc/emcee.jl +++ b/test/mcmc/emcee.jl @@ -17,7 +17,7 @@ using Turing n_walkers = 250 spl = Emcee(n_walkers, 2.0) - @test DynamicPPL.alg_str(Sampler(spl, gdemo_default)) == "Emcee" + @test DynamicPPL.alg_str(Sampler(spl)) == "Emcee" chain = sample(gdemo_default, spl, n_samples) check_gdemo(chain) diff --git a/test/mcmc/ess.jl b/test/mcmc/ess.jl index 4675f61e20..7f47e4b127 100644 --- a/test/mcmc/ess.jl +++ b/test/mcmc/ess.jl @@ -30,7 +30,7 @@ using Turing N = 10 s1 = ESS() - @test DynamicPPL.alg_str(Sampler(s1, demo_default)) == "ESS" + @test DynamicPPL.alg_str(Sampler(s1)) == "ESS" c1 = sample(demo_default, s1, N) c2 = sample(demodot_default, s1, N) diff --git a/test/mcmc/gibbs.jl b/test/mcmc/gibbs.jl index 58db233f8b..5b0feab34e 100644 --- a/test/mcmc/gibbs.jl +++ b/test/mcmc/gibbs.jl @@ -40,7 +40,7 @@ const DEMO_MODELS_WITHOUT_DOT_ASSUME = Union{ DynamicPPL.Model{typeof(DynamicPPL.TestUtils.demo_assume_multivariate_observe_literal)}, DynamicPPL.Model{typeof(DynamicPPL.TestUtils.demo_assume_observe_literal)}, DynamicPPL.Model{typeof(DynamicPPL.TestUtils.demo_assume_dot_observe_literal)}, - DynamicPPL.Model{typeof(DynamicPPL.TestUtils.demo_assume_matrix_dot_observe_matrix)}, + DynamicPPL.Model{typeof(DynamicPPL.TestUtils.demo_assume_matrix_observe_matrix_index)}, } has_dot_assume(::DEMO_MODELS_WITHOUT_DOT_ASSUME) = false has_dot_assume(::DynamicPPL.Model) = true @@ -90,7 +90,7 @@ has_dot_assume(::DynamicPPL.Model) = true end end - # Check the type stability also in the dot_tilde pipeline. + # Check the type stability also when using .~. for k in all_varnames # The map(identity, ...) part is there to concretise the eltype. subkeys = map( @@ -145,7 +145,7 @@ end end unwrap_sampler(sampler::DynamicPPL.Sampler{<:AlgWrapper}) = - DynamicPPL.Sampler(sampler.alg.inner, sampler.selector) + DynamicPPL.Sampler(sampler.alg.inner) # Methods we need to define to be able to use AlgWrapper instead of an actual algorithm. # They all just propagate the call to the inner algorithm. @@ -295,7 +295,7 @@ end @varname(m) => RepeatSampler(PG(10), 2), ) for s in (s1, s2, s3, s4, s5, s6) - @test DynamicPPL.alg_str(Turing.Sampler(s, gdemo_default)) == "Gibbs" + @test DynamicPPL.alg_str(Turing.Sampler(s)) == "Gibbs" end @test sample(gdemo_default, s1, N) isa MCMCChains.Chains @@ -305,7 +305,7 @@ end @test sample(gdemo_default, s5, N) isa MCMCChains.Chains @test sample(gdemo_default, s6, N) isa MCMCChains.Chains - g = Turing.Sampler(s3, gdemo_default) + g = Turing.Sampler(s3) @test sample(gdemo_default, g, N) isa MCMCChains.Chains end diff --git a/test/mcmc/hmc.jl b/test/mcmc/hmc.jl index 3afe1332c7..718b3cfe3f 100644 --- a/test/mcmc/hmc.jl +++ b/test/mcmc/hmc.jl @@ -155,11 +155,11 @@ using Turing @testset "hmcda constructor" begin alg = HMCDA(0.8, 0.75; adtype=adbackend) - sampler = Sampler(alg, gdemo_default) + sampler = Sampler(alg) @test DynamicPPL.alg_str(sampler) == "HMCDA" alg = HMCDA(200, 0.8, 0.75; adtype=adbackend) - sampler = Sampler(alg, gdemo_default) + sampler = Sampler(alg) @test DynamicPPL.alg_str(sampler) == "HMCDA" @test isa(alg, HMCDA) @@ -174,11 +174,11 @@ using Turing @testset "nuts constructor" begin alg = NUTS(200, 0.65; adtype=adbackend) - sampler = Sampler(alg, gdemo_default) + sampler = Sampler(alg) @test DynamicPPL.alg_str(sampler) == "NUTS" alg = NUTS(0.65; adtype=adbackend) - sampler = Sampler(alg, gdemo_default) + sampler = Sampler(alg) @test DynamicPPL.alg_str(sampler) == "NUTS" end @@ -218,7 +218,7 @@ using Turing # https://github.com/TuringLang/Turing.jl/issues/1308 @model function mwe3(::Type{T}=Array{Float64}) where {T} m = T(undef, 2, 3) - return m .~ MvNormal(zeros(2), I) + return m ~ filldist(MvNormal(zeros(2), I), 3) end @test sample(StableRNG(seed), mwe3(), HMC(0.2, 4; adtype=adbackend), 100) isa Chains end @@ -327,7 +327,7 @@ using Turing algs = [HMC(0.1, 10), HMCDA(0.8, 0.75), NUTS(0.5), NUTS(0, 0.5)] @testset "$(alg)" for alg in algs # Construct a HMC state by taking a single step - spl = Sampler(alg, gdemo_default) + spl = Sampler(alg) hmc_state = DynamicPPL.initialstep( Random.default_rng(), gdemo_default, spl, DynamicPPL.VarInfo(gdemo_default) )[2] diff --git a/test/mcmc/mh.jl b/test/mcmc/mh.jl index 69cf5a849b..d190e589a5 100644 --- a/test/mcmc/mh.jl +++ b/test/mcmc/mh.jl @@ -28,7 +28,7 @@ GKernel(var) = (x) -> Normal(x, sqrt.(var)) s3 = MH() s4 = MH([1.0 0.1; 0.1 1.0]) for s in (s1, s2, s3, s4) - @test DynamicPPL.alg_str(Sampler(s, gdemo_default)) == "MH" + @test DynamicPPL.alg_str(Sampler(s)) == "MH" end c1 = sample(gdemo_default, s1, N) @@ -116,7 +116,7 @@ GKernel(var) = (x) -> Normal(x, sqrt.(var)) end model = M(zeros(2), I, 1) - sampler = Inference.Sampler(MH(), model) + sampler = Inference.Sampler(MH()) dt, vt = Inference.dist_val_tuple(sampler, Turing.VarInfo(model)) @@ -234,22 +234,22 @@ GKernel(var) = (x) -> Normal(x, sqrt.(var)) alg = MH() spl = DynamicPPL.Sampler(alg) vi = Turing.Inference.maybe_link!!(vi, spl, alg.proposals, gdemo_default) - @test !DynamicPPL.islinked(vi, spl) + @test !DynamicPPL.islinked(vi) # Link if proposal is `AdvancedHM.RandomWalkProposal` vi = deepcopy(vi_base) - d = length(vi_base[DynamicPPL.SampleFromPrior()]) + d = length(vi_base[:]) alg = MH(AdvancedMH.RandomWalkProposal(MvNormal(zeros(d), I))) spl = DynamicPPL.Sampler(alg) vi = Turing.Inference.maybe_link!!(vi, spl, alg.proposals, gdemo_default) - @test DynamicPPL.islinked(vi, spl) + @test DynamicPPL.islinked(vi) # Link if ALL proposals are `AdvancedHM.RandomWalkProposal`. vi = deepcopy(vi_base) alg = MH(:s => AdvancedMH.RandomWalkProposal(Normal())) spl = DynamicPPL.Sampler(alg) vi = Turing.Inference.maybe_link!!(vi, spl, alg.proposals, gdemo_default) - @test DynamicPPL.islinked(vi, spl) + @test DynamicPPL.islinked(vi) # Don't link if at least one proposal is NOT `RandomWalkProposal`. # TODO: make it so that only those that are using `RandomWalkProposal` @@ -262,7 +262,7 @@ GKernel(var) = (x) -> Normal(x, sqrt.(var)) ) spl = DynamicPPL.Sampler(alg) vi = Turing.Inference.maybe_link!!(vi, spl, alg.proposals, gdemo_default) - @test !DynamicPPL.islinked(vi, spl) + @test !DynamicPPL.islinked(vi) end @testset "prior" begin diff --git a/test/optimisation/Optimisation.jl b/test/optimisation/Optimisation.jl index cc9ab8c874..5ec7afae40 100644 --- a/test/optimisation/Optimisation.jl +++ b/test/optimisation/Optimisation.jl @@ -539,17 +539,16 @@ using Turing # because we hit NaNs, etc. To avoid this, we set the `g_tol` and the `f_tol` to # something larger than the default. allowed_incorrect_mle = [ - DynamicPPL.TestUtils.demo_dot_assume_dot_observe, + DynamicPPL.TestUtils.demo_dot_assume_observe, DynamicPPL.TestUtils.demo_assume_index_observe, DynamicPPL.TestUtils.demo_assume_multivariate_observe, DynamicPPL.TestUtils.demo_assume_multivariate_observe_literal, DynamicPPL.TestUtils.demo_dot_assume_observe_submodel, - DynamicPPL.TestUtils.demo_dot_assume_dot_observe_matrix, - DynamicPPL.TestUtils.demo_dot_assume_matrix_dot_observe_matrix, + DynamicPPL.TestUtils.demo_dot_assume_observe_matrix_index, DynamicPPL.TestUtils.demo_assume_submodel_observe_index_literal, DynamicPPL.TestUtils.demo_dot_assume_observe_index, DynamicPPL.TestUtils.demo_dot_assume_observe_index_literal, - DynamicPPL.TestUtils.demo_assume_matrix_dot_observe_matrix, + DynamicPPL.TestUtils.demo_assume_matrix_observe_matrix_index, ] @testset "MLE for $(model.f)" for model in DynamicPPL.TestUtils.DEMO_MODELS Random.seed!(23) @@ -624,16 +623,9 @@ using Turing m = DynamicPPL.contextualize( gdemo_default, ADUtils.ADTypeCheckContext(adbackend, gdemo_default.context) ) - if adbackend isa AutoForwardDiff - # TODO: Figure out why this is happening. - # https://github.com/TuringLang/Turing.jl/issues/2369 - @test_throws DivideError maximum_likelihood(m; adtype=adbackend) - @test_throws DivideError maximum_a_posteriori(m; adtype=adbackend) - else - # These will error if the adbackend being used is not the one set. - maximum_likelihood(m; adtype=adbackend) - maximum_a_posteriori(m; adtype=adbackend) - end + # These will error if the adbackend being used is not the one set. + maximum_likelihood(m; adtype=adbackend) + maximum_a_posteriori(m; adtype=adbackend) end end diff --git a/test/runtests.jl b/test/runtests.jl index 093615e540..0a948a317e 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -39,7 +39,6 @@ end end @testset "essential" verbose = true begin - @timeit_include("essential/ad.jl") @timeit_include("essential/container.jl") end diff --git a/test/skipped/unit_test_helper.jl b/test/skipped/unit_test_helper.jl index 174234480e..aa513e428e 100644 --- a/test/skipped/unit_test_helper.jl +++ b/test/skipped/unit_test_helper.jl @@ -11,7 +11,9 @@ function test_grad(turing_model, grad_f; trans=Dict()) ℓ = LogDensityProblemsAD.ADgradient( Turing.AutoTracker(), Turing.LogDensityFunction( - vi, model_f, SampleFromPrior(), DynamicPPL.DefaultContext() + model_f, + vi, + DynamicPPL.SamplingContext(SampleFromPrior(), DynamicPPL.DefaultContext()), ), ) for _ in 1:10000 diff --git a/test/test_utils/ad_utils.jl b/test/test_utils/ad_utils.jl index 2c01dc524e..ee544e7ce3 100644 --- a/test/test_utils/ad_utils.jl +++ b/test/test_utils/ad_utils.jl @@ -195,40 +195,6 @@ function DynamicPPL.tilde_observe(context::ADTypeCheckContext, sampler, right, l return logp, vi end -function DynamicPPL.dot_tilde_assume(context::ADTypeCheckContext, right, left, vn, vi) - value, logp, vi = DynamicPPL.dot_tilde_assume( - DynamicPPL.childcontext(context), right, left, vn, vi - ) - check_adtype(context, vi) - return value, logp, vi -end - -function DynamicPPL.dot_tilde_assume( - rng::Random.AbstractRNG, context::ADTypeCheckContext, sampler, right, left, vn, vi -) - value, logp, vi = DynamicPPL.dot_tilde_assume( - rng, DynamicPPL.childcontext(context), sampler, right, left, vn, vi - ) - check_adtype(context, vi) - return value, logp, vi -end - -function DynamicPPL.dot_tilde_observe(context::ADTypeCheckContext, right, left, vi) - logp, vi = DynamicPPL.dot_tilde_observe( - DynamicPPL.childcontext(context), right, left, vi - ) - check_adtype(context, vi) - return logp, vi -end - -function DynamicPPL.dot_tilde_observe(context::ADTypeCheckContext, sampler, right, left, vi) - logp, vi = DynamicPPL.dot_tilde_observe( - DynamicPPL.childcontext(context), sampler, right, left, vi - ) - check_adtype(context, vi) - return logp, vi -end - # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # List of AD backends to test. @@ -236,7 +202,7 @@ end All the ADTypes on which we want to run the tests. """ adbackends = [ - Turing.AutoForwardDiff(; chunksize=0), + Turing.AutoForwardDiff(), Turing.AutoReverseDiff(; compile=false), Turing.AutoMooncake(; config=nothing), ]