Rename LogPrior -> LogPriorAccumulator, and Likelihood and NumProduce

Author: mhauru

HISTORY.md

@@ -8,7 +8,7 @@
 
 This release overhauls how VarInfo objects track variables such as the log joint probability. The new approach is to use what we call accumulators: Objects that the VarInfo carries on it that may change their state at each `tilde_assume!!` and `tilde_observe!!` call based on the value of the variable in question. They replace both variables that were previously hard-coded in the `VarInfo` object (`logp` and `num_produce`) and some contexts. This brings with it a number of breaking changes:
 
-  - `PriorContext` and `LikelihoodContext` no longer exist. By default, a `VarInfo` tracks both the log prior and the log likelihood separately, and they can be accessed with `getlogprior` and `getloglikelihood`. If you want to execute a model while only accumulating one of the two (to save clock cycles), you can do so by creating a `VarInfo` that only has one accumulator in it, e.g. `varinfo = setaccs!!(varinfo, (LogPrior(),))`.
+  - `PriorContext` and `LikelihoodContext` no longer exist. By default, a `VarInfo` tracks both the log prior and the log likelihood separately, and they can be accessed with `getlogprior` and `getloglikelihood`. If you want to execute a model while only accumulating one of the two (to save clock cycles), you can do so by creating a `VarInfo` that only has one accumulator in it, e.g. `varinfo = setaccs!!(varinfo, (LogPriorAccumulator(),))`.
   - `MiniBatchContext` does not exist anymore. It can be replaced by creating and using a custom accumulator that replaces the default `LikelihoodContext`. We may introduce such an accumulator in DynamicPPL in the future, but for now you'll need to do it yourself.
   - `tilde_observe` and `observe` have been removed. `tilde_observe!!` still exists, and any contexts should modify its behaviour. We may further rework the call stack under `tilde_observe!!` in the near future.
   - `tilde_assume` no longer returns the log density of the current assumption as its second return value. We may further rework the `tilde_assume!!` call stack as well.

docs/src/api.md

@@ -356,9 +356,9 @@ AbstractAccumulator
 DynamicPPL provides the following default accumulators.
 
 ```@docs
-LogPrior
-LogLikelihood
-NumProduce
+LogPriorAccumulator
+LogLikelihoodAccumulator
+NumProduceAccumulator
 ```
 
 ### Common API

src/DynamicPPL.jl

@@ -48,9 +48,9 @@ export AbstractVarInfo,
     VarInfo,
     SimpleVarInfo,
     AbstractAccumulator,
-    LogLikelihood,
-    LogPrior,
-    NumProduce,
+    LogLikelihoodAccumulator,
+    LogPriorAccumulator,
+    NumProduceAccumulator,
     push!!,
     empty!!,
     subset,

src/abstract_varinfo.jl

@@ -194,7 +194,7 @@ Set the log of the prior probability of the parameters sampled in `vi` to `logp`
 
 See also: [`setloglikelihood!!`](@ref), [`setlogp!!`](@ref), [`getlogprior`](@ref).
 """
-setlogprior!!(vi::AbstractVarInfo, logp) = setacc!!(vi, LogPrior(logp))
+setlogprior!!(vi::AbstractVarInfo, logp) = setacc!!(vi, LogPriorAccumulator(logp))
 
 """
     setloglikelihood!!(vi::AbstractVarInfo, logp)
@@ -203,7 +203,7 @@ Set the log of the likelihood probability of the observed data sampled in `vi` t
 
 See also: [`setlogprior!!`](@ref), [`setlogp!!`](@ref), [`getloglikelihood`](@ref).
 """
-setloglikelihood!!(vi::AbstractVarInfo, logp) = setacc!!(vi, LogLikelihood(logp))
+setloglikelihood!!(vi::AbstractVarInfo, logp) = setacc!!(vi, LogLikelihoodAccumulator(logp))
 
 """
     setlogp!!(vi::AbstractVarInfo, logp::NamedTuple)
@@ -303,7 +303,7 @@ Add `logp` to the value of the log of the prior probability in `vi`.
 See also: [`accloglikelihood!!`](@ref), [`acclogp!!`](@ref), [`getlogprior`](@ref), [`setlogprior!!`](@ref).
 """
 function acclogprior!!(vi::AbstractVarInfo, logp)
-    return map_accumulator!!(acc -> acc + LogPrior(logp), vi, Val(:LogPrior))
+    return map_accumulator!!(acc -> acc + LogPriorAccumulator(logp), vi, Val(:LogPrior))
 end
 
 """
