Compiler 3.0

docs/src/using-turing/advanced.md

@@ -115,15 +115,15 @@ mf(vi, sampler, model) = begin
     # Assume s has an InverseGamma distribution.
     s, lp = Turing.assume(sampler,
                 InverseGamma(2, 3),
-                Turing.VarName([:c_s, :s], ""), vi)
+                Turing.@varname(s), vi)
 
     # Add the lp to the accumulated logp.
     vi.logp += lp
 
     # Assume m has a Normal distribution.
     m, lp = Turing.assume(sampler,
                 Normal(0, sqrt(s)),
-                Turing.VarName([:c_m, :m], ""), vi)
+                Turing.@varname(m), vi)
 
     # Add the lp to the accumulated logp.
     vi.logp += lp

src/Turing.jl

@@ -32,39 +32,34 @@ const CACHERANGES = 0b01
 
 const DEBUG = Bool(parse(Int, get(ENV, "DEBUG_TURING", "0")))
 
-"""
-    struct Model{pvars, dvars, F, TData, TDefaults}
-        f::F
-        data::TData
-        defaults::TDefaults
-    end
+# Random probability measures.
+include("stdlib/distributions.jl")
+include("stdlib/RandomMeasures.jl")
 
-A `Model` struct with parameter variables `pvars`, data variables `dvars`, inner
-function `f`, `data::NamedTuple` and `defaults::NamedTuple`.
 """
-struct Model{pvars,
-    dvars,
-    F,
-    TData,
-    TDefaults
-} <: AbstractModel
+struct Model{F, Targs <: NamedTuple}
     f::F
-    data::TData
-    defaults::TDefaults
-end
-function Model{pvars, dvars}(f::F, data::TD, defaults::TDefaults) where {pvars, dvars, F, TD, TDefaults}
-    return Model{pvars, dvars, F, TD, TDefaults}(f, data, defaults)
+    args::Targs
 end
