From 90b02bb429228b801783aff6a814c607f5a69a55 Mon Sep 17 00:00:00 2001 From: Elizaveta Semenova Date: Sat, 3 Feb 2024 12:21:57 +0000 Subject: [PATCH] PPLs --- 06_Monte_Carlo_and_MCMC.ipynb | 19 -- 07_PPLs.md | 73 ++++ 08_intro_to_Numpyro.ipynb | 607 ++++++++++++++++++++++++++++++++++ _config.yml | 6 +- _toc.yml | 6 +- 5 files changed, 690 insertions(+), 21 deletions(-) create mode 100644 07_PPLs.md create mode 100644 08_intro_to_Numpyro.ipynb diff --git a/06_Monte_Carlo_and_MCMC.ipynb b/06_Monte_Carlo_and_MCMC.ipynb index e727818..bb406c6 100644 --- a/06_Monte_Carlo_and_MCMC.ipynb +++ b/06_Monte_Carlo_and_MCMC.ipynb @@ -417,25 +417,6 @@ "If not, bare in mind that we only wrote the simplest one possible! Sampling algorithms can get very complicated. 🧠" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Probabilistics programming\n", - "\n", - "[Probabilistic programming](https://en.wikipedia.org/wiki/Probabilistic_programming) is a paradigm in computer programming that enables the creation of models and algorithms capable of handling uncertainty and randomness. It combines principles from probability theory and programming to build systems that can reason about uncertain data and make informed decisions. This approach allows developers to express complex models in a natural and intuitive way, enabling tasks such as Bayesian inference, machine learning, and statistical analysis to be performed more effectively.\n", - "\n", - "In this section we will give an overview of the modern landscape of probabilistic programming languages (PPLs), and demonstrate abilities of one of them (NumPyro).\n", - "\n", - "Familiarity with a PPL will equip participants with a tool allowing them to focus on the scientific problem of interest, while inference is being taken care of by the inference engine. We will show how to use the [NumPyro](https://num.pyro.ai/en/latest/index.html#) library to perform exact Bayesian inference (using Markov Chain Monte Carlo).\n", - "\n", - "## Probabilistic programming languages (PPLs)\n", - "\n", - "Luckily, we do not need to write a sampler by hand every time, because PPLs are there to help.\n", - "\n", - "A PPL allows us to formalize a Bayesian model and perform inference with the help of powerful algorithms. **A user needs to only formulate the model** and maybe chose a sampler." - ] - }, { "cell_type": "code", "execution_count": null, diff --git a/07_PPLs.md b/07_PPLs.md new file mode 100644 index 0000000..855aa92 --- /dev/null +++ b/07_PPLs.md @@ -0,0 +1,73 @@ +# Probabilistic Programming Languages + +## Probabilistics programming + +[Probabilistic programming](https://en.wikipedia.org/wiki/Probabilistic_programming) (PP) is a paradigm in computer programming that enables the creation of models and algorithms capable of handling uncertainty and randomness. It combines principles from probability theory and programming to build systems that can reason about uncertain data and make informed decisions. This approach allows developers to express complex models in a natural and intuitive way, enabling tasks such as Bayesian inference, machine learning, and statistical analysis to be performed more effectively. + +Probabilistic programming lies at the intersection of such domains as machine learning algorithms, statistics, and programming laguages, and its golas are to + +- simplify the inference process, +- automate inference. + +```{tikz, tikz-ex, fig.cap = "Funky tikz", fig.ext = 'png', cache=TRUE} +\usetikzlibrary{arrows} +\begin{tikzpicture}[node distance=2cm, auto,>=latex', thick, scale = 0.5] +\node (P) {$P$}; +\node (B) [right of=P] {$B$}; +\node (A) [below of=P] {$A$}; +\node (C) [below of=B] {$C$}; +\node (P1) [node distance=1.4cm, left of=P, above of=P] {$\hat{P}$}; +\draw[->] (P) to node {$f$} (B); +\draw[->] (P) to node [swap] {$g$} (A); +\draw[->] (A) to node [swap] {$f$} (C); +\draw[->] (B) to node {$g$} (C); +\draw[->, bend right] (P1) to node [swap] {$\hat{g}$} (A); +\draw[->, bend left] (P1) to node {$\hat{f}$} (B); +\draw[->, dashed] (P1) to node {$k$} (P); +\end{tikzpicture} +``` + +You can think of the overall logic hierarchy as + +Inference → Probabilistic Programming System → Probabilistic Programming Language → Models → Applications + +In this section we will give an overview of the modern landscape of probabilistic programming languages (PPLs) and in the next section we will explore abilities of one of them (NumPyro). Familiarity with a PPL will equip participants with a tool allowing them to focus on the scientific problem of interest, while inference is being taken care of by the inference engine. + + +We will show how to use the [NumPyro](https://num.pyro.ai/en/latest/index.html#) library to perform exact Bayesian inference (using Markov Chain Monte Carlo). + +## Probabilistic programming languages (PPLs) + +An operative definition of probabilistic programming is as follows: + +β€œProbabilistic programs are usual functional or imperative programs with two added constructs: + +1. the ability to draw values at random from distributions, and + +2. the ability to condition values of variables in a program via observations.” +Gordon et al, 2014 + + +Luckily, we do not need to write a sampler by hand every time, because PPLs are there to help. + +A PPL allows us to formalize a Bayesian model and perform inference with the help of powerful algorithms. **A user needs to only formulate the model** and maybe chose a sampler. + +Luckily, we do not need to write a sampler by hand every time, because probabilistic programming languages (PPLs) are there to help. + +A PPL allows to formalize a Bayesian model and perform inference with the help of powerful algorithms. A user needs to only formulate the model (and maybe chose a sampler) and press the inference button. + +The list of currently existing PPLs is overwhelmingly long and only keeps growing: + +BUGS, WinBUGS, JAGS, +Stan, +PyMC3, PyMC4, +Nimble, +Pyro, +Edward, TensorFlow Probability, Edward 2, +Gen, +Turing, +Stheno, +SOSS, +Omega, +Infer.NET +to name a few.size(chains) \ No newline at end of file diff --git a/08_intro_to_Numpyro.ipynb b/08_intro_to_Numpyro.ipynb new file mode 100644 index 0000000..c6d9f0c --- /dev/null +++ b/08_intro_to_Numpyro.ipynb @@ -0,0 +1,607 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "J1LV5w4eFSzA" + }, + "source": [ + "# Introduction to NumPyro\n", + "\n", + "Probabilistic programming is a powerful approach to modeling and inference in machine learning and statistics. It allows us to build models that incorporate uncertainty and make probabilistic predictions. NumPyro is a probabilistic programming library that combines the flexibility of NumPy with the probabilistic modeling capabilities of Pyro, making it an excellent choice for researchers and data scientists. In this introductory tutorial, we'll explore the basics of NumPyro and how to get started with probabilistic programming.\n", + "\n", + "## Prerequisites" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "id": "mhhWCsnWNO7Q" + }, + "outputs": [], + "source": [ + "#import matplotlib.pyplot as plt\n", + "\n", + "#import numpyro\n", + "#import numpyro.distributions as dist\n", + "#from numpyro.infer import MCMC, NUTS, P\n", + "#import jax\n", + "#import jax.numpy as jnp\n", + "\n", + "#import arviz as az" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Vb4ILFuduHfK" + }, + "source": [ + "In a NumPyro program, you define a probabilistic model that consists of various elements. Let's break down the key elements of a typical NumPyro program:\n", + "\n", + "1. Importing Libraries:\n", + "\n", + "At the beginning of your NumPyro program, you import the necessary libraries, including NumPyro and other required dependencies like JAX and Pyro if applicable. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "id": "NZ7-DnBcuM_7" + }, + "outputs": [], + "source": [ + "import numpyro\n", + "import numpyro.distributions as dist\n", + "from numpyro.infer import MCMC, NUTS, Predictive\n", + "from numpyro.diagnostics import hpdi\n", + "\n", + "import jax\n", + "import jax.numpy as jnp\n", + "\n", + "import arviz as az\n", + "from scipy.stats import gaussian_kde\n", + "\n", + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "25oL3ubXuWZg" + }, + "source": [ + "2. Defining the Model Function:\n", + "\n", + "In NumPyro, you define your probabilistic model as a Python function. This function encapsulates the entire model, including both the prior distributions and the likelihood. Typically, the model function takes one or more arguments, such as data or model parameters, and returns a set of latent variables and observations." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "id": "z_AsEI8SuSAu" + }, + "outputs": [], + "source": [ + "def model(data):\n", + " # Define prior distributions for model parameters\n", + " mean = numpyro.sample(\"mean\", dist.Normal(0, 1))\n", + " scale = numpyro.sample(\"scale\", dist.Exponential(1))\n", + "\n", + " # Define likelihood\n", + " with numpyro.plate(\"data_plate\", len(data)):\n", + " numpyro.sample(\"obs\", dist.Normal(mean, scale), obs=data)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-LqThfWVudNN" + }, + "source": [ + "3. Prior Distributions:\n", + "\n", + "- Inside the model function, you define prior distributions for the model parameters. These prior distributions represent your beliefs about the parameters before observing any data. You use the `numpyro.sample` function to specify these priors. In the example above, `mean` and `scale` are defined as random variables sampled from specific prior distributions.\n", + "\n", + "\n", + "4. Likelihood:\n", + "\n", + "- After specifying the prior distributions, you define the likelihood of your observed data. The likelihood represents the probability distribution of your observed data given the model parameters. It describes how likely it is to observe the data under different parameter values. In the example, the numpyro.sample function is used to define the likelihood of the data points given the mean and scale parameters.\n", + "\n", + "5. Plate for Repetition:\n", + "- In Bayesian modeling, you often work with multiple data points that share the same statistical structure. The `numpyro.plate` context manager allows you to create a plate, which represents a repeated structure for data. It's used to efficiently handle repeated observations. In the example, `numpyro.plate` is used to specify that the likelihood applies to multiple data points.\n", + "\n", + "6. Inference Algorithm:\n", + "\n", + "- After defining your model, you need to choose an inference algorithm to estimate the posterior distribution of model parameters. NumPyro supports various inference algorithms, including NUTS (No-U-Turn Sampler) and SVI (Stochastic Variational Inference). You initialize and configure the chosen inference algorithm according to your requirements.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "id": "Qz6nkjdGua0c" + }, + "outputs": [], + "source": [ + "nuts_kernel = NUTS(model)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8C2V-_BdvEwc" + }, + "source": [ + "8. Performing Inference:\n", + "\n", + "- You use the configured inference algorithm to perform Bayesian inference. In the example, MCMC (Markov Chain Monte Carlo) inference is performed using the `MCMC` class. The `run` method of the `MCMC` object is called to run the inference process." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xAlfnkP6vCV2", + "outputId": "213c669e-9d36-4398-c4a5-c5b389afcfb8" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/q3/n2z18__9281b8xfhctcpxfsr0000gn/T/ipykernel_88949/317822218.py:5: UserWarning: There are not enough devices to run parallel chains: expected 2 but got 1. Chains will be drawn sequentially. If you are running MCMC in CPU, consider using `numpyro.set_host_device_count(2)` at the beginning of your program. You can double-check how many devices are available in your system using `jax.local_device_count()`.\n", + " mcmc = MCMC(nuts_kernel, num_samples=1000, num_warmup=1000, num_chains=2)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "sample: 100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 2000/2000 [00:03<00:00, 542.65it/s, 1 steps of size 5.86e-01. acc. prob=0.95] \n", + "sample: 100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 2000/2000 [00:01<00:00, 1831.55it/s, 3 steps of size 7.44e-01. acc. prob=0.89]\n" + ] + } + ], + "source": [ + "# Simulated data\n", + "data = jnp.array([2.3, 3.9, 1.7, -0.8, 2.5])\n", + "\n", + "\n", + "mcmc = MCMC(nuts_kernel, num_samples=1000, num_warmup=1000, num_chains=2)\n", + "mcmc.run(jax.random.PRNGKey(0), data)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2DXdboTTvSNu" + }, + "source": [ + "9. Posterior Analysis:\n", + "\n", + "- After running the inference, you can retrieve posterior samples of the model parameters. These samples represent the estimated posterior distribution of the parameters given the observed data. You can then analyze these samples to make inferences about your model." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "id": "wL3YlwkovP6C" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " mean 1.17 0.69 1.19 0.04 2.27 885.10 1.01\n", + " scale 1.87 0.62 1.74 0.97 2.72 783.04 1.00\n", + "\n", + "Number of divergences: 0\n" + ] + } + ], + "source": [ + "# Get the posterior samples\n", + "posterior_samples = mcmc.get_samples()\n", + "\n", + "# Print summary statistics of posterior\n", + "mcmc.print_summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-n-z22VnvbRV" + }, + "source": [ + "10. Visualization and Inference:\n", + "\n", + "- Finally, you can perform various tasks such as visualizing the posterior distributions, computing summary statistics, and making predictions or inferences based on the posterior samples." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[,\n", + " ],\n", + " [,\n", + " ]], dtype=object)" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot posterior distributions\n", + "az.plot_trace(mcmc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "igd5fC_9voTw" + }, + "source": [ + "These elements together form a typical NumPyro program for Bayesian probabilistic modeling. The key steps involve defining the model, specifying prior distributions and likelihood, selecting an inference algorithm, running the inference, and analyzing the posterior samples to draw conclusions about the model parameters." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "The typical elements that we will need to write are model in Numpyro are as follows:\n", + "\n", + "- Parameters can be sampled using `numpyro.sample`\n", + "- Parameters can be sampled from any of the available distributsions using, e.g. `dist.Beta(alpha, beta)` \n", + "- Likelihood is constructed by adding `obs=...` to the sampling statement: `numpyro.sample('obs', dist.Binomial(n, p), obs=h)`\n", + "- Once the model has been formulated, we need to specify\n", + " - the sampling algorithm which we would like to use. NUTS is a good default oprtion: `kernel = NUTS(model)` ,\n", + " - number of warm-up steps, number of iterations, number of chains, e.g. `MCMC(kernel, num_warmup=1000, num_samples=2000, num_chains=4)`,\n", + " - using `Predictive` class we can generate predictions.\n", + "\n", + "\n", + "In the example avobe\n", + "\n", + "- We define a simple probabilistic model with two parameters: `mean` and `scale`.\n", + "- We specify priors for these parameters.\n", + "- The data is assumed to be normally distributed with parameters `mean` and `scale`.\n", + "- In this example, the likelihood is specified within the `numpyro.sample` statement inside the model function. NumPyro automatically evaluates the likelihood for the observed data points `(obs=data)` when performing MCMC inference.\n", + "- We use the No-U-Turn Sampler (NUTS) to perform Markov Chain Monte Carlo (MCMC) inference.\n", + "- Finally, we visualize the posterior distributions of the parameters.\n", + "\n", + "\n", + "Let's build a model step by step." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Coin tossing " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "n = 100 # number of trials\n", + "h = 61 # number of successes\n", + "alpha = 2 # hyperparameters\n", + "beta = 2\n", + "\n", + "niter = 1000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "def model(n, alpha=2, beta=2, h=None):\n", + "\n", + " # prior on the probability of success p\n", + " p = numpyro.sample('p', dist.Beta(alpha, beta))\n", + "\n", + " # likelihood - notice the `obs=h` part\n", + " # p is the probabiity of success,\n", + " # n is the total number of experiments\n", + " # h is the number of successes\n", + " numpyro.sample('obs', dist.Binomial(n, p), obs=h)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prior Predictive check\n", + "\n", + "A prior predictive check is a method used in Bayesian statistics to assess the compatibility of a chosen prior distribution with the observed data by simulating data from the prior and comparing it to the actual data - an overlooked but golden tool!" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "from jax import random\n", + "\n", + "rng_key = random.PRNGKey(0)\n", + "rng_key, rng_key_ = random.split(rng_key)\n", + "\n", + "# use the Predictive class to generate predictions.\n", + "# Notice that we are not passing observation `h` as data.\n", + "# Since we have set `h=None`, this allows the model to make predictions of `h`\n", + "# when data for it is not provided.\n", + "prior_predictive = Predictive(model, num_samples=1000)\n", + "prior_predictions = prior_predictive(rng_key_, n)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['obs', 'p'])" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# we have generated samples for two variables\n", + "prior_predictions.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "# extract samples for variable 'p'\n", + "pred_obs = prior_predictions['p']\n", + "\n", + "# compute its summary statistics for the samples of `p`\n", + "mean_prior_pred = jnp.mean(pred_obs, axis=0)\n", + "hpdi_prior_pred = hpdi(pred_obs, 0.89)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'gaussian_kde' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[63], line 5\u001b[0m\n\u001b[1;32m 3\u001b[0m ax\u001b[38;5;241m.\u001b[39mhist(pred_obs, bins\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m15\u001b[39m, density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, alpha\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.5\u001b[39m)\n\u001b[1;32m 4\u001b[0m x \u001b[38;5;241m=\u001b[39m jnp\u001b[38;5;241m.\u001b[39mlinspace(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m3000\u001b[39m)\n\u001b[0;32m----> 5\u001b[0m kde \u001b[38;5;241m=\u001b[39m \u001b[43mgaussian_kde\u001b[49m(pred_obs)\n\u001b[1;32m 6\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot(x, kde(x), color\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC0\u001b[39m\u001b[38;5;124m'\u001b[39m, lw\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m, alpha\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.5\u001b[39m)\n\u001b[1;32m 7\u001b[0m ax\u001b[38;5;241m.\u001b[39mset_xlabel(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mp\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'gaussian_kde' is not defined" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcAAAAESCAYAAABq0wVXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAeC0lEQVR4nO3df3BU1f3/8ddCIEHHXUQkCRIQ+EAgMMYYJD+Y4FAgGBSl05bMtEZwoDZTO4AZW4moiPZjSlXKbxQHzTBKiBgQHEMhzlcISEqHNGE6hSoobWLclAElG7AkAuf7h1/265If5C7sBnOej5n7xz059+R9j3FfnN1797qMMUYAAFimW2cXAABAZyAAAQBWIgABAFYiAAEAViIAAQBWIgABAFYiAAEAVoro7AKulYsXL+rLL7/UTTfdJJfL1dnlAAA6gTFGjY2N6t+/v7p1a3+N12UC8Msvv1RcXFxnlwEAuA7U1tZqwIAB7fbpMgF40003SfrupN1udydXAwDoDD6fT3Fxcf5MaE+XCcBLb3u63W4CEAAs15GPwrgIBgBgJQIQAGAlAhAAYCUCEABgJQIQAGAlAhAAYCUCEABgJQIQAGAlxzfCl5eX66WXXlJlZaW8Xq+2bt2q6dOnt9l/9+7dmjBhQov2I0eOaMSIEf79kpISPfPMM/rss880dOhQ/e///q9+/OMfOy0PwHXkT2WfhmzsxycPD9nYsIPjFeDZs2eVmJioVatWOTruk08+kdfr9W/Dhg3z/6yiokLZ2dnKycnRoUOHlJOToxkzZujAgQNOywMAoEMcrwCzsrKUlZXl+Bf169dPvXv3bvVny5Yt0+TJk5Wfny9Jys/P1549e7Rs2TIVFRU5/l0AAFxJ2D4DTEpKUmxsrCZOnKiPPvoo4GcVFRXKzMwMaJsyZYr279/f5nhNTU3y+XwBGwAAHRXyAIyNjdW6detUUlKiLVu2KD4+XhMnTlR5ebm/T319vaKjowOOi46OVn19fZvjFhQUyOPx+DcehQQAcCLkT4OIj49XfHy8fz8tLU21tbV6+eWXNX78eH/75d/cbYxp99u88/PzlZeX59+/9AgMAAA6olNug0hNTdXRo0f9+zExMS1WeydOnGixKvy+yMhI/6OPeAQSAMCpTgnAqqoqxcbG+vfT0tJUVlYW0GfXrl1KT08Pd2kAAEs4fgv0zJkzOnbsmH//+PHjqq6uVp8+fTRw4EDl5+errq5OGzZskPTdFZ633367Ro0apebmZr311lsqKSlRSUmJf4x58+Zp/PjxWrJkiR588EFt27ZNH374ofbt23cNThEAgJYcB+DBgwcDbmy/9DnczJkzVVhYKK/Xq5qaGv/Pm5ub9cQTT6iurk69evXSqFGj9MEHH2jq1Kn+Punp6dq0aZOefvppPfPMMxo6dKiKi4uVkpJyNecGAECbXMYY09lFXAs+n08ej0cNDQ18HghcJ/gmGISbkyzgu0ABAFYiAAEAViIAAQBWCvmN8ACuDp+jAaHBChAAYCUCEABgJQIQAGAlPgOEFfgcrXWhnBfgescKEABgJVaAAH6QQr16/SGv7NExrAABAFYiAAEAViIAAQBWIgABAFYiAAEAViIAAQBWIgABAFYiAAEAVuJGeOAq8XViwA8TK0AAgJUIQACAlQhAAICVCEAAgJUIQACAlQhAAICVHAdgeXm5pk2bpv79+8vlcum9995rt/+WLVs0efJk3XrrrXK73UpLS9POnTsD+hQWFsrlcrXYzp0757Q8AAA6xHEAnj17VomJiVq1alWH+peXl2vy5MkqLS1VZWWlJkyYoGnTpqmqqiqgn9vtltfrDdiioqKclgcAQIc4vhE+KytLWVlZHe6/bNmygP0XX3xR27Zt0/vvv6+kpCR/u8vlUkxMjNNyAAAIStg/A7x48aIaGxvVp0+fgPYzZ85o0KBBGjBggO6///4WK8TLNTU1yefzBWwAAHRU2APwlVde0dmzZzVjxgx/24gRI1RYWKjt27erqKhIUVFRGjdunI4ePdrmOAUFBfJ4PP4tLi4uHOUDALqIsAZgUVGRnnvuORUXF6tfv37+9tTUVD300ENKTExURkaG3nnnHQ0fPlwrV65sc6z8/Hw1NDT4t9ra2nCcAgCgiwjbl2EXFxdr9uzZ2rx5syZNmtRu327duunuu+9udwUYGRmpyMjIa10mAMASYVkBFhUVadasWdq4caPuu+++K/Y3xqi6ulqxsbFhqA4AYCPHK8AzZ87o2LFj/v3jx4+rurpaffr00cCBA5Wfn6+6ujpt2LBB0nfh9/DDD2v58uVKTU1VfX29JKlXr17yeDySpMWLFys1NVXDhg2Tz+fTihUrVF1drdWrV1+LcwQAoAXHK8CDBw8qKSnJfwtDXl6ekpKS9Oyzz0qSvF6vampq/P1fe+01nT9/Xo899phiY2P927x58/x9Tp8+rUcffVQjR45UZmam6urqVF5errFjx17t+QEA0CqXMcZ0dhHXgs/nk8fjUUNDg9xud2eXg+sMD62FU49PHt7ZJSAITrKA7wIFAFiJAAQAWClst0Hghy+UbyPydhOAcGMFCACwEitAXBe4SAVAuLECBABYiQAEAFiJAAQAWIkABABYiQAEAFiJAAQAWInbIACgFXzxQ9fHChAAYCUCEABgJQIQAGAlAhAAYCUCEABgJQIQAGAlAhAAYCUCEABgJQIQAGAlAhAAYCUCEABgJQIQAGAlAhAAYCXHAVheXq5p06apf//+crlceu+99654zJ49e5ScnKyoqCgNGTJEr776aos+JSUlSkhIUGRkpBISErR161anpQEA0GGOA/Ds2bNKTEzUqlWrOtT/+PHjmjp1qjIyMlRVVaWnnnpKc+fOVUlJib9PRUWFsrOzlZOTo0OHDiknJ0czZszQgQMHnJYHAECHuIwxJuiDXS5t3bpV06dPb7PPk08+qe3bt+vIkSP+ttzcXB06dEgVFRWSpOzsbPl8Pu3YscPf595779XNN9+soqKiDtXi8/nk8XjU0NAgt9sd3AmhXaF8PhpgE54HGDpOsiDknwFWVFQoMzMzoG3KlCk6ePCgvv3223b77N+/v81xm5qa5PP5AjYAADoq5AFYX1+v6OjogLbo6GidP39eJ0+ebLdPfX19m+MWFBTI4/H4t7i4uGtfPACgywrLVaAulytg/9K7rt9vb63P5W3fl5+fr4aGBv9WW1t7DSsGAHR1EaH+BTExMS1WcidOnFBERIRuueWWdvtcvir8vsjISEVGRl77ggEAVgj5CjAtLU1lZWUBbbt27dKYMWPUo0ePdvukp6eHujwAgKUcrwDPnDmjY8eO+fePHz+u6upq9enTRwMHDlR+fr7q6uq0YcMGSd9d8blq1Srl5eXpl7/8pSoqKrR+/fqAqzvnzZun8ePHa8mSJXrwwQe1bds2ffjhh9q3b981OEUAAFpyvAI8ePCgkpKSlJSUJEnKy8tTUlKSnn32WUmS1+tVTU2Nv//gwYNVWlqq3bt3684779QLL7ygFStW6Cc/+Ym/T3p6ujZt2qQ333xTd9xxhwoLC1VcXKyUlJSrPT8AAFp1VfcBXk+4DzD0uA8QuDa4DzB0rqv7AAEAuB4RgAAAKxGAAAArEYAAACsRgAAAKxGAAAArEYAAACsRgAAAKxGAAAArEYAAACsRgAAAKxGAAAArEYAAACsRgAAAKxGAAAArEYAAACsRgAAAKxGAAAArEYAAACsRgAAAKxGAAAArEYAAACtFdHYBuHb+VPZpZ5cAAD8YrAABAFYiAAEAVgoqANesWaPBgwcrKipKycnJ2rt3b5t9Z82aJZfL1WIbNWqUv09hYWGrfc6dOxdMeQAAXJHjACwuLtb8+fO1cOFCVVVVKSMjQ1lZWaqpqWm1//Lly+X1ev1bbW2t+vTpo5/97GcB/dxud0A/r9erqKio4M4KAIArcByAS5cu1ezZszVnzhyNHDlSy5YtU1xcnNauXdtqf4/Ho5iYGP928OBBff3113rkkUcC+rlcroB+MTExwZ0RAAAd4Ogq0ObmZlVWVmrBggUB7ZmZmdq/f3+Hxli/fr0mTZqkQYMGBbSfOXNGgwYN0oULF3TnnXfqhRdeUFJSUpvjNDU1qampyb/v8/kcnAkAdJ5QX7H9+OThIR2/q3C0Ajx58qQuXLig6OjogPbo6GjV19df8Xiv16sdO3Zozpw5Ae0jRoxQYWGhtm/frqKiIkVFRWncuHE6evRom2MVFBTI4/H4t7i4OCenAgCwXFAXwbhcroB9Y0yLttYUFhaqd+/emj59ekB7amqqHnroISUmJiojI0PvvPOOhg8frpUrV7Y5Vn5+vhoaGvxbbW1tMKcCALCUo7dA+/btq+7du7dY7Z04caLFqvByxhi98cYbysnJUc+ePdvt261bN919993trgAjIyMVGRnZ8eIBAPgeRyvAnj17Kjk5WWVlZQHtZWVlSk9Pb/fYPXv26NixY5o9e/YVf48xRtXV1YqNjXVSHgAAHeb4q9Dy8vKUk5OjMWPGKC0tTevWrVNNTY1yc3MlfffWZF1dnTZs2BBw3Pr165WSkqLRo0e3GHPx4sVKTU3VsGHD5PP5tGLFClVXV2v16tVBnhYAAO1zHIDZ2dk6deqUnn/+eXm9Xo0ePVqlpaX+qzq9Xm+LewIbGhpUUlKi5cuXtzrm6dOn9eijj6q+vl4ej0dJSUkqLy/X2LFjgzglAACuzGWMMZ1dxLXg8/nk8XjU0NAgt9vd2eV0Cr4MG4Bk920QTrKA7wIFAFiJAAQAWIkABABYiQAEAFiJAAQAWIkABABYiQAEAFiJAAQAWMnxN8Hg6nCzOgBcH1gBAgCsRAACAKxEAAIArMRngADQxYTyWoOu9EXbrAABAFYiAAEAViIAAQBWIgABAFYiAAEAViIAAQBWIgABAFYiAAEAViIAAQBWIgABAFYiAAEAViIAAQBWCioA16xZo8GDBysqKkrJycnau3dvm313794tl8vVYvvnP/8Z0K+kpEQJCQmKjIxUQkKCtm7dGkxpAAB0iOMALC4u1vz587Vw4UJVVVUpIyNDWVlZqqmpafe4Tz75RF6v178NGzbM/7OKigplZ2crJydHhw4dUk5OjmbMmKEDBw44PyMAADrAZYwxTg5ISUnRXXfdpbVr1/rbRo4cqenTp6ugoKBF/927d2vChAn6+uuv1bt371bHzM7Ols/n044dO/xt9957r26++WYVFRV1qC6fzyePx6OGhga53W4npxRWoXxMCQCE2vX+OCQnWeBoBdjc3KzKykplZmYGtGdmZmr//v3tHpuUlKTY2FhNnDhRH330UcDPKioqWow5ZcqUdsdsamqSz+cL2AAA6ChHAXjy5ElduHBB0dHRAe3R0dGqr69v9ZjY2FitW7dOJSUl2rJli+Lj4zVx4kSVl5f7+9TX1zsaU5IKCgrk8Xj8W1xcnJNTAQBYLqgnwrtcroB9Y0yLtkvi4+MVHx/v309LS1Ntba1efvlljR8/PqgxJSk/P195eXn+fZ/PRwgCADrM0Qqwb9++6t69e4uV2YkTJ1qs4NqTmpqqo0eP+vdjYmIcjxkZGSm32x2wAQDQUY4CsGfPnkpOTlZZWVlAe1lZmdLT0zs8TlVVlWJjY/37aWlpLcbctWuXozEBAHDC8VugeXl5ysnJ0ZgxY5SWlqZ169appqZGubm5kr57a7Kurk4bNmyQJC1btky33367Ro0apebmZr311lsqKSlRSUmJf8x58+Zp/PjxWrJkiR588EFt27ZNH374ofbt23eNThMAgECOAzA7O1unTp3S888/L6/Xq9GjR6u0tFSDBg2SJHm93oB7Apubm/XEE0+orq5OvXr10qhRo/TBBx9o6tSp/j7p6enatGmTnn76aT3zzDMaOnSoiouLlZKScg1OEQCAlhzfB3i94j5AAAg9a+8DBACgqyAAAQBWIgABAFYiAAEAViIAAQBWCuqr0LoyrtIEADuwAgQAWIkABABYiQAEAFiJAAQAWIkABABYiQAEAFiJAAQAWIkABABYiQAEAFiJAAQAWIkABABYiQAEAFiJAAQAWIkABABYiQAEAFiJAAQAWIkABABYiQAEAFiJAAQAWCmoAFyzZo0GDx6sqKgoJScna+/evW323bJliyZPnqxbb71VbrdbaWlp2rlzZ0CfwsJCuVyuFtu5c+eCKQ8AgCtyHIDFxcWaP3++Fi5cqKqqKmVkZCgrK0s1NTWt9i8vL9fkyZNVWlqqyspKTZgwQdOmTVNVVVVAP7fbLa/XG7BFRUUFd1YAAFxBhNMDli5dqtmzZ2vOnDmSpGXLlmnnzp1au3atCgoKWvRftmxZwP6LL76obdu26f3331dSUpK/3eVyKSYmxmk5AAAExdEKsLm5WZWVlcrMzAxoz8zM1P79+zs0xsWLF9XY2Kg+ffoEtJ85c0aDBg3SgAEDdP/997dYIV6uqalJPp8vYAMAoKMcBeDJkyd14cIFRUdHB7RHR0ervr6+Q2O88sorOnv2rGbMmOFvGzFihAoLC7V9+3YVFRUpKipK48aN09GjR9scp6CgQB6Px7/FxcU5ORUAgOWCugjG5XIF7BtjWrS1pqioSM8995yKi4vVr18/f3tqaqoeeughJSYmKiMjQ++8846GDx+ulStXtjlWfn6+Ghoa/FttbW0wpwIAsJSjzwD79u2r7t27t1jtnThxosWq8HLFxcWaPXu2Nm/erEmTJrXbt1u3brr77rvbXQFGRkYqMjKy48UDAPA9jlaAPXv2VHJyssrKygLay8rKlJ6e3uZxRUVFmjVrljZu3Kj77rvvir/HGKPq6mrFxsY6KQ8AgA5zfBVoXl6ecnJyNGbMGKWlpWndunWqqalRbm6upO/emqyrq9OGDRskfRd+Dz/8sJYvX67U1FT/6rFXr17yeDySpMWLFys1NVXDhg2Tz+fTihUrVF1drdWrV1+r8wQAIIDjAMzOztapU6f0/PPPy+v1avTo0SotLdWgQYMkSV6vN+CewNdee03nz5/XY489pscee8zfPnPmTBUWFkqSTp8+rUcffVT19fXyeDxKSkpSeXm5xo4de5WnBwC4lv5U9mlIx3988vCQjv99LmOMCdtvCyGfzyePx6OGhga53e6gxwn1f1wAQNuuNgCdZAHfBQoAsBIBCACwEgEIALASAQgAsBIBCACwEgEIALASAQgAsBIBCACwEgEIALASAQgAsBIBCACwEgEIALASAQgAsBIBCACwEgEIALASAQgAsBIBCACwEgEIALASAQgAsBIBCACwEgEIALASAQgAsBIBCACwEgEIALASAQgAsBIBCACwUlABuGbNGg0ePFhRUVFKTk7W3r172+2/Z88eJScnKyoqSkOGDNGrr77aok9JSYkSEhIUGRmphIQEbd26NZjSAADoEMcBWFxcrPnz52vhwoWqqqpSRkaGsrKyVFNT02r/48ePa+rUqcrIyFBVVZWeeuopzZ07VyUlJf4+FRUVys7OVk5Ojg4dOqScnBzNmDFDBw4cCP7MAABoh8sYY5wckJKSorvuuktr1671t40cOVLTp09XQUFBi/5PPvmktm/friNHjvjbcnNzdejQIVVUVEiSsrOz5fP5tGPHDn+fe++9VzfffLOKioparaOpqUlNTU3+/YaGBg0cOFC1tbVyu91OTinA6v9zLOhjAQBX57Ef/c9VHe/z+RQXF6fTp0/L4/G039k40NTUZLp37262bNkS0D537lwzfvz4Vo/JyMgwc+fODWjbsmWLiYiIMM3NzcYYY+Li4szSpUsD+ixdutQMHDiwzVoWLVpkJLGxsbGxsbXYamtrr5hpEXLg5MmTunDhgqKjowPao6OjVV9f3+ox9fX1rfY/f/68Tp48qdjY2Db7tDWmJOXn5ysvL8+/f/HiRX311Ve65ZZb5HK52j2PS/9CuNrVYlfF/FwZc9Q+5qd9zM+VBTtHxhg1Njaqf//+V+zrKAAvuTxgjDHthk5r/S9vdzpmZGSkIiMjA9p69+7dbt2Xc7vd/PG1g/m5MuaofcxP+5ifKwtmjq741uf/4+gimL59+6p79+4tVmYnTpxosYK7JCYmptX+ERERuuWWW9rt09aYAABcLUcB2LNnTyUnJ6usrCygvaysTOnp6a0ek5aW1qL/rl27NGbMGPXo0aPdPm2NCQDAVbvip4SX2bRpk+nRo4dZv369OXz4sJk/f7658cYbzb/+9S9jjDELFiwwOTk5/v6ff/65ueGGG8zjjz9uDh8+bNavX2969Ohh3n33XX+fjz/+2HTv3t384Q9/MEeOHDF/+MMfTEREhPnLX/7itLwOOXfunFm0aJE5d+5cSMb/oWN+row5ah/z0z7m58rCMUeOA9AYY1avXm0GDRpkevbsae666y6zZ88e/89mzpxp7rnnnoD+u3fvNklJSaZnz57m9ttvN2vXrm0x5ubNm018fLzp0aOHGTFihCkpKQmmNAAAOsTxfYAAAHQFfBcoAMBKBCAAwEoEIADASgQgAMBKXTYAQ/HIpq7Eyfxs2bJFkydP1q233iq32620tDTt3LkzjNWGn9O/n0s+/vhjRURE6M477wxtgdcBp3PU1NSkhQsXatCgQYqMjNTQoUP1xhtvhKna8HM6P2+//bYSExN1ww03KDY2Vo888ohOnToVpmrDq7y8XNOmTVP//v3lcrn03nvvXfGYkLxGd/ZlqKFw6V7F119/3Rw+fNjMmzfP3Hjjjebf//53q/0v3as4b948c/jwYfP666+3uFexK3E6P/PmzTNLliwxf/3rX82nn35q8vPzTY8ePczf/va3MFceHk7n55LTp0+bIUOGmMzMTJOYmBieYjtJMHP0wAMPmJSUFFNWVmaOHz9uDhw4YD7++OMwVh0+Tudn7969plu3bmb58uXm888/N3v37jWjRo0y06dPD3Pl4VFaWmoWLlxoSkpKjCSzdevWdvuH6jW6Swbg2LFjTW5ubkDbiBEjzIIFC1rt/7vf/c6MGDEioO1Xv/qVSU1NDVmNncnp/LQmISHBLF68+FqXdl0Idn6ys7PN008/bRYtWtTlA9DpHO3YscN4PB5z6tSpcJTX6ZzOz0svvWSGDBkS0LZixQozYMCAkNV4vehIAIbqNbrLvQXa3NysyspKZWZmBrRnZmZq//79rR5TUVHRov+UKVN08OBBffvttyGrtTMEMz+Xu3jxohobG9WnT59QlNipgp2fN998U5999pkWLVoU6hI7XTBztH37do0ZM0Z//OMfddttt2n48OF64okn9N///jccJYdVMPOTnp6uL774QqWlpTLG6D//+Y/effdd3XfffeEo+boXqtfooJ4GcT0L1SObuopg5udyr7zyis6ePasZM2aEosROFcz8HD16VAsWLNDevXsVEdHl/pdqIZg5+vzzz7Vv3z5FRUVp69atOnnypH7961/rq6++6nKfAwYzP+np6Xr77beVnZ2tc+fO6fz583rggQe0cuXKcJR83QvVa3SXWwFeEopHNnUlTufnkqKiIj333HMqLi5Wv379QlVep+vo/Fy4cEE///nPtXjxYg0fPjxc5V0XnPwNXbx4US6XS2+//bbGjh2rqVOnaunSpSosLOySq0DJ2fwcPnxYc+fO1bPPPqvKykr9+c9/1vHjx5WbmxuOUn8QQvEa3eX+uRqqRzZ1FcHMzyXFxcWaPXu2Nm/erEmTJoWyzE7jdH4aGxt18OBBVVVV6Te/+Y2k717sjTGKiIjQrl279KMf/SgstYdLMH9DsbGxuu222wKe0zZy5EgZY/TFF19o2LBhIa05nIKZn4KCAo0bN06//e1vJUl33HGHbrzxRmVkZOj3v/99l3oXKhiheo3ucivAUD2yqasIZn6k71Z+s2bN0saNG7v05xJO58ftduvvf/+7qqur/Vtubq7i4+NVXV2tlJSUcJUeNsH8DY0bN05ffvmlzpw542/79NNP1a1bNw0YMCCk9YZbMPPzzTffqFu3wJfj7t27S/r/Kx2bhew1+qouoblOheKRTV2J0/nZuHGjiYiIMKtXrzZer9e/nT59urNOIaSczs/lbLgK1OkcNTY2mgEDBpif/vSn5h//+IfZs2ePGTZsmJkzZ05nnUJIOZ2fN99800RERJg1a9aYzz77zOzbt8+MGTPGjB07trNOIaQaGxtNVVWVqaqqMpLM0qVLTVVVlf82kXC9RnfJADQmNI9s6kqczM8999xjJLXYZs6cGf7Cw8Tp38/32RCAxjifoyNHjphJkyaZXr16mQEDBpi8vDzzzTffhLnq8HE6PytWrDAJCQmmV69eJjY21vziF78wX3zxRZirDo+PPvqo3deUcL1G8zgkAICVutxngAAAdAQBCACwEgEIALASAQgAsBIBCACwEgEIALASAQgAsBIBCACwEgEIALASAQgAsBIBCACw0v8FxgMkZnQg5pwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(dpi=100, figsize=(5, 3))\n", + "ax = fig.add_subplot(1, 1, 1)\n", + "ax.hist(pred_obs, bins=15, density=True, alpha=0.5)\n", + "x = jnp.linspace(0, 1, 3000)\n", + "kde = gaussian_kde(pred_obs)\n", + "ax.plot(x, kde(x), color='C0', lw=3, alpha=0.5)\n", + "ax.set_xlabel('p')\n", + "ax.set_title('Prior predictive distribution for p')\n", + "ax.set_xlim(0, 1)\n", + "ax.grid(0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference\n", + "\n", + "Using the same routine as we did for prior redictive, we can perform inference by using the observed data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "rng_key = random.PRNGKey(0)\n", + "rng_key, rng_key_ = random.split(rng_key)\n", + "\n", + "# specify inference algorithm\n", + "kernel = NUTS(model)\n", + "\n", + "# define number of samples and number chains\n", + "mcmc = MCMC(kernel, num_warmup=1000, num_samples=2000, num_chains=4)\n", + "\n", + "#run MCMC\n", + "mcmc.run(rng_key_, n=n, h=h)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# inpect summary\n", + "# r_hat is a dignostic comparing within chain variation to between chan variation.\n", + "# It is an importnat convergene diagnostic, and we want its valye to be close to 1\n", + "mcmc.print_summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'p_posterior_samples' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[64], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m ax \u001b[38;5;241m=\u001b[39m fig\u001b[38;5;241m.\u001b[39madd_subplot(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 3\u001b[0m ax\u001b[38;5;241m.\u001b[39mhist(pred_obs, bins\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m15\u001b[39m, density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, alpha\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.5\u001b[39m, label \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPrior distribution\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 4\u001b[0m ax\u001b[38;5;241m.\u001b[39mhist(\u001b[43mp_posterior_samples\u001b[49m, bins\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m15\u001b[39m, density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, alpha\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.5\u001b[39m, label \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPosterior distribution\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 5\u001b[0m x \u001b[38;5;241m=\u001b[39m jnp\u001b[38;5;241m.\u001b[39mlinspace(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m3000\u001b[39m)\n\u001b[1;32m 6\u001b[0m kde \u001b[38;5;241m=\u001b[39m gaussian_kde(pred_obs)\n", + "\u001b[0;31mNameError\u001b[0m: name 'p_posterior_samples' is not defined" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(dpi=100, figsize=(5, 3))\n", + "ax = fig.add_subplot(1, 1, 1)\n", + "ax.hist(pred_obs, bins=15, density=True, alpha=0.5, label = \"Prior distribution\")\n", + "ax.hist(p_posterior_samples, bins=15, density=True, alpha=0.5, label = \"Posterior distribution\")\n", + "x = jnp.linspace(0, 1, 3000)\n", + "kde = gaussian_kde(pred_obs)\n", + "ax.plot(x, kde(x), color='C0', lw=3, alpha=0.5)\n", + "kde = gaussian_kde(p_posterior_samples)\n", + "ax.plot(x, kde(x), color='C1', lw=3, alpha=0.5)\n", + "ax.set_xlabel('p')\n", + "ax.set_xlim(0, 1)\n", + "ax.grid(0.3)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# exatract samples of parameter p\n", + "p_samples = mcmc.get_samples()\n", + "p_posterior_samples = p_samples['p']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "NumPyro is a versatile library for probabilistic programming that combines the power of NumPy and Pyro. In this introductory tutorial, we've covered the basics of defining a probabilistic model, performing MCMC inference, and visualizing the results. As you delve deeper into probabilistic programming with NumPyro, you'll be able to build more complex and customized models for your specific applications. Happy modeling!" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/_config.yml b/_config.yml index b5c8913..03310cf 100644 --- a/_config.yml +++ b/_config.yml @@ -39,4 +39,8 @@ parse: # don't forget to list any other extensions you want enabled, # including those that are enabled by default! - amsmath - - dollarmath \ No newline at end of file + - dollarmath + +sphinx: + extra_extensions: + - sphinxcontrib.tikz \ No newline at end of file diff --git a/_toc.yml b/_toc.yml index cf745d8..562c0f3 100644 --- a/_toc.yml +++ b/_toc.yml @@ -7,4 +7,8 @@ chapters: - file: 02_about.md - file: 03_intro_epi.md - file: 04_probability_distributions.ipynb -- file: 05_intro_to_Numpyro.ipynb \ No newline at end of file +- file: 05_Bayesian_inference.ipynb +- file: 06_Monte_Carlo_and_MCMC.ipynb +- file: 07_PPLs.md +- file: 08_intro_to_Numpyro.ipynb +- file: 100_acknowledgements.md \ No newline at end of file