Rename {Prior,Uniform,Params}Init -> InitFrom{Prior,Uniform,Params}

Author: penelopeysm

docs/src/api.md

@@ -474,9 +474,9 @@ To accomplish this, an initialisation _strategy_ is required, which defines how
 There are three concrete strategies provided in DynamicPPL:
 
 ```@docs
-PriorInit
-UniformInit
-ParamsInit
+InitFromPrior
+InitFromUniform
+InitFromParams
 ```
 
 If you wish to write your own, you have to subtype [`DynamicPPL.AbstractInitStrategy`](@ref) and implement the `init` method.

src/DynamicPPL.jl

@@ -111,9 +111,9 @@ export AbstractVarInfo,
     # Initialisation
     InitContext,
     AbstractInitStrategy,
-    PriorInit,
-    UniformInit,
-    ParamsInit,
+    InitFromPrior,
+    InitFromUniform,
+    InitFromParams,
     # Pseudo distributions
     NamedDist,
     NoDist,

src/contexts/init.jl

@@ -17,22 +17,24 @@ Generate a new value for a random variable with the given distribution.
 !!! warning "Return values must be unlinked"
     The values returned by `init` must always be in the untransformed space, i.e.,
     they must be within the support of the original distribution. That means that,
-    for example, `init(rng, dist, u::UniformInit)` will in general return values that
+    for example, `init(rng, dist, u::InitFromUniform)` will in general return values that
     are outside the range [u.lower, u.upper].
 """
 function init end
 
 """
-    PriorInit()
+    InitFromPrior()
 
 Obtain new values by sampling from the prior distribution.
 """
-struct PriorInit <: AbstractInitStrategy end
-init(rng::Random.AbstractRNG, ::VarName, dist::Distribution, ::PriorInit) = rand(rng, dist)
+struct InitFromPrior <: AbstractInitStrategy end
+function init(rng::Random.AbstractRNG, ::VarName, dist::Distribution, ::InitFromPrior)
+    return rand(rng, dist)
+end
 
 """
-    UniformInit()
-    UniformInit(lower, upper)
+    InitFromUniform()
+    InitFromUniform(lower, upper)
 
 Obtain new values by first transforming the distribution of the random variable
 to unconstrained space, then sampling a value uniformly between `lower` and
