Fix more imports

Author: penelopeysm

developers/compiler/minituring-contexts/index.qmd

@@ -294,7 +294,7 @@ Of course, using an MCMC algorithm to sample from the prior is unnecessary and s
 The use of contexts also goes far beyond just evaluating log probabilities and sampling. Some examples from Turing are
 
 * `FixedContext`, which fixes some variables to given values and removes them completely from the evaluation of any log probabilities. They power the `Turing.fix` and `Turing.unfix` functions.
-* `ConditionContext` conditions the model on fixed values for some parameters. They are used by `Turing.condition` and `Turing.uncondition`, i.e. the `model | (parameter=value,)` syntax. The difference between `fix` and `condition` is whether the log probability for the corresponding variable is included in the overall log density. 
+* `ConditionContext` conditions the model on fixed values for some parameters. They are used by `Turing.condition` and `Turing.decondition`, i.e. the `model | (parameter=value,)` syntax. The difference between `fix` and `condition` is whether the log probability for the corresponding variable is included in the overall log density. 
 
 * `PriorExtractorContext` collects information about what the prior distribution of each variable is.
 * `PrefixContext` adds prefixes to variable names, allowing models to be used within other models without variable name collisions.

developers/compiler/model-manual/index.qmd

@@ -36,26 +36,26 @@ using DynamicPPL
 function gdemo2(model, varinfo, context, x)
     # Assume s² has an InverseGamma distribution.
     s², varinfo = DynamicPPL.tilde_assume!!(
-        context, InverseGamma(2, 3), Turing.@varname(s²), varinfo
+        context, InverseGamma(2, 3), @varname(s²), varinfo
     )
 
     # Assume m has a Normal distribution.
     m, varinfo = DynamicPPL.tilde_assume!!(
-        context, Normal(0, sqrt(s²)), Turing.@varname(m), varinfo
+        context, Normal(0, sqrt(s²)), @varname(m), varinfo
     )
 
     # Observe each value of x[i] according to a Normal distribution.
     for i in eachindex(x)
         _retval, varinfo = DynamicPPL.tilde_observe!!(
-            context, Normal(m, sqrt(s²)), x[i], Turing.@varname(x[i]), varinfo
+            context, Normal(m, sqrt(s²)), x[i], @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))
+gdemo2(x) = DynamicPPL.Model(gdemo2, (; x))
 
 # Instantiate a Model object with our data variables.
 model2 = gdemo2([1.5, 2.0])

developers/inference/implementing-samplers/index.qmd

@@ -403,11 +403,11 @@ As we promised, all of this hassle of implementing our `MALA` sampler in a way t
 It also enables use with Turing.jl through the `externalsampler`, but we need to do one final thing first: we need to tell Turing.jl how to extract a vector of parameters from the "sample" returned in our implementation of `AbstractMCMC.step`. In our case, the "sample" is a `MALASample`, so we just need the following line:
 
 ```{julia}
-# Load Turing.jl.
 using Turing
+using DynamicPPL
 
 # Overload the `getparams` method for our "sample" type, which is just a vector.
-Turing.Inference.getparams(::Turing.Model, sample::MALASample) = sample.x
+Turing.Inference.getparams(::DynamicPPL.Model, sample::MALASample) = sample.x
 ```
 
 And with that, we're good to go!

tutorials/bayesian-time-series-analysis/index.qmd

@@ -165,6 +165,8 @@ scatter!(t, yf; color=2, label="Data")
 With the model specified and with a reasonable prior we can now let Turing decompose the time series for us!
 
 ```{julia}
+using MCMCChains: get_sections
+
 function mean_ribbon(samples)
     qs = quantile(samples)
     low = qs[:, Symbol("2.5%")]
@@ -174,7 +176,7 @@ function mean_ribbon(samples)
 end
 
 function get_decomposition(model, x, cyclic_features, chain, op)
-    chain_params = Turing.MCMCChains.get_sections(chain, :parameters)
+    chain_params = get_sections(chain, :parameters)
     return returned(model(x, cyclic_features, op), chain_params)
 end
 

tutorials/variational-inference/index.qmd

@@ -18,7 +18,7 @@ Here we will focus on how to use VI in Turing and not much on the theory underly
 If you are interested in understanding the mathematics you can checkout [our write-up]({{<meta using-turing-variational-inference>}}) or any other resource online (there a lot of great ones).
 
 Using VI in Turing.jl is very straight forward.
-If `model` denotes a definition of a `Turing.Model`, performing VI is as simple as
+If `model` denotes a definition of a `DynamicPPL.Model`, performing VI is as simple as
 
 ```{julia}
 #| eval: false
@@ -54,7 +54,7 @@ x_i &\overset{\text{i.i.d.}}{=} \mathcal{N}(m, s), \quad i = 1, \dots, n
 
 Recall that *conjugate* refers to the fact that we can obtain a closed-form expression for the posterior. Of course one wouldn't use something like variational inference for a conjugate model, but it's useful as a simple demonstration as we can compare the result to the true posterior.
 
-First we generate some synthetic data, define the `Turing.Model` and instantiate the model on the data:
+First we generate some synthetic data, define the `DynamicPPL.Model` and instantiate the model on the data:
 
 ```{julia}
 # generate data
@@ -666,11 +666,13 @@ using Bijectors: Scale, Shift
 ```
 
 ```{julia}
+using DistributionsAD
+
 d = length(q)
-base_dist = Turing.DistributionsAD.TuringDiagMvNormal(zeros(d), ones(d))
+base_dist = DistributionsAD.TuringDiagMvNormal(zeros(d), ones(d))
 ```
 
-`bijector(model::Turing.Model)` is defined by Turing, and will return a `bijector` which takes you from the space of the latent variables to the real space. In this particular case, this is a mapping `((0, ∞) × ℝ × ℝ¹⁰) → ℝ¹²`. We're interested in using a normal distribution as a base-distribution and transform samples to the latent space, thus we need the inverse mapping from the reals to the latent space:
+`bijector(model::DynamicPPL.Model)` is defined in DynamicPPL, and will return a `bijector` which takes you from the space of the latent variables to the real space. In this particular case, this is a mapping `((0, ∞) × ℝ × ℝ¹⁰) → ℝ¹²`. We're interested in using a normal distribution as a base-distribution and transform samples to the latent space, thus we need the inverse mapping from the reals to the latent space:
 
 ```{julia}
 to_constrained = inverse(bijector(m));