@@ -314,7 +314,9 @@ Add `logp` to the value of the log of the likelihood in `vi`.
 See also: [`accloglikelihood!!`](@ref), [`acclogp!!`](@ref), [`getloglikelihood`](@ref), [`setloglikelihood!!`](@ref).
 """
 function accloglikelihood!!(vi::AbstractVarInfo, logp)
-    return map_accumulator!!(acc -> acc + LogLikelihood(logp), vi, Val(:LogLikelihood))
+    return map_accumulator!!(
+        acc -> acc + LogLikelihoodAccumulator(logp), vi, Val(:LogLikelihood)
+    )
 end
 
 """

src/accumulators.jl

@@ -193,124 +193,146 @@ end
 # END ACCUMULATOR TUPLE, BEGIN LOG PROB AND NUM PRODUCE ACCUMULATORS
 
 """
-    LogPrior{T} <: AbstractAccumulator
+    LogPriorAccumulator{T} <: AbstractAccumulator
 
 An accumulator that tracks the cumulative log prior during model execution.
 
 # Fields
 $(TYPEDFIELDS)
 """
-struct LogPrior{T} <: AbstractAccumulator
+struct LogPriorAccumulator{T} <: AbstractAccumulator
     "the scalar log prior value"
     logp::T
 end
 
 """
-    LogPrior{T}()
+    LogPriorAccumulator{T}()
 
-Create a new `LogPrior` accumulator with the log prior initialized to zero.
+Create a new `LogPriorAccumulator` accumulator with the log prior initialized to zero.
 """
-LogPrior{T}() where {T} = LogPrior(zero(T))
-LogPrior() = LogPrior{LogProbType}()
+LogPriorAccumulator{T}() where {T} = LogPriorAccumulator(zero(T))
+LogPriorAccumulator() = LogPriorAccumulator{LogProbType}()
 
 """
-    LogLikelihood{T} <: AbstractAccumulator
+    LogLikelihoodAccumulator{T} <: AbstractAccumulator
 
 An accumulator that tracks the cumulative log likelihood during model execution.
 
 # Fields
 $(TYPEDFIELDS)
 """
-struct LogLikelihood{T} <: AbstractAccumulator
+struct LogLikelihoodAccumulator{T} <: AbstractAccumulator
     "the scalar log likelihood value"
     logp::T
 end
 
 """
-    LogLikelihood{T}()
+    LogLikelihoodAccumulator{T}()
 
-Create a new `LogLikelihood` accumulator with the log likelihood initialized to zero.
+Create a new `LogLikelihoodAccumulator` accumulator with the log likelihood initialized to zero.
 """
-LogLikelihood{T}() where {T} = LogLikelihood(zero(T))
-LogLikelihood() = LogLikelihood{LogProbType}()
+LogLikelihoodAccumulator{T}() where {T} = LogLikelihoodAccumulator(zero(T))
+LogLikelihoodAccumulator() = LogLikelihoodAccumulator{LogProbType}()
 
 """
-    NumProduce{T} <: AbstractAccumulator
+    NumProduceAccumulator{T} <: AbstractAccumulator
 
 An accumulator that tracks the number of observations during model execution.
 
 # Fields
 $(TYPEDFIELDS)
 """
-struct NumProduce{T<:Integer} <: AbstractAccumulator
+struct NumProduceAccumulator{T<:Integer} <: AbstractAccumulator
     "the number of observations"
     num::T
 end
 
 """
-    NumProduce{T<:Integer}()
+    NumProduceAccumulator{T<:Integer}()
 
-Create a new `NumProduce` accumulator with the number of observations initialized to zero.
+Create a new `NumProduceAccumulator` accumulator with the number of observations initialized to zero.
 """
-NumProduce{T}() where {T} = NumProduce(zero(T))
-NumProduce() = NumProduce{Int}()
+NumProduceAccumulator{T}() where {T} = NumProduceAccumulator(zero(T))
+NumProduceAccumulator() = NumProduceAccumulator{Int}()
 