@@ -47,17 +49,17 @@ Requires that `lower <= upper`.
 
 [Stan reference manual page on initialization](https://mc-stan.org/docs/reference-manual/execution.html#initialization)
 """
-struct UniformInit{T<:AbstractFloat} <: AbstractInitStrategy
+struct InitFromUniform{T<:AbstractFloat} <: AbstractInitStrategy
     lower::T
     upper::T
-    function UniformInit(lower::T, upper::T) where {T<:AbstractFloat}
+    function InitFromUniform(lower::T, upper::T) where {T<:AbstractFloat}
         lower > upper &&
             throw(ArgumentError("`lower` must be less than or equal to `upper`"))
         return new{T}(lower, upper)
     end
-    UniformInit() = UniformInit(-2.0, 2.0)
+    InitFromUniform() = InitFromUniform(-2.0, 2.0)
 end
-function init(rng::Random.AbstractRNG, ::VarName, dist::Distribution, u::UniformInit)
+function init(rng::Random.AbstractRNG, ::VarName, dist::Distribution, u::InitFromUniform)
     b = Bijectors.bijector(dist)
     sz = Bijectors.output_size(b, size(dist))
     y = u.lower .+ ((u.upper - u.lower) .* rand(rng, sz...))
@@ -71,9 +73,9 @@ function init(rng::Random.AbstractRNG, ::VarName, dist::Distribution, u::Uniform
 end
 
 """
-    ParamsInit(
+    InitFromParams(
         params::Union{AbstractDict{<:VarName},NamedTuple},
-        fallback::Union{AbstractInitStrategy,Nothing}=PriorInit()
+        fallback::Union{AbstractInitStrategy,Nothing}=InitFromPrior()
     )
 
 Obtain new values by extracting them from the given dictionary or NamedTuple.
@@ -82,28 +84,30 @@ The parameter `fallback` specifies how new values are to be obtained if they
 cannot be found in `params`, or they are specified as `missing`. `fallback`
 can either be an initialisation strategy itself, in which case it will be
 used to obtain new values, or it can be `nothing`, in which case an error
-will be thrown. The default for `fallback` is `PriorInit()`.
+will be thrown. The default for `fallback` is `InitFromPrior()`.
 
 !!! note
     The values in `params` must be provided in the space of the untransformed
-distribution.
+    distribution.
 """
-struct ParamsInit{P,S<:Union{AbstractInitStrategy,Nothing}} <: AbstractInitStrategy
+struct InitFromParams{P,S<:Union{AbstractInitStrategy,Nothing}} <: AbstractInitStrategy
     params::P
     fallback::S
-    function ParamsInit(
+    function InitFromParams(
         params::AbstractDict{<:VarName}, fallback::Union{AbstractInitStrategy,Nothing}
     )
         return new{typeof(params),typeof(fallback)}(params, fallback)
     end
-    ParamsInit(params::AbstractDict{<:VarName}) = ParamsInit(params, PriorInit())
-    function ParamsInit(
-        params::NamedTuple, fallback::Union{AbstractInitStrategy,Nothing}=PriorInit()
+    function InitFromParams(params::AbstractDict{<:VarName})
+        return InitFromParams(params, InitFromPrior())
+    end
+    function InitFromParams(
+        params::NamedTuple, fallback::Union{AbstractInitStrategy,Nothing}=InitFromPrior()
     )
-        return ParamsInit(to_varname_dict(params), fallback)
+        return InitFromParams(to_varname_dict(params), fallback)
     end
 end
-function init(rng::Random.AbstractRNG, vn::VarName, dist::Distribution, p::ParamsInit)
+function init(rng::Random.AbstractRNG, vn::VarName, dist::Distribution, p::InitFromParams)
     # TODO(penelopeysm): It would be nice to do a check to make sure that all
     # of the parameters in `p.params` were actually used, and either warn or
     # error if they aren't. This is actually quite non-trivial though because
@@ -128,7 +132,7 @@ end
 """
     InitContext(
             [rng::Random.AbstractRNG=Random.default_rng()],
-            [strategy::AbstractInitStrategy=PriorInit()],
+            [strategy::AbstractInitStrategy=InitFromPrior()],
     )
 
 A leaf context that indicates that new values for random variables are
@@ -140,11 +144,11 @@ struct InitContext{R<:Random.AbstractRNG,S<:AbstractInitStrategy} <: AbstractCon
     rng::R
     strategy::S
     function InitContext(
-        rng::Random.AbstractRNG, strategy::AbstractInitStrategy=PriorInit()
+        rng::Random.AbstractRNG, strategy::AbstractInitStrategy=InitFromPrior()
     )
         return new{typeof(rng),typeof(strategy)}(rng, strategy)
     end
-    function InitContext(strategy::AbstractInitStrategy=PriorInit())
+    function InitContext(strategy::AbstractInitStrategy=InitFromPrior())
         return InitContext(Random.default_rng(), strategy)
     end
 end

src/model.jl

@@ -894,30 +894,32 @@ end
         [rng::Random.AbstractRNG,]
         model::Model,
         varinfo::AbstractVarInfo,
-        [init_strategy::AbstractInitStrategy=PriorInit()]
+        [init_strategy::AbstractInitStrategy=InitFromPrior()]
     )
 
 Evaluate the `model` and replace the values of the model's random variables in
 the given `varinfo` with new values using a specified initialisation strategy.
 If the values in `varinfo` are not already present, they will be added using
 that same strategy.
 
-If `init_strategy` is not provided, defaults to PriorInit().
+If `init_strategy` is not provided, defaults to InitFromPrior().
 
 Returns a tuple of the model's return value, plus the updated `varinfo` object.
 """
 function init!!(
     rng::Random.AbstractRNG,
     model::Model,
     varinfo::AbstractVarInfo,
-    init_strategy::AbstractInitStrategy=PriorInit(),
+    init_strategy::AbstractInitStrategy=InitFromPrior(),
 )
     new_context = setleafcontext(model.context, InitContext(rng, init_strategy))
     new_model = contextualize(model, new_context)
     return evaluate!!(new_model, varinfo)
 end
 function init!!(
-    model::Model, varinfo::AbstractVarInfo, init_strategy::AbstractInitStrategy=PriorInit()
+    model::Model,
+    varinfo::AbstractVarInfo,
+    init_strategy::AbstractInitStrategy=InitFromPrior(),
 )
     return init!!(Random.default_rng(), model, varinfo, init_strategy)
 end

test/contexts.jl

@@ -537,36 +537,36 @@ Base.IteratorEltype(::Type{<:AbstractContext}) = Base.EltypeUnknown()
             end
         end
 
-        @testset "PriorInit" begin
-            test_generating_new_values(PriorInit())
-            test_replacing_values(PriorInit())
-            test_rng_respected(PriorInit())
-            test_link_status_respected(PriorInit())
+        @testset "InitFromPrior" begin
+            test_generating_new_values(InitFromPrior())
+            test_replacing_values(InitFromPrior())
+            test_rng_respected(InitFromPrior())
+            test_link_status_respected(InitFromPrior())
 
             @testset "check that values are within support" begin
                 # Not many other sensible checks we can do for priors.
                 @model just_unif() = x ~ Uniform(0.0, 1e-7)
                 for _ in 1:100
-                    _, vi = DynamicPPL.init!!(just_unif(), VarInfo(), PriorInit())
+                    _, vi = DynamicPPL.init!!(just_unif(), VarInfo(), InitFromPrior())
                     @test vi[@varname(x)] isa Real
                     @test 0.0 <= vi[@varname(x)] <= 1e-7
                 end
             end
         end
 
-        @testset "UniformInit" begin
-            test_generating_new_values(UniformInit())
-            test_replacing_values(UniformInit())
-            test_rng_respected(UniformInit())
-            test_link_status_respected(UniformInit())
+        @testset "InitFromUniform" begin
+            test_generating_new_values(InitFromUniform())
+            test_replacing_values(InitFromUniform())
+            test_rng_respected(InitFromUniform())
+            test_link_status_respected(InitFromUniform())
 
             @testset "check that bounds are respected" begin
                 @testset "unconstrained" begin
                     umin, umax = -1.0, 1.0
                     @model just_norm() = x ~ Normal()
                     for _ in 1:100
                         _, vi = DynamicPPL.init!!(
-                            just_norm(), VarInfo(), UniformInit(umin, umax)
+                            just_norm(), VarInfo(), InitFromUniform(umin, umax)
                         )
                         @test vi[@varname(x)] isa Real
                         @test umin <= vi[@varname(x)] <= umax
@@ -579,7 +579,7 @@ Base.IteratorEltype(::Type{<:AbstractContext}) = Base.EltypeUnknown()
                     tmin, tmax = inv_bijector(umin), inv_bijector(umax)
                     for _ in 1:100
                         _, vi = DynamicPPL.init!!(
-                            just_beta(), VarInfo(), UniformInit(umin, umax)
+                            just_beta(), VarInfo(), InitFromUniform(umin, umax)
                         )
                         @test vi[@varname(x)] isa Real
                         @test tmin <= vi[@varname(x)] <= tmax
@@ -588,9 +588,9 @@ Base.IteratorEltype(::Type{<:AbstractContext}) = Base.EltypeUnknown()
             end
         end
 
-        @testset "ParamsInit" begin
-            test_link_status_respected(ParamsInit((; a=1.0)))
-            test_link_status_respected(ParamsInit(Dict(@varname(a) => 1.0)))
+        @testset "InitFromParams" begin
+            test_link_status_respected(InitFromParams((; a=1.0)))
+            test_link_status_respected(InitFromParams(Dict(@varname(a) => 1.0)))
 
             @testset "given full set of parameters" begin
                 # test_init_model has x ~ Normal() and y ~ MvNormal(zeros(2), I)
@@ -600,13 +600,13 @@ Base.IteratorEltype(::Type{<:AbstractContext}) = Base.EltypeUnknown()
                 model = test_init_model()
                 @testset "$vi_name" for (vi_name, empty_vi) in empty_varinfos
                     _, vi = DynamicPPL.init!!(
-                        model, deepcopy(empty_vi), ParamsInit(params_nt)
+                        model, deepcopy(empty_vi), InitFromParams(params_nt)
                     )
                     @test vi[@varname(x)] == my_x
                     @test vi[@varname(y)] == my_y
                     logp_nt = getlogp(vi)
                     _, vi = DynamicPPL.init!!(
-                        model, deepcopy(empty_vi), ParamsInit(params_dict)
+                        model, deepcopy(empty_vi), InitFromParams(params_dict)
                     )
                     @test vi[@varname(x)] == my_x
                     @test vi[@varname(y)] == my_y
@@ -621,12 +621,12 @@ Base.IteratorEltype(::Type{<:AbstractContext}) = Base.EltypeUnknown()
                 params_dict = Dict(@varname(x) => my_x)
                 model = test_init_model()
                 @testset "$vi_name" for (vi_name, empty_vi) in empty_varinfos
-                    @testset "with PriorInit fallback" begin
+                    @testset "with InitFromPrior fallback" begin
                         _, vi = DynamicPPL.init!!(
                             Xoshiro(468),
                             model,
                             deepcopy(empty_vi),
-                            ParamsInit(params_nt, PriorInit()),
+                            InitFromParams(params_nt, InitFromPrior()),
                         )
                         @test vi[@varname(x)] == my_x
                         nt_y = vi[@varname(y)]
@@ -636,7 +636,7 @@ Base.IteratorEltype(::Type{<:AbstractContext}) = Base.EltypeUnknown()
                             Xoshiro(469),
                             model,
                             deepcopy(empty_vi),
-                            ParamsInit(params_dict, PriorInit()),
+                            InitFromParams(params_dict, InitFromPrior()),
                         )
                         @test vi[@varname(x)] == my_x
                         dict_y = vi[@varname(y)]
@@ -649,10 +649,10 @@ Base.IteratorEltype(::Type{<:AbstractContext}) = Base.EltypeUnknown()
                     @testset "with no fallback" begin
                         # These just don't have an entry for `y`.
                         @test_throws ErrorException DynamicPPL.init!!(
-                            model, deepcopy(empty_vi), ParamsInit(params_nt, nothing)
+                            model, deepcopy(empty_vi), InitFromParams(params_nt, nothing)
                         )
                         @test_throws ErrorException DynamicPPL.init!!(
-                            model, deepcopy(empty_vi), ParamsInit(params_dict, nothing)
+                            model, deepcopy(empty_vi), InitFromParams(params_dict, nothing)
                         )
                         # We also explicitly test the case where `y = missing`.
                         params_nt_missing = (; x=my_x, y=missing)
@@ -662,12 +662,12 @@ Base.IteratorEltype(::Type{<:AbstractContext}) = Base.EltypeUnknown()
                         @test_throws ErrorException DynamicPPL.init!!(
                             model,
                             deepcopy(empty_vi),
-                            ParamsInit(params_nt_missing, nothing),
+                            InitFromParams(params_nt_missing, nothing),
                         )
                         @test_throws ErrorException DynamicPPL.init!!(
                             model,
                             deepcopy(empty_vi),
-                            ParamsInit(params_dict_missing, nothing),
+                            InitFromParams(params_dict_missing, nothing),
                         )
                     end
                 end