Compiler 3.0

docs/src/using-turing/advanced.md

@@ -85,7 +85,7 @@ using Turing
   m ~ Normal(0, sqrt(s))
 
   # Observe each value of x.
-  [x ~ Normal(m, sqrt(s))]
+  @. x ~ Normal(m, sqrt(s))
 end
 
 sample(gdemo([1.5, 2.0]), HMC(0.1, 5), 1000)
@@ -99,58 +99,50 @@ using Turing
 data = (x = [1.5, 2.0],)
 
 # Create the model function.
-mf(vi, sampler, model) = begin
+mf(vi, sampler, ctx, model) = begin
     # Set the accumulated logp to zero.
     vi.logp = 0
-
-    # If x is provided, use the provided values.
-    # Otherwise, treat x as an empty vector with
-    # two entries.
-    if isdefined(model.data, :x)
-        x = model.data.x
-    else # x is a parameter
-        x = model.defaults.x
-    end
+    x = model.args.x
 
     # 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)
+    m, lp = Turing.Inference.tilde(
+        ctx, 
+        sampler, 
+        Normal(0, sqrt(s)), 
+        Turing.@varname(m), 
+        vi,
+    )
 
     # Add the lp to the accumulated logp.
     vi.logp += lp
 
     # Observe each value of x[i], according to a
     # Normal distribution.
-    for i = 1:length(x)
-        vi.logp += Turing.observe(sampler,
-                   Normal(m, sqrt(s)),
-                   x[i], vi)
-    end
+    vi.logp += Turing.Inference.dot_tilde(
+        ctx, 
+        sampler, 
+        Normal(m, sqrt(s)), 
+        x, 
+        vi,
+    )
 end
 
-# Define the default value for x when missing
-defaults = (x = Vector{Real}(undef, 2),)
-
 # Instantiate a Model object.
-model = Turing.Model{Tuple{:s, :m}, Tuple{:x}}(mf, data, defaults)
+model = Turing.Model(mf, data)
 
 # Sample the model.
 chain = sample(model, HMC(0.1, 5), 1000)
 ```
 
 
-Note that the `Turing.Model{Tuple{:s, :m}, Tuple{:x, :y}}` accepts two parameter tuples. The first set, `Tuple{:s, :m}`, represents parameter variables that will be generated by the model, while the second (`Tuple{:x}`) contains the variables to be observed.
-
-
 ## Task Copying
 
 
@@ -207,6 +199,106 @@ result = optimize(nlogp, lb, ub, sm_0, Fminbox())
 ```
 
 
+## Maximum a Posteriori Estimation
+
+
+Turing does not currently have built-in methods for calculating the [maximum a posteriori](https://en.wikipedia.org/wiki/Maximum_a_posteriori_estimation) (MAP) for a model. This is a goal for Turing's implementation (see [this issue](https://github.com/TuringLang/Turing.jl/issues/605)), but for the moment, we present here a method for estimating the MAP using [Optim.jl](https://github.com/JuliaNLSolvers/Optim.jl).
+
+
+```julia
+using Turing
+
+# Define the simple gdemo model.
+@model gdemo(x, y) = begin
+    s ~ InverseGamma(2, 3)
+    m ~ Normal(0, sqrt(s))
+    x ~ Normal(m, sqrt(s))
+    y ~ Normal(m, sqrt(s))
+    return s, m
+end
+
+function get_nlogp(model)
+    # Construct a trace struct
+    vi = Turing.VarInfo(model)
+
+    # Define a function to optimize.
+    function nlogp(sm)
+        spl = Turing.SampleFromPrior()
+        new_vi = Turing.VarInfo(vi, spl, sm)
+        model(new_vi, spl)
+        -new_vi.logp
+    end
+
+    return nlogp
+end
+
+# Define our data points.
+x = 1.5
+y = 2.0
+model = gdemo(x, y)
+nlogp = get_nlogp(model)
+
+# Import Optim.jl.
+using Optim
+
+# Create a starting point, call the optimizer.
+sm_0 = [1.0, 1.0]
+lb = [0.0, -Inf]
+ub = [Inf, Inf]
+result = optimize(nlogp, lb, ub, sm_0, Fminbox())
+```
+
+
+## Maximum Likelihood Estimation
+
+
+Much like the MAP example above, one can use Turing's syntax to define a model and ignore the prior distributions to perform [maximum likelihood estimation](https://en.wikipedia.org/wiki/Maximum_likelihood_estimation) (MLE).
+
+```julia
+using Turing
+
+# Define the simple gdemo model.
+@model gdemo(x, y) = begin
+    s ~ InverseGamma(2, 3)
+    m ~ Normal(0, sqrt(s))
+    x ~ Normal(m, sqrt(s))
+    y ~ Normal(m, sqrt(s))
+    return s, m
+end
+
+function get_nloglike(model)
+    # Construct a trace struct
+    vi = Turing.VarInfo(model)
+
+    # Define a function to optimize.
+    function nloglike(sm)
+        ctx = Turing.LikelihoodContext()
+        spl = Turing.SampleFromPrior()
+        new_vi = Turing.VarInfo(vi, spl, sm)
+        model(new_vi, spl, ctx)
+        -new_vi.logp
+    end
+
+    return nloglike
+end
+
+# Define our data points.
+x = 1.5
+y = 2.0
+model = gdemo(x, y)
+nlogp = get_nloglike(model)
+
+# Import Optim.jl.
+using Optim
+
+# Create a starting point, call the optimizer.
+sm_0 = [1.0, 1.0]
+lb = [0.0, -Inf]
+ub = [Inf, Inf]
+result = optimize(nlogp, lb, ub, sm_0, Fminbox())
+```
+
+
 ## Parallel Sampling