-Base.show(io::IO, acc::LogPrior) = print(io, "LogPrior($(repr(acc.logp)))")
-Base.show(io::IO, acc::LogLikelihood) = print(io, "LogLikelihood($(repr(acc.logp)))")
-Base.show(io::IO, acc::NumProduce) = print(io, "NumProduce($(repr(acc.num)))")
+function Base.show(io::IO, acc::LogPriorAccumulator)
+    return print(io, "LogPriorAccumulator($(repr(acc.logp)))")
+end
+function Base.show(io::IO, acc::LogLikelihoodAccumulator)
+    return print(io, "LogLikelihoodAccumulator($(repr(acc.logp)))")
+end
+function Base.show(io::IO, acc::NumProduceAccumulator)
+    return print(io, "NumProduceAccumulator($(repr(acc.num)))")
+end
 
-accumulator_name(::Type{<:LogPrior}) = :LogPrior
-accumulator_name(::Type{<:LogLikelihood}) = :LogLikelihood
-accumulator_name(::Type{<:NumProduce}) = :NumProduce
+accumulator_name(::Type{<:LogPriorAccumulator}) = :LogPrior
+accumulator_name(::Type{<:LogLikelihoodAccumulator}) = :LogLikelihood
+accumulator_name(::Type{<:NumProduceAccumulator}) = :NumProduce
 
-split(::LogPrior{T}) where {T} = LogPrior(zero(T))
-split(::LogLikelihood{T}) where {T} = LogLikelihood(zero(T))
-split(acc::NumProduce) = acc
+split(::LogPriorAccumulator{T}) where {T} = LogPriorAccumulator(zero(T))
+split(::LogLikelihoodAccumulator{T}) where {T} = LogLikelihoodAccumulator(zero(T))
+split(acc::NumProduceAccumulator) = acc
 
-combine(acc::LogPrior, acc2::LogPrior) = LogPrior(acc.logp + acc2.logp)
-combine(acc::LogLikelihood, acc2::LogLikelihood) = LogLikelihood(acc.logp + acc2.logp)
-function combine(acc::NumProduce, acc2::NumProduce)
-    return NumProduce(max(acc.num, acc2.num))
+function combine(acc::LogPriorAccumulator, acc2::LogPriorAccumulator)
+    return LogPriorAccumulator(acc.logp + acc2.logp)
+end
+function combine(acc::LogLikelihoodAccumulator, acc2::LogLikelihoodAccumulator)
+    return LogLikelihoodAccumulator(acc.logp + acc2.logp)
+end
+function combine(acc::NumProduceAccumulator, acc2::NumProduceAccumulator)
+    return NumProduceAccumulator(max(acc.num, acc2.num))
 end
 
-Base.:+(acc1::LogPrior, acc2::LogPrior) = LogPrior(acc1.logp + acc2.logp)
-Base.:+(acc1::LogLikelihood, acc2::LogLikelihood) = LogLikelihood(acc1.logp + acc2.logp)
-increment(acc::NumProduce) = NumProduce(acc.num + oneunit(acc.num))
+function Base.:+(acc1::LogPriorAccumulator, acc2::LogPriorAccumulator)
+    return LogPriorAccumulator(acc1.logp + acc2.logp)
+end
+function Base.:+(acc1::LogLikelihoodAccumulator, acc2::LogLikelihoodAccumulator)
+    return LogLikelihoodAccumulator(acc1.logp + acc2.logp)
+end
+increment(acc::NumProduceAccumulator) = NumProduceAccumulator(acc.num + oneunit(acc.num))
 
-Base.zero(acc::LogPrior) = LogPrior(zero(acc.logp))
-Base.zero(acc::LogLikelihood) = LogLikelihood(zero(acc.logp))
-Base.zero(acc::NumProduce) = NumProduce(zero(acc.num))
+Base.zero(acc::LogPriorAccumulator) = LogPriorAccumulator(zero(acc.logp))
+Base.zero(acc::LogLikelihoodAccumulator) = LogLikelihoodAccumulator(zero(acc.logp))
+Base.zero(acc::NumProduceAccumulator) = NumProduceAccumulator(zero(acc.num))
 
-function accumulate_assume!!(acc::LogPrior, val, logjac, vn, right)
-    return acc + LogPrior(logpdf(right, val) + logjac)
+function accumulate_assume!!(acc::LogPriorAccumulator, val, logjac, vn, right)
+    return acc + LogPriorAccumulator(logpdf(right, val) + logjac)
 end
-accumulate_observe!!(acc::LogPrior, right, left, vn) = acc
+accumulate_observe!!(acc::LogPriorAccumulator, right, left, vn) = acc
 
