Tutorials added

Author: shravanngoswamii

tutorials/00-introduction/Manifest.toml

@@ -0,0 +1,6 @@
+[deps]
+Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
+MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd"
+Turing = "fce5fe82-541a-59a6-adf8-730c64b5f9a0"

tutorials/00-introduction/Project.toml

@@ -1,35 +1,27 @@
 ---
 title: Introduction to Turing
-permalink: /tutorials/:name/
-redirect_from: tutorials/0-introduction/
-weave_options:
-  error : false
+engine: julia
 ---
 
-## Introduction
+### Introduction
 
 This is the first of a series of tutorials on the universal probabilistic programming language **Turing**.
 
-Turing is a probabilistic programming system written entirely in Julia.
-It has an intuitive modelling syntax and supports a wide range of sampling-based inference algorithms.
+Turing is a probabilistic programming system written entirely in Julia. It has an intuitive modelling syntax and supports a wide range of sampling-based inference algorithms.
 
-Familiarity with Julia is assumed throughout this tutorial.
-If you are new to Julia, [Learning Julia](https://julialang.org/learning/) is a good starting point.
+Familiarity with Julia is assumed throughout this tutorial. If you are new to Julia, [Learning Julia](https://julialang.org/learning/) is a good starting point.
 
-For users new to Bayesian machine learning, please consider more thorough introductions to the field such as [Pattern Recognition and Machine Learning](https://www.springer.com/us/book/9780387310732).
-This tutorial tries to provide an intuition for Bayesian inference and gives a simple example on how to use Turing.
-Note that this is not a comprehensive introduction to Bayesian machine learning.
+For users new to Bayesian machine learning, please consider more thorough introductions to the field such as [Pattern Recognition and Machine Learning](https://www.springer.com/us/book/9780387310732). This tutorial tries to provide an intuition for Bayesian inference and gives a simple example on how to use Turing. Note that this is not a comprehensive introduction to Bayesian machine learning.
 
 ### Coin Flipping Without Turing
 
 The following example illustrates the effect of updating our beliefs with every piece of new evidence we observe.
 
-Assume that we are unsure about the probability of heads in a coin flip.
-To get an intuitive understanding of what "updating our beliefs" is, we will visualize the probability of heads in a coin flip after each observed evidence.
+Assume that we are unsure about the probability of heads in a coin flip. To get an intuitive understanding of what "updating our beliefs" is, we will visualize the probability of heads in a coin flip after each observed evidence.
 
 First, let us load some packages that we need to simulate a coin flip
 
-```julia
+```{julia}
 using Distributions
 
 using Random
@@ -38,57 +30,47 @@ Random.seed!(12); # Set seed for reproducibility
 
 and to visualize our results.
 
-```julia
+```{julia}
 using StatsPlots
 ```
 
-Note that Turing is not loaded here — we do not use it in this example.
-If you are already familiar with posterior updates, you can proceed to the next step.
+Note that Turing is not loaded here — we do not use it in this example. If you are already familiar with posterior updates, you can proceed to the next step.
 
-Next, we configure the data generating model.
-Let us set the true probability that a coin flip turns up heads
+Next, we configure the data generating model. Let us set the true probability that a coin flip turns up heads
 
-```julia
+```{julia}
 p_true = 0.5;
 ```
 
 and set the number of coin flips we will show our model.
 
-```julia
+```{julia}
 N = 100;
 ```
 
-We simulate `N` coin flips by drawing `N` random samples from the Bernoulli distribution with success probability `p_true`.
-The draws are collected in a variable called `data`:
+We simulate `N` coin flips by drawing N random samples from the Bernoulli distribution with success probability `p_true`. The draws are collected in a variable called `data`:
 
-```julia
+```{julia}
 data = rand(Bernoulli(p_true), N);
 ```
 
 Here is what the first five coin flips look like:
 
-```julia
+```{julia}
 data[1:5]
 ```
 
-Next, we specify a prior belief about the distribution of heads and tails in a coin toss.
-Here we choose a [Beta](https://en.wikipedia.org/wiki/Beta_distribution) distribution as prior distribution for the probability of heads.
-Before any coin flip is observed, we assume a uniform distribution $\operatorname{U}(0, 1) = \operatorname{Beta}(1, 1)$ of the probability of heads.
-I.e., every probability is equally likely initially.
+Next, we specify a prior belief about the distribution of heads and tails in a coin toss. Here we choose a [Beta](https://en.wikipedia.org/wiki/Beta_distribution) distribution as prior distribution for the probability of heads. Before any coin flip is observed, we assume a uniform distribution $\operatorname{U}(0, 1) = \operatorname{Beta}(1, 1)$ of the probability of heads. I.e., every probability is equally likely initially.
 
-```julia
+```{julia}
 prior_belief = Beta(1, 1);
 ```
 
 With our priors set and our data at hand, we can perform Bayesian inference.
 
-This is a fairly simple process.
-We expose one additional coin flip to our model every iteration, such that the first run only sees the first coin flip, while the last iteration sees all the coin flips.
-In each iteration we update our belief to an updated version of the original Beta distribution that accounts for the new proportion of heads and tails.
-The update is particularly simple since our prior distribution is a [conjugate prior](https://en.wikipedia.org/wiki/Conjugate_prior).
-Note that a closed-form expression for the posterior (implemented in the `updated_belief` expression below) is not accessible in general and usually does not exist for more interesting models.
+This is a fairly simple process. We expose one additional coin flip to our model every iteration, such that the first run only sees the first coin flip, while the last iteration sees all the coin flips. In each iteration we update our belief to an updated version of the original Beta distribution that accounts for the new proportion of heads and tails. The update is particularly simple since our prior distribution is a [conjugate prior](https://en.wikipedia.org/wiki/Conjugate_prior). Note that a closed-form expression for the posterior (implemented in the `updated_belief` expression below) is not accessible in general and usually does not exist for more interesting models.
 
-```julia
+```{julia}
 function updated_belief(prior_belief::Beta, data::AbstractArray{Bool})
     # Count the number of heads and tails.
     heads = sum(data)
@@ -143,19 +125,19 @@ We now move away from the closed-form expression above.
 We use **Turing** to specify the same model and to approximate the posterior distribution with samples.
 To do so, we first need to load `Turing`.
 
-```julia
+```{julia}
 using Turing
 ```
 
 Additionally, we load `MCMCChains`, a library for analyzing and visualizing the samples with which we approximate the posterior distribution.
 
-```julia
+```{julia}
 using MCMCChains
 ```
 
 First, we define the coin-flip model using Turing.
 
-```julia
+```{julia}
 # Unconditioned coinflip model with `N` observations.
 @model function coinflip(; N::Int)
     # Our prior belief about the probability of heads in a coin toss.
@@ -174,15 +156,15 @@ The `@model` macro modifies the body of the Julia function `coinflip` and, e.g.,
 
 Here we defined a model that is not conditioned on any specific observations as this allows us to easily obtain samples of both `p` and `y` with
 
-```julia
+```{julia}
 rand(coinflip(; N))
 ```
 
 The model can be conditioned on some observations with `|`.
 See the [documentation of the `condition` syntax](https://turinglang.github.io/DynamicPPL.jl/stable/api/#Condition-and-decondition) in `DynamicPPL.jl` for more details.
 In the conditioned `model` the observations `y` are fixed to `data`.
 
-```julia
+```{julia}
 coinflip(y::AbstractVector{<:Real}) = coinflip(; N=length(y)) | (; y)
 
 model = coinflip(data);
@@ -192,31 +174,33 @@ After defining the model, we can approximate the posterior distribution by drawi
 In this example, we use a [Hamiltonian Monte Carlo](https://en.wikipedia.org/wiki/Hamiltonian_Monte_Carlo) sampler to draw these samples.
 Other tutorials give more information on the samplers available in Turing and discuss their use for different models.
 
-```julia
+```{julia}
 sampler = NUTS();
 ```
 
 We approximate the posterior distribution with 1000 samples:
 
-```julia
+```{julia}
 chain = sample(model, sampler, 1_000; progress=false);
 ```
 
 The `sample` function and common keyword arguments are explained more extensively in the documentation of [AbstractMCMC.jl](https://turinglang.github.io/AbstractMCMC.jl/dev/api/).
 
 After finishing the sampling process, we can visually compare the closed-form posterior distribution with the approximation obtained with Turing.
 
-```julia
+```{julia}
 histogram(chain)
 ```
 
 Now we can build our plot:
 
-```julia; echo=false
+<!-- ```{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]!"
-```
+``` -->
 
-```julia
+```{julia}
 # Visualize a blue density plot of the approximate posterior distribution using HMC (see Chain 1 in the legend).
 density(chain; xlim=(0, 1), legend=:best, w=2, c=:blue)
 
@@ -241,10 +225,4 @@ vline!([p_true]; label="True probability", c=:red)
 
 As we can see, the samples obtained with Turing closely approximate the true posterior distribution.
 Hopefully this tutorial has provided an easy-to-follow, yet informative introduction to Turing's simpler applications.
-More advanced usage is demonstrated in other tutorials.
-
-```julia, echo=false, skip="notebook", tangle=false
-if isdefined(Main, :TuringTutorials)
-    Main.TuringTutorials.tutorial_footer(WEAVE_ARGS[:folder], WEAVE_ARGS[:file])
-end
-```
+More advanced usage is demonstrated in other tutorials.