-get_pvars(m::Model{params}) where {params} = Tuple(params.types)
-get_dvars(m::Model{params, data}) where {params, data} = Tuple(data.types)
-get_defaults(m::Model) = m.defaults
-@generated function in_pvars(::Val{sym}, ::Model{params}) where {sym, params}
-    return sym in params.types ? :(true) : :(false)
-end
-@generated function in_dvars(::Val{sym}, ::Model{params, data}) where {sym, params, data}
-    return sym in data.types ? :(true) : :(false)
+
+A `Model` struct with arguments `args` and inner function `f`.
+"""
+struct Model{F, Targs <: NamedTuple} <: AbstractModel
+    f::F
+    args::Targs
 end
+(model::Model)(vi) = model(vi, SampleFromPrior())
+(model::Model)(vi, spl) = model(vi, spl, DefaultContext())
 (model::Model)(args...; kwargs...) = model.f(args..., model; kwargs...)
+getmissing(model::Model) = _getmissing(model.args)
+@generated function _getmissing(args::NamedTuple{names, ttuple}) where {names, ttuple}
+    minds = filter(1:length(names)) do i
+        ttuple.types[i] == Missing
+    end
+    mnames = names[minds]
+    return :(Val{$mnames}())
+end
+
 function runmodel! end
 function getspace end
 
@@ -114,6 +109,36 @@ Sampler(alg) = Sampler(alg, Selector())
 Sampler(alg, model::Model) = Sampler(alg, model, Selector())
 Sampler(alg, model::Model, s::Selector) = Sampler(alg, model, s)
 
+abstract type AbstractContext end
+
+"""
+    struct DefaultContext <: AbstractContext end
+
+The `DefaultContext` is used by default to compute log the joint probability of the data and parameters when running the model.
+"""
+struct DefaultContext <: AbstractContext end
+
+"""
+    struct LikelihoodContext <: AbstractContext end
+
+The `LikelihoodContext` enables the computation of the log likelihood of the data when running the model.
+"""
+struct LikelihoodContext <: AbstractContext end
+
+"""
+    struct MiniBatchContext{Tctx, T} <: AbstractContext
+        ctx::Tctx
+        loglike_scalar::T
+    end
+
+The `MiniBatchContext` enables the computation of `log(prior) + s * log(likelihood of a batch)` when running the model, where `s` is the `loglike_scalar` field, typically equal to `the number of data points / batch size`. This is useful in batch-based stochastic gradient descent algorithms to be optimizing `log(prior) + log(likelihood of all the data points)` in the expectation.
+"""
+struct MiniBatchContext{Tctx, T} <: AbstractContext
+    ctx::Tctx
+    loglike_scalar::T
+end
+MiniBatchContext(ctx = DefaultContext(); batch_size, npoints) = MiniBatchContext(ctx, npoints/batch_size)
+
 include("utilities/Utilities.jl")
 using .Utilities
 include("core/Core.jl")
@@ -140,17 +165,16 @@ using .Variational
     include("contrib/inference/dynamichmc.jl")
 end
 
-# Random probability measures.
-include("stdlib/distributions.jl")
-include("stdlib/RandomMeasures.jl")
-
 ###########
 # Exports #
 ###########
 
 # Turing essentials - modelling macros and inference algorithms
 export  @model,                 # modelling
-        @VarName,
+        @varname,
+        @varinfo,
+        @logpdf,
+        @sampler,
 
         MH,                     # classic sampling
         Gibbs,
@@ -190,6 +214,7 @@ export  @model,                 # modelling
         BinomialLogit,
         VecBinomialLogit,
         OrderedLogistic,
-        LogPoisson
+        LogPoisson,
+        NamedDist
 
 end

src/contrib/inference/AdvancedSMCExtensions.jl

@@ -65,19 +65,6 @@ function Sampler(alg::PMMH, model::Model, s::Selector)
         space = union(space, sub_alg.space)
     end
 
-    # Sanity check for space
-    if !isempty(space)
-        @assert issubset(Set(get_pvars(model)), space) "[$alg_str] symbols specified to samplers ($space)" * "
-            doesn't cover the model parameters ($(Set(get_pvars(model))))"
-
-        if Set(get_pvars(model)) != space
-            warn(
-                "[$alg_str] extra parameters specified by samplers" * 
-                "don't exist in model: $(setdiff(space, Set(get_pvars(model))))"
-            )
-        end
-    end
-
     info[:old_likelihood_estimate] = -Inf # Force to accept first proposal
     info[:old_prior_prob] = 0.0
     info[:samplers] = samplers

src/contrib/inference/dynamichmc.jl

@@ -110,7 +110,7 @@ function Sampler(
 end
 
 # Disable the callback for DynamicHMC, since it has it's own progress meter.
-function Turing.Interface.init_callback(
+function AbstractMCMC.init_callback(
     rng::AbstractRNG,
     model::Model,
     s::Sampler{<:DynamicNUTS},

src/core/Core.jl

@@ -21,7 +21,7 @@ include("container.jl")
 include("ad.jl")
 
 export  @model,
-        @VarName,
+        @varname,
         generate_observe,
         translate_tilde!,
         get_vars,
@@ -51,6 +51,9 @@ export  @model,
         setchunksize,
         verifygrad,
         gradient_logp_forward,
-        gradient_logp_reverse
+        gradient_logp_reverse,
+        @varinfo,
+        @logpdf,
+        @sampler
 
 end # module

src/core/RandomVariables.jl

@@ -2,7 +2,7 @@ module RandomVariables
 
 using ...Turing: Turing, CACHERESET, CACHEIDCS, CACHERANGES, Model,
     AbstractSampler, Sampler, SampleFromPrior, SampleFromUniform,
-    Selector, getspace
+    Selector, getspace, AbstractContext, DefaultContext
 using ...Utilities: vectorize, reconstruct, reconstruct!
 using Bijectors: SimplexDistribution, link, invlink
 using Distributions
@@ -54,30 +54,25 @@ export  VarName,
 """
 ```
 struct VarName{sym}
-    csym      ::    Symbol
     indexing  ::    String
-    counter   ::    Int
 end
 ```
 