-accumulate_assume!!(acc::LogLikelihood, val, logjac, vn, right) = acc
-function accumulate_observe!!(acc::LogLikelihood, right, left, vn)
+accumulate_assume!!(acc::LogLikelihoodAccumulator, val, logjac, vn, right) = acc
+function accumulate_observe!!(acc::LogLikelihoodAccumulator, right, left, vn)
     # Note that it's important to use the loglikelihood function here, not logpdf, because
     # they handle vectors differently:
     # https://github.com/JuliaStats/Distributions.jl/issues/1972
-    return acc + LogLikelihood(Distributions.loglikelihood(right, left))
+    return acc + LogLikelihoodAccumulator(Distributions.loglikelihood(right, left))
 end
 
-accumulate_assume!!(acc::NumProduce, val, logjac, vn, right) = acc
-accumulate_observe!!(acc::NumProduce, right, left, vn) = increment(acc)
+accumulate_assume!!(acc::NumProduceAccumulator, val, logjac, vn, right) = acc
+accumulate_observe!!(acc::NumProduceAccumulator, right, left, vn) = increment(acc)
 
-Base.convert(::Type{LogPrior{T}}, acc::LogPrior) where {T} = LogPrior(convert(T, acc.logp))
-function Base.convert(::Type{LogLikelihood{T}}, acc::LogLikelihood) where {T}
-    return LogLikelihood(convert(T, acc.logp))
+function Base.convert(::Type{LogPriorAccumulator{T}}, acc::LogPriorAccumulator) where {T}
+    return LogPriorAccumulator(convert(T, acc.logp))
 end
-function Base.convert(::Type{NumProduce{T}}, acc::NumProduce) where {T}
-    return NumProduce(convert(T, acc.num))
+function Base.convert(
+    ::Type{LogLikelihoodAccumulator{T}}, acc::LogLikelihoodAccumulator
+) where {T}
+    return LogLikelihoodAccumulator(convert(T, acc.logp))
+end
+function Base.convert(
+    ::Type{NumProduceAccumulator{T}}, acc::NumProduceAccumulator
+) where {T}
+    return NumProduceAccumulator(convert(T, acc.num))
 end
 
 # TODO(mhauru)
-# We ignore the convert_eltype calls for NumProduce, by letting them fallback on
+# We ignore the convert_eltype calls for NumProduceAccumulator, by letting them fallback on
 # convert_eltype(::AbstractAccumulator, ::Type). This is because they are only used to
-# deal with dual number types of AD backends, which shouldn't concern NumProduce. This is
+# deal with dual number types of AD backends, which shouldn't concern NumProduceAccumulator. This is
 # horribly hacky and should be fixed. See also comment in `unflatten` in `src/varinfo.jl`.
-convert_eltype(::Type{T}, acc::LogPrior) where {T} = LogPrior(convert(T, acc.logp))
-function convert_eltype(::Type{T}, acc::LogLikelihood) where {T}
-    return LogLikelihood(convert(T, acc.logp))
+function convert_eltype(::Type{T}, acc::LogPriorAccumulator) where {T}
+    return LogPriorAccumulator(convert(T, acc.logp))
+end
+function convert_eltype(::Type{T}, acc::LogLikelihoodAccumulator) where {T}
+    return LogLikelihoodAccumulator(convert(T, acc.logp))
 end

src/logdensityfunction.jl

@@ -79,7 +79,7 @@ julia> LogDensityProblems.logdensity(f, [0.0])
 -2.3378770664093453
 
 julia> # LogDensityFunction respects the accumulators in VarInfo:
-       f_prior = LogDensityFunction(model, setaccs!!(VarInfo(model), (LogPrior(),)));
+       f_prior = LogDensityFunction(model, setaccs!!(VarInfo(model), (LogPriorAccumulator(),)));
 
 julia> LogDensityProblems.logdensity(f_prior, [0.0]) == logpdf(Normal(), 0.0)
 true

src/model.jl

