Rename FooInit -> InitFromFoo

Author: penelopeysm

ext/DynamicPPLMCMCChainsExt.jl

@@ -130,7 +130,7 @@ function DynamicPPL.predict(
             rng,
             model,
             varinfo,
-            DynamicPPL.ParamsInit(values_dict, DynamicPPL.PriorInit()),
+            DynamicPPL.InitFromParams(values_dict, DynamicPPL.InitFromPrior()),
         )
         vals = DynamicPPL.values_as_in_model(model, false, varinfo)
         varname_vals = mapreduce(
@@ -268,7 +268,9 @@ function DynamicPPL.returned(model::DynamicPPL.Model, chain_full::MCMCChains.Cha
         # Resample any variables that are not present in `values_dict`, and
         # return the model's retval.
         retval, _ = DynamicPPL.init!!(
-            model, varinfo, DynamicPPL.ParamsInit(values_dict, DynamicPPL.PriorInit())
+            model,
+            varinfo,
+            DynamicPPL.InitFromParams(values_dict, DynamicPPL.InitFromPrior()),
         )
         retval
     end

src/sampler.jl

@@ -58,7 +58,7 @@ function AbstractMCMC.step(
     kwargs...,
 )
     vi = VarInfo()
-    strategy = sampler isa SampleFromPrior ? PriorInit() : UniformInit()
+    strategy = sampler isa SampleFromPrior ? InitFromPrior() : InitFromUniform()
     _, new_vi = DynamicPPL.init!!(rng, model, vi, strategy)
     return new_vi, nothing
 end
@@ -103,9 +103,9 @@ end
     init_strategy(sampler)
 
 Define the initialisation strategy used for generating initial values when
-sampling with `sampler`. Defaults to `PriorInit()`, but can be overridden.
+sampling with `sampler`. Defaults to `InitFromPrior()`, but can be overridden.
 """
-init_strategy(::Sampler) = PriorInit()
+init_strategy(::Sampler) = InitFromPrior()
 
 function AbstractMCMC.step(
     rng::Random.AbstractRNG,
@@ -118,7 +118,7 @@ function AbstractMCMC.step(
     # with NamedTuple of Metadata).
     vi = default_varinfo(rng, model, spl)
 
-    # Fill it with initial parameters. Note that, if `ParamsInit` is used, the
+    # Fill it with initial parameters. Note that, if `InitFromParams` is used, the
     # parameters provided must be in unlinked space (when inserted into the
     # varinfo, they will be adjusted to match the linking status of the
     # varinfo).

src/simple_varinfo.jl

@@ -232,22 +232,26 @@ end
 
 # Constructor from `Model`.
 function SimpleVarInfo{T}(
-    rng::Random.AbstractRNG, model::Model, init_strategy::AbstractInitStrategy=PriorInit()
+    rng::Random.AbstractRNG,
+    model::Model,
+    init_strategy::AbstractInitStrategy=InitFromPrior(),
 ) where {T<:Real}
     return last(init!!(rng, model, SimpleVarInfo{T}(), init_strategy))
 end
 function SimpleVarInfo{T}(
-    model::Model, init_strategy::AbstractInitStrategy=PriorInit()
+    model::Model, init_strategy::AbstractInitStrategy=InitFromPrior()
 ) where {T<:Real}
     return SimpleVarInfo{T}(Random.default_rng(), model, init_strategy)
 end
 # Constructors without type param
 function SimpleVarInfo(
-    rng::Random.AbstractRNG, model::Model, init_strategy::AbstractInitStrategy=PriorInit()
+    rng::Random.AbstractRNG,
+    model::Model,
+    init_strategy::AbstractInitStrategy=InitFromPrior(),
 )
     return SimpleVarInfo{LogProbType}(rng, model, init_strategy)
 end
-function SimpleVarInfo(model::Model, init_strategy::AbstractInitStrategy=PriorInit())
+function SimpleVarInfo(model::Model, init_strategy::AbstractInitStrategy=InitFromPrior())
     return SimpleVarInfo{LogProbType}(Random.default_rng(), model, init_strategy)
 end
 

src/varinfo.jl

@@ -133,11 +133,13 @@ given `rng` and `init_strategy`.
     instead.
 """
 function VarInfo(
-    rng::Random.AbstractRNG, model::Model, init_strategy::AbstractInitStrategy=PriorInit()
+    rng::Random.AbstractRNG,
+    model::Model,
+    init_strategy::AbstractInitStrategy=InitFromPrior(),
 )
     return typed_varinfo(rng, model, init_strategy)
 end
-function VarInfo(model::Model, init_strategy::AbstractInitStrategy=PriorInit())
+function VarInfo(model::Model, init_strategy::AbstractInitStrategy=InitFromPrior())
     return VarInfo(Random.default_rng(), model, init_strategy)
 end
 
@@ -207,14 +209,16 @@ Construct a VarInfo object for the given `model`, which has just a single
 # Arguments
 - `rng::Random.AbstractRNG`: The random number generator to use during model evaluation
 - `model::Model`: The model for which to create the varinfo object
-- `init_strategy::AbstractInitStrategy`: How the values are to be initialised. Defaults to `PriorInit()`.
+- `init_strategy::AbstractInitStrategy`: How the values are to be initialised. Defaults to `InitFromPrior()`.
 """
 function untyped_varinfo(
-    rng::Random.AbstractRNG, model::Model, init_strategy::AbstractInitStrategy=PriorInit()
+    rng::Random.AbstractRNG,
+    model::Model,
+    init_strategy::AbstractInitStrategy=InitFromPrior(),
 )
     return last(init!!(rng, model, VarInfo(Metadata()), init_strategy))
 end
-function untyped_varinfo(model::Model, init_strategy::AbstractInitStrategy=PriorInit())
+function untyped_varinfo(model::Model, init_strategy::AbstractInitStrategy=InitFromPrior())
     return untyped_varinfo(Random.default_rng(), model, init_strategy)
 end
 
@@ -282,14 +286,16 @@ Return a VarInfo object for the given `model`, which has a NamedTuple of
 # Arguments
 - `rng::Random.AbstractRNG`: The random number generator to use during model evaluation
 - `model::Model`: The model for which to create the varinfo object
-- `init_strategy::AbstractInitStrategy`: How the values are to be initialised. Defaults to `PriorInit()`.
+- `init_strategy::AbstractInitStrategy`: How the values are to be initialised. Defaults to `InitFromPrior()`.
 """
 function typed_varinfo(
-    rng::Random.AbstractRNG, model::Model, init_strategy::AbstractInitStrategy=PriorInit()
+    rng::Random.AbstractRNG,
+    model::Model,
+    init_strategy::AbstractInitStrategy=InitFromPrior(),
 )
     return typed_varinfo(untyped_varinfo(rng, model, init_strategy))
 end
-function typed_varinfo(model::Model, init_strategy::AbstractInitStrategy=PriorInit())
+function typed_varinfo(model::Model, init_strategy::AbstractInitStrategy=InitFromPrior())
     return typed_varinfo(Random.default_rng(), model, init_strategy)
 end
 
@@ -302,19 +308,21 @@ Return a VarInfo object for the given `model`, which has just a single
 # Arguments
 - `rng::Random.AbstractRNG`: The random number generator to use during model evaluation
 - `model::Model`: The model for which to create the varinfo object
-- `init_strategy::AbstractInitStrategy`: How the values are to be initialised. Defaults to `PriorInit()`.
+- `init_strategy::AbstractInitStrategy`: How the values are to be initialised. Defaults to `InitFromPrior()`.
 """
 function untyped_vector_varinfo(vi::UntypedVarInfo)
     md = metadata_to_varnamedvector(vi.metadata)
     return VarInfo(md, copy(vi.accs))
 end
 function untyped_vector_varinfo(
-    rng::Random.AbstractRNG, model::Model, init_strategy::AbstractInitStrategy=PriorInit()
+    rng::Random.AbstractRNG,
+    model::Model,
+    init_strategy::AbstractInitStrategy=InitFromPrior(),
 )
     return untyped_vector_varinfo(untyped_varinfo(rng, model, init_strategy))
 end
 function untyped_vector_varinfo(
-    model::Model, init_strategy::AbstractInitStrategy=PriorInit()
+    model::Model, init_strategy::AbstractInitStrategy=InitFromPrior()
 )
     return untyped_vector_varinfo(Random.default_rng(), model, init_strategy)
 end
@@ -328,7 +336,7 @@ Return a VarInfo object for the given `model`, which has a NamedTuple of
 # Arguments
 - `rng::Random.AbstractRNG`: The random number generator to use during model evaluation
 - `model::Model`: The model for which to create the varinfo object
-- `init_strategy::AbstractInitStrategy`: How the values are to be initialised. Defaults to `PriorInit()`.
+- `init_strategy::AbstractInitStrategy`: How the values are to be initialised. Defaults to `InitFromPrior()`.
 """
 function typed_vector_varinfo(vi::NTVarInfo)
     md = map(metadata_to_varnamedvector, vi.metadata)
@@ -340,11 +348,15 @@ function typed_vector_varinfo(vi::UntypedVectorVarInfo)
     return VarInfo(nt, copy(vi.accs))
 end
 function typed_vector_varinfo(
-    rng::Random.AbstractRNG, model::Model, init_strategy::AbstractInitStrategy=PriorInit()
+    rng::Random.AbstractRNG,
+    model::Model,
+    init_strategy::AbstractInitStrategy=InitFromPrior(),
 )
     return typed_vector_varinfo(untyped_vector_varinfo(rng, model, init_strategy))
 end
-function typed_vector_varinfo(model::Model, init_strategy::AbstractInitStrategy=PriorInit())
+function typed_vector_varinfo(
+    model::Model, init_strategy::AbstractInitStrategy=InitFromPrior()
+)
     return typed_vector_varinfo(Random.default_rng(), model, init_strategy)
 end
 

test/ext/DynamicPPLJETExt.jl

@@ -42,7 +42,7 @@
         @test DynamicPPL.Experimental.determine_suitable_varinfo(demo4()) isa
             DynamicPPL.NTVarInfo
         init_model = DynamicPPL.contextualize(
-            demo4(), DynamicPPL.InitContext(DynamicPPL.PriorInit())
+            demo4(), DynamicPPL.InitContext(DynamicPPL.InitFromPrior())
         )
         @test DynamicPPL.Experimental.determine_suitable_varinfo(init_model) isa
             DynamicPPL.UntypedVarInfo

test/sampler.jl

@@ -69,8 +69,8 @@
         end
 
         # initial samplers
-        DynamicPPL.init_strategy(::Sampler{OnlyInitAlgUniform}) = UniformInit()
-        @test DynamicPPL.init_strategy(Sampler(OnlyInitAlgDefault())) == PriorInit()
+        DynamicPPL.init_strategy(::Sampler{OnlyInitAlgUniform}) = InitFromUniform()
+        @test DynamicPPL.init_strategy(Sampler(OnlyInitAlgDefault())) == InitFromPrior()
 
         for alg in (OnlyInitAlgDefault(), OnlyInitAlgUniform())
             # model with one variable: initialization p = 0.2
@@ -81,7 +81,7 @@
             model = coinflip()
             sampler = Sampler(alg)
             lptrue = logpdf(Binomial(25, 0.2), 10)
-            let inits = ParamsInit((; p=0.2))
+            let inits = InitFromParams((; p=0.2))
                 chain = sample(model, sampler, 1; initial_params=inits, progress=false)
                 @test chain[1].metadata.p.vals == [0.2]
                 @test getlogjoint(chain[1]) == lptrue
@@ -109,7 +109,7 @@
             end
             model = twovars()
             lptrue = logpdf(InverseGamma(2, 3), 4) + logpdf(Normal(0, 2), -1)
-            let inits = ParamsInit((; s=4, m=-1))
+            let inits = InitFromParams((; s=4, m=-1))
                 chain = sample(model, sampler, 1; initial_params=inits, progress=false)
                 @test chain[1].metadata.s.vals == [4]
                 @test chain[1].metadata.m.vals == [-1]
@@ -133,7 +133,7 @@
             end
 
             # set only m = -1
-            for inits in (ParamsInit((; s=missing, m=-1)), ParamsInit((; m=-1)))
+            for inits in (InitFromParams((; s=missing, m=-1)), InitFromParams((; m=-1)))
                 chain = sample(model, sampler, 1; initial_params=inits, progress=false)
                 @test !ismissing(chain[1].metadata.s.vals[1])
                 @test chain[1].metadata.m.vals == [-1]

test/varinfo.jl

@@ -42,7 +42,7 @@ end
         end
         model = gdemo(1.0, 2.0)
 
-        _, vi = DynamicPPL.init!!(model, VarInfo(), UniformInit())
+        _, vi = DynamicPPL.init!!(model, VarInfo(), InitFromUniform())
         tvi = DynamicPPL.typed_varinfo(vi)
 
         meta = vi.metadata
@@ -479,18 +479,18 @@ end
         end
         model = gdemo([1.0, 1.5], [2.0, 2.5])
 
-        # Check that instantiating the model using UniformInit does not
+        # Check that instantiating the model using InitFromUniform does not
         # perform linking
-        # Note (penelopeysm): The purpose of using UniformInit specifically in
+        # Note (penelopeysm): The purpose of using InitFromUniform specifically in
         # this test is because it samples from the linked distribution i.e. in
         # unconstrained space. However, it does this not by linking the varinfo
         # but by transforming the distributions on the fly. That's why it's
         # worth specifically checking that it can do this without having to
         # change the VarInfo object.
-        # TODO(penelopeysm): Move this to UniformInit tests rather than here.
+        # TODO(penelopeysm): Move this to InitFromUniform tests rather than here.
         vi = VarInfo()
         meta = vi.metadata
-        _, vi = DynamicPPL.init!!(model, vi, UniformInit())
+        _, vi = DynamicPPL.init!!(model, vi, InitFromUniform())
         @test all(x -> !istrans(vi, x), meta.vns)
 
         # Check that linking and invlinking set the `trans` flag accordingly
@@ -554,7 +554,7 @@ end
 
         function test_linked_varinfo(model, vi)
             # vn and dist are taken from the containing scope
-            vi = last(DynamicPPL.init!!(model, vi, PriorInit()))
+            vi = last(DynamicPPL.init!!(model, vi, InitFromPrior()))
             f = DynamicPPL.from_linked_internal_transform(vi, vn, dist)
             x = f(DynamicPPL.getindex_internal(vi, vn))
             @test istrans(vi, vn)
@@ -972,7 +972,7 @@ end
         varinfo1 = DynamicPPL.link!!(VarInfo(model1), model1)
         # Calling init!! should preserve the fact that the variables are linked.
         model2 = demo(2)
-        varinfo2 = last(DynamicPPL.init!!(model2, deepcopy(varinfo1), PriorInit()))
+        varinfo2 = last(DynamicPPL.init!!(model2, deepcopy(varinfo1), InitFromPrior()))
         for vn in [@varname(x[1]), @varname(x[2])]
             @test DynamicPPL.istrans(varinfo2, vn)
         end
@@ -990,7 +990,7 @@ end
         varinfo1 = DynamicPPL.link!!(DynamicPPL.untyped_varinfo(model1), model1)
         # Calling init!! should preserve the fact that the variables are linked.
         model2 = demo_dot(2)
-        varinfo2 = last(DynamicPPL.init!!(model2, deepcopy(varinfo1), PriorInit()))
+        varinfo2 = last(DynamicPPL.init!!(model2, deepcopy(varinfo1), InitFromPrior()))
         for vn in [@varname(x), @varname(y[1])]
             @test DynamicPPL.istrans(varinfo2, vn)
         end