-A variable identifier. Every variable has a symbol `sym`, indices `indexing`, and
-internal fields: `csym` and `counter`. The Julia variable in the model corresponding to
-`sym` can refer to a single value or to a hierarchical array structure of univariate,
-multivariate or matrix variables. `indexing` stores the indices that can access the
-random variable from the Julia variable.
+A variable identifier. Every variable has a symbol `sym` and `indices `indexing`. 
+The Julia variable in the model corresponding to `sym` can refer to a single value or 
+to a hierarchical array structure of univariate, multivariate or matrix variables. `indexing` stores the indices that can access the random variable from the Julia 
+variable.
 
 Examples:
 
 - `x[1] ~ Normal()` will generate a `VarName` with `sym == :x` and `indexing == "[1]"`.
 - `x[:,1] ~ MvNormal(zeros(2))` will generate a `VarName` with `sym == :x` and
- `indexing == "[Colon(), 1]"`.
+ `indexing == "[Colon(),1]"`.
 - `x[:,1][2] ~ Normal()` will generate a `VarName` with `sym == :x` and
- `indexing == "[Colon(), 1][2]"`.
+ `indexing == "[Colon(),1][2]"`.
 """
 struct VarName{sym}
-    csym      ::    Symbol        # symbol generated in compilation time
-    indexing  ::    String        # indexing
-    counter   ::    Int           # counter of same {csym, uid}
+    indexing::String # indexing
 end
 
 abstract type AbstractVarInfo end
@@ -180,9 +175,10 @@ const TypedVarInfo = VarInfo{<:NamedTuple}
 
 function VarInfo(model::Model)
     vi = VarInfo()
-    model(vi, SampleFromUniform())
+    model(vi)
     return TypedVarInfo(vi)
 end
+(model::Model)() = model(Turing.VarInfo(), SampleFromPrior())
 
 function VarInfo(old_vi::UntypedVarInfo, spl, x::AbstractVector)
     new_vi = deepcopy(old_vi)
@@ -591,63 +587,39 @@ end
 # VarName
 
 """
-`VarName(csym, sym, indexing, counter)`
-`VarName{sym}(csym::Symbol, indexing::String)`
+`VarName(sym, indexing)`
+`VarName{sym}(indexing::String)`
 
 Constructs a new instance of `VarName{sym}`
 """
-VarName(csym, sym, indexing, counter) = VarName{sym}(csym, indexing, counter)
-function VarName(csym::Symbol, sym::Symbol, indexing::String)
-    # TODO: update this method when implementing the sanity check
-    return VarName{sym}(csym, indexing, 1)
-end
-function VarName{sym}(csym::Symbol, indexing::String) where {sym}
-    # TODO: update this method when implementing the sanity check
-    return VarName{sym}(csym, indexing, 1)
-end
-
-"""
-`VarName(syms::Vector{Symbol}, indexing::String)`
-
-Constructs a new instance of `VarName{syms[2]}`
-"""
-function VarName(syms::Vector{Symbol}, indexing::String) where {sym}
-    # TODO: update this method when implementing the sanity check
-    return VarName{syms[2]}(syms[1], indexing, 1)
-end
+VarName(sym, indexing) = VarName{sym}(indexing)
 
 """
 `VarName(vn::VarName, indexing::String)`
 
 Returns a copy of `vn` with a new index `indexing`.
 """
-function VarName(vn::VarName, indexing::String)
-    return VarName(vn.csym, vn.sym, indexing, vn.counter)
+function VarName(vn::VarName{sym}, indexing::String) where {sym}
+    return VarName{sym}(indexing)
 end
 
 function getproperty(vn::VarName{sym}, f::Symbol) where {sym}
     return f === :sym ? sym : getfield(vn, f)
 end
 
-# NOTE: VarName should only be constructed by VarInfo internally due to the nature of the counter field.
-
 """
 `uid(vn::VarName)`
 
 Returns a unique tuple identifier for `vn`.
 """
-uid(vn::VarName) = (vn.csym, vn.sym, vn.indexing, vn.counter)
+uid(vn::VarName) = (vn.sym, vn.indexing)
 
 hash(vn::VarName) = hash(uid(vn))
 
 ==(x::VarName, y::VarName) = hash(uid(x)) == hash(uid(y))
 
-function string(vn::VarName; all = true)
-    if all
-        return "{$(vn.csym),$(vn.sym)$(vn.indexing)}:$(vn.counter)"
-    else
-        return "$(vn.sym)$(vn.indexing)"
-    end
+function string(vn::VarName)
+    return "$(vn.sym)$(vn.indexing)"
 end
 function string(vns::Vector{<:VarName})
     return replace(string(map(vn -> string(vn), vns)), "String" => "")
@@ -658,7 +630,7 @@ end
 
 Returns a `Symbol` represenation of the variable identifier `VarName`.
 """
-Symbol(vn::VarName) = Symbol(string(vn, all=false))  # simplified symbol
+Symbol(vn::VarName) = Symbol(string(vn))  # simplified symbol
 
 """
 `in(vn::VarName, space::Set)`
@@ -670,7 +642,7 @@ function in(vn::VarName, space::Tuple)::Bool
         return true
     else
         # String representation of `vn`
-        vn_str = string(vn, all=false)
+        vn_str = string(vn)
         return _in(vn_str, space)
     end
 end
@@ -699,21 +671,22 @@ function has_eval_num(spl::T) where T<:AbstractSampler
 end
 
 """
-`runmodel!(model::Model, vi::AbstractVarInfo, spl::AbstractSampler)`
+`runmodel!(model::Model, vi::AbstractVarInfo, spl::AbstractSampler, ctx::AbstractContext)`
 
 Samples from `model` using the sampler `spl` storing the sample and log joint
 probability in `vi`.
 """
 function runmodel!(
     model::Model,
     vi::AbstractVarInfo,
-    spl::T = SampleFromPrior()
+    spl::T = SampleFromPrior(),
+    ctx::AbstractContext = DefaultContext()
 ) where T<:AbstractSampler
     setlogp!(vi, 0)
     if has_eval_num(spl)
         spl.state.eval_num += 1
     end
-    model(vi, spl)
+    model(vi, spl, ctx)
     return vi
 end
 
@@ -1106,7 +1079,7 @@ end
     length(names) === 0 && return :(NamedTuple())
     expr = Expr(:tuple)
     map(names) do f
-        push!(expr.args, Expr(:(=), f, :(getindex.(Ref(vi), metadata.$f.vns), string.(metadata.$f.vns, all=false))))
+        push!(expr.args, Expr(:(=), f, :(getindex.(Ref(vi), metadata.$f.vns), string.(metadata.$f.vns))))
     end
     return expr
 end