@@ -1058,8 +1058,11 @@ See also [`logjoint`](@ref) and [`loglikelihood`](@ref).
 """
 function logprior(model::Model, varinfo::AbstractVarInfo)
     # Remove other accumulators from varinfo, since they are unnecessary.
-    logprior =
-        hasacc(varinfo, Val(:LogPrior)) ? getacc(varinfo, Val(:LogPrior)) : LogPrior()
+    logprior = if hasacc(varinfo, Val(:LogPrior))
+        getacc(varinfo, Val(:LogPrior))
+    else
+        LogPriorAccumulator()
+    end
     varinfo = setaccs!!(deepcopy(varinfo), (logprior,))
     return getlogprior(last(evaluate!!(model, varinfo, DefaultContext())))
 end
@@ -1112,7 +1115,7 @@ function Distributions.loglikelihood(model::Model, varinfo::AbstractVarInfo)
     loglikelihood = if hasacc(varinfo, Val(:LogLikelihood))
         getacc(varinfo, Val(:LogLikelihood))
     else
-        LogLikelihood()
+        LogLikelihoodAccumulator()
     end
     varinfo = setaccs!!(deepcopy(varinfo), (loglikelihood,))
     return getloglikelihood(last(evaluate!!(model, varinfo, DefaultContext())))

src/pointwise_logdensities.jl

@@ -69,7 +69,7 @@ function accumulate_assume!!(
         # T is the element type of the vectors that are the values of `acc.logps`. Usually
         # it's LogProbType.
         T = eltype(last(fieldtypes(eltype(acc.logps))))
-        subacc = accumulate_assume!!(LogPrior{T}(), val, logjac, vn, right)
+        subacc = accumulate_assume!!(LogPriorAccumulator{T}(), val, logjac, vn, right)
         push!(acc, vn, subacc.logp)
     end
     return acc
@@ -87,7 +87,7 @@ function accumulate_observe!!(
         # T is the element type of the vectors that are the values of `acc.logps`. Usually
         # it's LogProbType.
         T = eltype(last(fieldtypes(eltype(acc.logps))))
-        subacc = accumulate_observe!!(LogLikelihood{T}(), right, left, vn)
+        subacc = accumulate_observe!!(LogLikelihoodAccumulator{T}(), right, left, vn)
         push!(acc, vn, subacc.logp)
     end
     return acc

src/simple_varinfo.jl

@@ -125,15 +125,15 @@ Evaluation in transformed space of course also works:
 
 ```jldoctest simplevarinfo-general
 julia> vi = DynamicPPL.settrans!!(SimpleVarInfo((x = -1.0,)), true)
-Transformed SimpleVarInfo((x = -1.0,), (LogLikelihood = LogLikelihood(0.0), LogPrior = LogPrior(0.0)))
+Transformed SimpleVarInfo((x = -1.0,), (LogLikelihood = LogLikelihoodAccumulator(0.0), LogPrior = LogPriorAccumulator(0.0)))
 
 julia> # (✓) Positive probability mass on negative numbers!
        getlogjoint(last(DynamicPPL.evaluate!!(m, vi, DynamicPPL.DefaultContext())))
 -1.3678794411714423
 
 julia> # While if we forget to indicate that it's transformed:
        vi = DynamicPPL.settrans!!(SimpleVarInfo((x = -1.0,)), false)
-SimpleVarInfo((x = -1.0,), (LogLikelihood = LogLikelihood(0.0), LogPrior = LogPrior(0.0)))
+SimpleVarInfo((x = -1.0,), (LogLikelihood = LogLikelihoodAccumulator(0.0), LogPrior = LogPriorAccumulator(0.0)))
 
 julia> # (✓) No probability mass on negative numbers!
        getlogjoint(last(DynamicPPL.evaluate!!(m, vi, DynamicPPL.DefaultContext())))
@@ -204,7 +204,9 @@ function SimpleVarInfo(values, accs)
     return SimpleVarInfo(values, accs, NoTransformation())
 end
 function SimpleVarInfo{T}(values) where {T<:Real}
-    return SimpleVarInfo(values, AccumulatorTuple(LogLikelihood{T}(), LogPrior{T}()))
+    return SimpleVarInfo(
+        values, AccumulatorTuple(LogLikelihoodAccumulator{T}(), LogPriorAccumulator{T}())
+    )
 end
 function SimpleVarInfo(values)
     return SimpleVarInfo{LogProbType}(values)

src/transforming.jl

@@ -52,7 +52,7 @@ function _transform!!(
     model::Model,
 )
     # To transform using DynamicTransformationContext, we evaluate the model, but we do not
-    # need to use any accumulators other than LogPrior (which is affected by the Jacobian of
+    # need to use any accumulators other than LogPriorAccumulator (which is affected by the Jacobian of
     # the transformation).
     accs = getaccs(vi)
     has_logprior = haskey(accs, Val(:LogPrior))