fixed docs

shravanngoswamii · shravanngoswamii · commit 1c88b69b8a70 · 2024-05-19T18:53:59.000+05:30
diff --git a/tutorials/00-introduction/index.qmd b/tutorials/00-introduction/index.qmd
@@ -196,7 +196,6 @@ Now we can build our plot:
 
 <!-- ```{julia}
 #| echo=false
-#| output: true
 @assert isapprox(mean(chain, :p), 0.5; atol=0.1) "Estimated mean of parameter p: $(mean(chain, :p)) - not in [0.4, 0.6]!"
 ``` -->
 
diff --git a/tutorials/01-gaussian-mixture-model/index.qmd b/tutorials/01-gaussian-mixture-model/index.qmd
@@ -107,13 +107,11 @@ We use a `Gibbs` sampler that combines a [particle Gibbs](https://www.stats.ox.a
 We generate multiple chains in parallel using multi-threading.
 
 ```{julia}
-#| echo: false
 #| output: false
 setprogress!(false)
 ```
 
 ```{julia}
-#| output: false
 sampler = Gibbs(PG(100, :k), HMC(0.05, 10, :μ, :w))
 nsamples = 100
 nchains = 3
diff --git a/tutorials/02-logistic-regression/index.qmd b/tutorials/02-logistic-regression/index.qmd
@@ -121,7 +121,6 @@ end;
 Now we can run our sampler. This time we'll use [`NUTS`](https://turinglang.org/stable/docs/library/#Turing.Inference.NUTS) to sample from our posterior.
 
 ```{julia}
-#| echo: false
 #| output: false
 setprogress!(false)
 ```
diff --git a/tutorials/03-bayesian-neural-network/index.qmd b/tutorials/03-bayesian-neural-network/index.qmd
@@ -107,7 +107,6 @@ end;
 Inference can now be performed by calling `sample`. We use the `NUTS` Hamiltonian Monte Carlo sampler here.
 
 ```{julia}
-#| echo: false
 #| output: false
 setprogress!(false)
 ```
@@ -183,6 +182,7 @@ contour!(x1_range, x2_range, Z)
 
 Suppose we are interested in how the predictive power of our Bayesian neural network evolved between samples. In that case, the following graph displays an animation of the contour plot generated from the network weights in samples 1 to 1,000.
 
+
 ```{julia}
 # Number of iterations to plot.
 n_end = 500
diff --git a/tutorials/04-hidden-markov-model/index.qmd b/tutorials/04-hidden-markov-model/index.qmd
@@ -123,7 +123,6 @@ The parameter `s` is not a continuous variable. It is a vector of **integers**,
 Time to run our sampler.
 
 ```{julia}
-#| echo: false
 #| output: false
 setprogress!(false)
 ```
@@ -140,7 +139,6 @@ It's a bit easier to show how our model performed graphically.
 The code below generates an animation showing the graph of the data above, and the data our model generates in each sample.
 
 ```{julia}
-
 # Extract our m and s parameters from the chain.
 m_set = MCMCChains.group(chn, :m).value
 s_set = MCMCChains.group(chn, :s).value
diff --git a/tutorials/05-linear-regression/index.qmd b/tutorials/05-linear-regression/index.qmd
@@ -11,7 +11,6 @@ This tutorial covers how to implement a linear regression model in Turing.
 We begin by importing all the necessary libraries.
 
 ```{julia}
-#| eval: false
 # Import Turing.
 using Turing
 
@@ -39,8 +38,6 @@ Random.seed!(0);
 ```
 
 ```{julia}
-#| eval: false
-#| echo: false
 #| output: false
 setprogress!(false)
 ```
@@ -52,7 +49,6 @@ We want to know if we can construct a Bayesian linear regression model to predic
 Let us take a look at the data we have.
 
 ```{julia}
-#| eval: false
 # Load the dataset.
 data = RDatasets.dataset("datasets", "mtcars")
 
@@ -61,7 +57,6 @@ first(data, 6)
 ```
 
 ```{julia}
-#| eval: false
 size(data)
 ```
 
@@ -118,7 +113,6 @@ We do not know that our coefficients are different from zero, and we don't know
 Lastly, each observation $y_i$ is distributed according to the calculated `mu` term given by $\alpha + \boldsymbol{\beta}^\mathsf{T}\boldsymbol{X_i}$.
 
 ```{julia}
-#| eval: false
 # Bayesian linear regression.
 @model function linear_regression(x, y)
     # Set variance prior.
diff --git a/tutorials/06-infinite-mixture-model/index.qmd b/tutorials/06-infinite-mixture-model/index.qmd
@@ -222,7 +222,6 @@ data /= std(data);
 Next, we'll sample from our posterior using SMC.
 
 ```{julia}
-#| echo: false
 #| output: false
 setprogress!(false)
 ```
diff --git a/tutorials/07-poisson-regression/index.qmd b/tutorials/07-poisson-regression/index.qmd
@@ -69,7 +69,7 @@ df[sample(1:nrow(df), 5; replace=false), :]
 We plot the distribution of the number of sneezes for the 4 different cases taken above. As expected, the person sneezes the most when he has taken alcohol and not taken his medicine. He sneezes the least when he doesn't consume alcohol and takes his medicine.
 
 ```{julia}
-#Data Plotting
+# Data Plotting
 
 p1 = Plots.histogram(
     df[(df[:, :alcohol_taken] .== 0) .& (df[:, :nomeds_taken] .== 0), 1];
@@ -102,7 +102,7 @@ data
 We must recenter our data about 0 to help the Turing sampler in initialising the parameter estimates. So, normalising the data in each column by subtracting the mean and dividing by the standard deviation:
 
 ```{julia}
-# # Rescale our matrices.
+# Rescale our matrices.
 data = (data .- mean(data; dims=1)) ./ std(data; dims=1)
 ```
 
@@ -213,4 +213,3 @@ plot(chains_new)
 ```
 
 As can be seen from the numeric values and the plots above, the standard deviation values have decreased and all the plotted values are from the estimated posteriors. The exponentiated mean values, with the warmup samples removed, have not changed by much and they are still in accordance with their intuitive meanings as described earlier.
-
diff --git a/tutorials/08-multinomial-logistic-regression/index.qmd b/tutorials/08-multinomial-logistic-regression/index.qmd
@@ -119,7 +119,6 @@ end;
 Now we can run our sampler. This time we'll use [`NUTS`](https://turinglang.org/stable/docs/library/#Turing.Inference.NUTS) to sample from our posterior.
 
 ```{julia}
-#| echo: false
 #| output: false
 setprogress!(false)
 ```
diff --git a/tutorials/09-variational-inference/index.qmd b/tutorials/09-variational-inference/index.qmd
@@ -73,7 +73,6 @@ We'll produce 10 000 samples with 200 steps used for adaptation and a target acc
 If you don't understand what "adaptation" or "target acceptance rate" refers to, all you really need to know is that `NUTS` is known to be one of the most accurate and efficient samplers (when applicable) while requiring little to no hand-tuning to work well.
 
 ```{julia}
-#| echo: false
 #| output: false
 setprogress!(false)
 ```
@@ -601,6 +600,7 @@ Test set:
     OLS loss: $ols_loss2")
 ```
 
+
 Interestingly the squared difference between true- and mean-prediction on the test-set is actually *better* for the mean-field variational posterior than for the "true" posterior obtained by MCMC sampling using `NUTS`. But, as Bayesians, we know that the mean doesn't tell the entire story. One quick check is to look at the mean predictions ± standard deviation of the two different approaches:
 
 ```{julia}
@@ -797,8 +797,8 @@ Test set:
 ```
 
 ```{julia}
-#| echo: false
 #| eval: false
+#| echo: false
 # Verify the loss on the test set.
 @assert vi_loss2 < 0.01 "VI loss on the test set: $(vi_loss2)"
 @assert bayes_loss2 < 0.000001 "Bayes loss on the test set: $(bayes_loss2)"
diff --git a/tutorials/10-bayesian-differential-equations/index.qmd b/tutorials/10-bayesian-differential-equations/index.qmd
@@ -9,7 +9,6 @@ The popular “forward-problem” of simulation consists of solving the differen
 Bayesian inference provides a robust approach to parameter estimation with quantified uncertainty.
 
 ```{julia}
-#| eval: false
 using Turing
 using DifferentialEquations
 
@@ -41,7 +40,6 @@ where $x(t)$ and $y(t)$ denote the populations of prey and predator at time $t$,
 We implement the Lotka-Volterra model and simulate it with parameters $\alpha = 1.5$, $\beta = 1$, $\gamma = 3$, and $\delta = 1$ and initial conditions $x(0) = y(0) = 1$.
 
 ```{julia}
-#| eval: false
 # Define Lotka-Volterra model.
 function lotka_volterra(du, u, p, t)
     # Model parameters.
@@ -71,7 +69,6 @@ With the [`saveat` argument](https://docs.sciml.ai/latest/basics/common_solver_o
 To make the example more realistic we add random normally distributed noise to the simulation.
 
 ```{julia}
-#| eval: false
 sol = solve(prob, Tsit5(); saveat=0.1)
 odedata = Array(sol) + 0.8 * randn(size(Array(sol)))
 
@@ -89,8 +86,8 @@ Previously, functions in Turing and DifferentialEquations were not inter-composa
 Nowadays, however, Turing and DifferentialEquations are completely composable and we can just simulate differential equations inside a Turing `@model`.
 Therefore, we write the Lotka-Volterra parameter estimation problem using the Turing `@model` macro as below:
 
+
 ```{julia}
-#| eval: false
 @model function fitlv(data, prob)
     # Prior distributions.
     σ ~ InverseGamma(2, 3)
@@ -121,7 +118,6 @@ The estimated parameters are close to the parameter values the observations were
 We can also check visually that the chains have converged.
 
 ```{julia}
-#| eval: false
 plot(chain)
 ```
 
@@ -133,7 +129,6 @@ We plot the ensemble of solutions to check if the solution resembles the data.
 The 300 retrodicted time courses from the posterior are plotted in gray, the noisy observations are shown as blue and red dots, and the green and purple lines are the ODE solution that was used to generate the data.
 
 ```{julia}
-#| eval: false
 plot(; legend=false)
 posterior_samples = sample(chain[[:α, :β, :γ, :δ]], 300; replace=false)
 for p in eachrow(Array(posterior_samples))
@@ -155,7 +150,6 @@ For instance, let us suppose we have only observations of the predators but not
 I.e., we fit the model only to the $y$ variable of the system without providing any data for $x$:
 
 ```{julia}
-#| eval: false
 @model function fitlv2(data::AbstractVector, prob)
     # Prior distributions.
     σ ~ InverseGamma(2, 3)
@@ -183,7 +177,6 @@ chain2 = sample(model2, NUTS(0.45), MCMCSerial(), 5000, 3; progress=false)
 Again we inspect the trajectories of 300 randomly selected posterior samples.
 
 ```{julia}
-#| eval: false
 plot(; legend=false)
 posterior_samples = sample(chain2[[:α, :β, :γ, :δ]], 300; replace=false)
 for p in eachrow(Array(posterior_samples))
@@ -222,7 +215,6 @@ Again we use parameters $\alpha = 1.5$, $\beta = 1$, $\gamma = 3$, and $\delta =
 Moreover, we assume $x(t) = 1$ for $t < 0$.
 
 ```{julia}
-#| eval: false
 function delay_lotka_volterra(du, u, h, p, t)
     # Model parameters.
     α, β, γ, δ = p
diff --git a/tutorials/11-probabilistic-pca/index.qmd b/tutorials/11-probabilistic-pca/index.qmd
@@ -80,7 +80,6 @@ We use PCA to explore underlying structure or pattern which may not necessarily
 First, we load the dependencies used.
 
 ```{julia}
-
 using Turing
 using ReverseDiff
 Turing.setadbackend(:reversediff)
@@ -189,7 +188,6 @@ We run the inference using the NUTS sampler, of which the chain length is set to
 You are free to try [different samplers](https://turinglang.org/stable/docs/library/#samplers).
 
 ```{julia}
-#| echo: false
 #| output: false
 setprogress!(false)
 ```
diff --git a/tutorials/13-seasonal-time-series/index.qmd b/tutorials/13-seasonal-time-series/index.qmd
@@ -243,6 +243,7 @@ Since our model takes cyclic effects into account separately,
 we get a better estimate of the true overall trend than if we would have just fitted a line.
 But what frequency content did the model identify?
 
+
 ```{julia}
 function plot_cyclic_features(βsin, βcos)
     labels = reshape(["freq = $i" for i in freqs], 1, :)
diff --git a/tutorials/15-gaussian-processes/index.qmd b/tutorials/15-gaussian-processes/index.qmd
@@ -133,6 +133,7 @@ We'll make use of [ReverseDiff.jl](https://github.com/JuliaDiff/ReverseDiff.jl),
 better performance than [ForwardDiff.jl](https://github.com/JuliaDiff/ForwardDiff.jl/) on
 this example. See Turing.jl's docs on Automatic Differentiation for more info.
 
+
 ```{julia}
 using Random, ReverseDiff
 
diff --git a/tutorials/docs-04-for-developers-abstractmcmc-turing/index.qmd b/tutorials/docs-04-for-developers-abstractmcmc-turing/index.qmd
@@ -12,8 +12,6 @@ Consider the following Turing, code block:
 ```{julia}
 using Turing
 
-setprogress!(false)
-
 @model function gdemo(x, y)
     s² ~ InverseGamma(2, 3)
     m ~ Normal(0, sqrt(s²))
@@ -25,7 +23,7 @@ mod = gdemo(1.5, 2)
 alg = IS()
 n_samples = 1000
 
-chn = sample(mod, alg, n_samples)
+chn = sample(mod, alg, n_samples, progress=false)
 ```
 
 The function `sample` is part of the AbstractMCMC interface. As explained in the [interface guide](https://turinglang.org/dev/docs/for-developers/interface), building a a sampling method that can be used by `sample` consists in overloading the structs and functions in `AbstractMCMC`. The interface guide also gives a standalone example of their implementation, [`AdvancedMH.jl`]().
@@ -64,7 +62,7 @@ is a good approximation of the posterior.
 Recall the last line of the above code block:
 
 ```{julia}
-chn = sample(mod, alg, n_samples)
+chn = sample(mod, alg, n_samples, progress=false)
 ```
 
 Here `sample` takes as arguments a **model** `mod`, an **algorithm** `alg`, and a **number of samples** `n_samples`, and returns an instance `chn` of `Chains` which can be analysed using the functions in `MCMCChains`.
diff --git a/tutorials/docs-06-for-developers-interface/index.qmd b/tutorials/docs-06-for-developers-interface/index.qmd
@@ -162,6 +162,7 @@ The other `step!` function performs the usual steps from Metropolis-Hastings. In
 - `q` returns the log density of one parameterization conditional on another, according to the proposal distribution.
 - `step!` generates a new proposal, checks the acceptance probability, and then returns either the previous transition or the proposed transition.
 
+
 ```{julia}
 #| eval: false
 # Define a function that makes a basic proposal depending on a univariate
@@ -276,7 +277,6 @@ chain = sample(model, spl, 100000; param_names=["μ", "σ"])
 
 If all the interface functions have been extended properly, you should get an output from `display(chain)` that looks something like this:
 
-
 ```{.cell-bg}
 Object of type Chains, with data of type 100000×3×1 Array{Float64,3}
 
diff --git a/tutorials/docs-12-using-turing-guide/index.qmd b/tutorials/docs-12-using-turing-guide/index.qmd
@@ -37,6 +37,7 @@ end
 Note: As a sanity check, the prior expectation of `s²` is `mean(InverseGamma(2, 3)) = 3/(2 - 1) = 3` and the prior expectation of `m` is 0. This can be easily checked using `Prior`:
 
 ```{julia}
+#| output: false
 setprogress!(false)
 ```
 
@@ -497,8 +498,8 @@ using StatsBase
 coeftable(mle_estimate)
 ```
 
-
-```
+<!-- table -->
+```{.cell-bg}
 ─────────────────────────────
    estimate  stderror   tstat
 ─────────────────────────────
@@ -507,7 +508,6 @@ m    1.75    0.176777  9.8995
 ─────────────────────────────
 ```
 
-
 Standard errors are calculated from the Fisher information matrix (inverse Hessian of the log likelihood or log joint). t-statistics will be familiar to frequentist statisticians. Warning -- standard errors calculated in this way may not always be appropriate for MAP estimates, so please be cautious in interpreting them.
 
 #### Sampling with the MAP/MLE as initial states
diff --git a/tutorials/docs-15-using-turing-sampler-viz/index.qmd b/tutorials/docs-15-using-turing-sampler-viz/index.qmd
@@ -97,6 +97,7 @@ end;
 ```
 
 ```{julia}
+#| output: false
 setprogress!(false)
 ```
 
diff --git a/tutorials/docs-16-using-turing-external-samplers/index.qmd b/tutorials/docs-16-using-turing-external-samplers/index.qmd
@@ -38,7 +38,7 @@ Before discussing how this is done in practice, giving a high-level description
 Imagine that we created an instance of an external sampler that we will call `spl` such that `typeof(spl)<:AbstractMCMC.AbstractSampler`.
 In order to avoid type ambiguity within Turing, at the moment it is necessary to declare `spl` as an external sampler to Turing `espl = externalsampler(spl)`, where `externalsampler(s::AbstractMCMC.AbstractSampler)` is a Turing function that types our external sampler adequately.
 
-An excellent point to start to show how this is done in practice is by looking at the sampling library `AdvancedMH` ((`AdvancedMH`'s GitHub)[[https://github.com/TuringLang/AdvancedMH.jl]) for Metropolis-Hastings (MH) methods.
+An excellent point to start to show how this is done in practice is by looking at the sampling library `AdvancedMH` ([`AdvancedMH`'s GitHub](https://github.com/TuringLang/AdvancedMH.jl)) for Metropolis-Hastings (MH) methods.
 Let's say we want to use a random walk Metropolis-Hastings sampler without specifying the proposal distributions.
 The code below constructs an MH sampler using a multivariate Gaussian distribution with zero mean and unit variance in `d` dimensions as a random walk proposal.
 
@@ -49,19 +49,21 @@ rwmh = AdvancedMH.RWMH(d)
 ```
 
 ```{julia}
+#| output: false
 setprogress!(false)
 ```
 
 Sampling is then as easy as:
 
+
 ```{julia}
 chain = sample(model, externalsampler(rwmh), 10_000)
 ```
 
 ## Going beyond the Turing API
 
 As previously mentioned, the Turing wrappers can often limit the capabilities of the sampling libraries they wrap.
-`AdvancedHMC`[^1] ((`AdvancedHMC`'s GitHub)[https://github.com/TuringLang/AdvancedHMC.jl]) is a clear example of this. A common practice when performing HMC is to provide an initial guess for the mass matrix.
+`AdvancedHMC`[^1] ([`AdvancedHMC`'s GitHub](https://github.com/TuringLang/AdvancedHMC.jl)) is a clear example of this. A common practice when performing HMC is to provide an initial guess for the mass matrix.
 However, the native HMC sampler within Turing only allows the user to specify the type of the mass matrix despite the two options being possible within `AdvancedHMC`.
 Thankfully, we can use Turing's support for external samplers to define an HMC sampler with a custom mass matrix in `AdvancedHMC` and then use it to sample our Turing model.
 
