Turing 0.37

Project.toml

@@ -53,4 +53,4 @@ UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [compat]
-Turing = "0.36.2"
+Turing = "0.37"

_quarto.yml

@@ -32,7 +32,7 @@ website:
         text: Team
     right:
       # Current version
-      - text: "v0.36"
+      - text: "v0.37"
         menu:
           - text: Changelog
             href: https://turinglang.org/docs/changelog.html

core-functionality/index.qmd

@@ -475,7 +475,10 @@ Example usage:
     k = length(unique(g))
     a ~ filldist(Exponential(), k) # = Product(fill(Exponential(), k))
     mu = a[g]
-    return x .~ Normal.(mu)
+    for i in eachindex(x)
+        x[i] ~ Normal(mu[i])
+    end
+    return mu
 end
 ```
 
@@ -491,7 +494,10 @@ Example usage:
     k = length(unique(g))
     a ~ arraydist([Exponential(i) for i in 1:k])
     mu = a[g]
-    return x .~ Normal.(mu)
+    for i in eachindex(x)
+        x[i] ~ Normal(mu[i])
+    end
+    return mu
 end
 ```
 

developers/compiler/model-manual/index.qmd

@@ -16,7 +16,9 @@ using Turing
     m ~ Normal(0, sqrt(s²))
 
     # Observe each value of x.
-    @. x ~ Normal(m, sqrt(s²))
+    x .~ Normal(m, sqrt(s²))
+
+    return nothing
 end
 
 model = gdemo([1.5, 2.0])
@@ -28,6 +30,8 @@ However, models can be constructed by hand without the use of a macro.
 Taking the `gdemo` model above as an example, the macro-based definition can be implemented also (a bit less generally) with the macro-free version
 
 ```{julia}
+using DynamicPPL
+
 # Create the model function.
 function gdemo2(model, varinfo, context, x)
     # Assume s² has an InverseGamma distribution.
@@ -41,9 +45,15 @@ function gdemo2(model, varinfo, context, x)
     )
 
     # Observe each value of x[i] according to a Normal distribution.
-    return DynamicPPL.dot_tilde_observe!!(
-        context, Normal(m, sqrt(s²)), x, Turing.@varname(x), varinfo
-    )
+    for i in eachindex(x)
+        _retval, varinfo = DynamicPPL.tilde_observe!!(
+            context, Normal(m, sqrt(s²)), x[i], Turing.@varname(x[i]), varinfo
+        )
+    end
+
+    # The final return statement should comprise both the original return
+    # value and the updated varinfo.
+    return nothing, varinfo
 end
 gdemo2(x) = Turing.Model(gdemo2, (; x))
 

tutorials/gaussian-mixture-models/index.qmd

@@ -167,10 +167,12 @@ One solution here is to enforce an ordering on our $\mu$ vector, requiring $\mu_
 `Bijectors.jl` [provides](https://turinglang.org/Bijectors.jl/dev/transforms/#Bijectors.OrderedBijector) an easy transformation (`ordered()`) for this purpose:
 
 ```{julia}
+using Bijectors: ordered
+
 @model function gaussian_mixture_model_ordered(x)
     # Draw the parameters for each of the K=2 clusters from a standard normal distribution.
     K = 2
-    μ ~ Bijectors.ordered(MvNormal(Zeros(K), I))
+    μ ~ ordered(MvNormal(Zeros(K), I))
     # Draw the weights for the K clusters from a Dirichlet distribution with parameters αₖ = 1.
     w ~ Dirichlet(K, 1.0)
     # Alternatively, one could use a fixed set of weights.
@@ -285,7 +287,7 @@ using LogExpFunctions
 @model function gmm_marginalized(x)
     K = 2
     D, N = size(x)
-    μ ~ Bijectors.ordered(MvNormal(Zeros(K), I))
+    μ ~ ordered(MvNormal(Zeros(K), I))
     w ~ Dirichlet(K, 1.0)
     dists = [MvNormal(Fill(μₖ, D), I) for μₖ in μ]
     for i in 1:N
@@ -325,7 +327,7 @@ The `logpdf` implementation for a `MixtureModel` distribution is exactly the mar
 @model function gmm_marginalized(x)
     K = 2
     D, _ = size(x)
-    μ ~ Bijectors.ordered(MvNormal(Zeros(K), I))
+    μ ~ ordered(MvNormal(Zeros(K), I))
     w ~ Dirichlet(K, 1.0)
     x ~ MixtureModel([MvNormal(Fill(μₖ, D), I) for μₖ in μ], w)
 end
@@ -381,7 +383,7 @@ end
 @model function gmm_recover(x)
     K = 2
     D, N =  size(x)
-    μ ~ Bijectors.ordered(MvNormal(Zeros(K), I))
+    μ ~ ordered(MvNormal(Zeros(K), I))
     w ~ Dirichlet(K, 1.0)
     dists = [MvNormal(Fill(μₖ, D), I) for μₖ in μ]
     x ~ MixtureModel(dists, w)

tutorials/hidden-markov-models/index.qmd

@@ -96,7 +96,7 @@ The priors on our transition matrix are noninformative, using `T[i] ~ Dirichlet(
     N = length(y)
 
     # State sequence.
-    s = tzeros(Int, N)
+    s = zeros(Int, N)
 
     # Emission matrix.
     m = Vector(undef, K)

tutorials/infinite-mixture-models/index.qmd

@@ -188,10 +188,10 @@ In Turing we can implement an infinite Gaussian mixture model using the Chinese
     H = Normal(μ0, σ0)
 
     # Latent assignment.
-    z = tzeros(Int, length(x))
+    z = zeros(Int, length(x))
 
     # Locations of the infinitely many clusters.
-    μ = tzeros(Float64, 0)
+    μ = zeros(Float64, 0)
 
     for i in 1:length(x)
 

tutorials/variational-inference/index.qmd

@@ -36,6 +36,7 @@ We first import the packages to be used:
 using Random
 using Turing
 using Turing: Variational
+using Bijectors: bijector
 using StatsPlots, Measures
 
 Random.seed!(42);

usage/probability-interface/index.qmd

@@ -18,7 +18,7 @@ Let's use a simple model of normally-distributed data as an example.
 
 ```{julia}
 using Turing
-using LinearAlgebra: I
+using DynamicPPL
 using Random
 
 @model function gdemo(n)
@@ -98,11 +98,9 @@ logjoint(model, sample)
 ```
 
 For models with many variables `rand(model)` can be prohibitively slow since it returns a `NamedTuple` of samples from the prior distribution of the unconditioned variables.
-We recommend working with samples of type `DataStructures.OrderedDict` in this case:
+We recommend working with samples of type `DataStructures.OrderedDict` in this case (which Turing re-exports, so can be used directly):
 
 ```{julia}
-using DataStructures: OrderedDict
-
 Random.seed!(124)
 sample_dict = rand(OrderedDict, model)
 ```