diff --git a/02_about.md b/02_about.md
index 87021aa..88d00f0 100644
--- a/02_about.md
+++ b/02_about.md
@@ -2,24 +2,23 @@
 
 These lecture notes cover the course which will be taught during three weeks from 25 March to 12 April 2024 to a MSc ["AI for Science"](https://ai.aims.ac.za/) cohort at the [African Institute for Mathematical Sciences (AIMS)](https://aims.ac.za/), South Africa. After the course, I plan to keep improving the materials since they will be helpful for future stundents and collaborators.
 
-If you notice any typos, mistakes or inconsistencies in these course notes, please email them to `elizaveta [dot] p [dot] [insert my surname] [at] gmail [dot] com`.
+If you notice any typos, mistakes or inconsistencies, please email them to `elizaveta [dot] p [dot] [insert my surname] [at] gmail [dot] com`.
 
-Tentative outline of the course is presented below but might be adjusted during the course.
+Tentative outline of the course is presented below but might be adjusted at a later point.
 
 
 * <span style="color:orange">Week 1 - Probabilistic programming</span>.
     * Day 1
         * Introduction to modelling in epidemiology
-        * Probability distributions refresher
+        * Probability distributions and random variables
         * Bayesian inference
         * Focus on priors
     * Day 2
-    	* numerical methods to obtain posterior
-	    * MCMC by hand
-	    * convergence diagnostics
-	    * PPLs
-	    * Intro to Numpyro: model, inference, check convergence
-	    * Bayesian workflow: prior predictive and posterior predictive
+	    * The Monte Carlo methods and MCMC
+	    * Convergence diagnostics
+	    * Probabilistic programming
+	    * Introduction to Numpyro
+	    * Bayesian workflow
     * Day 3 
     	* logistic regression with Numpyro
         * Poisson and NegativeBinomial regression with Numpyro
diff --git a/03_intro_epi.md b/03_intro_epi.md
index 9b4a470..192cfa0 100644
--- a/03_intro_epi.md
+++ b/03_intro_epi.md
@@ -1,15 +1,15 @@
 # Introduction to Modelling in epidemiology
 
-In this course we will consider a range of models used in epidemiology - from spatial statistics to disease transmission modelling - and their probabilistic formulation. In order to perform Bayesian inference we will use the probabilistic programing language (PPL) Numpyro.
+In this course we will consider a range of models used in epidemiology - from <font color='orange'>hierarchical modelling</font> and <font color='orange'>spatial statistics</font> to <font color='orange'>disease transmission modelling</font> - and their probabilistic formulation. In order to perform Bayesian inference we will use the probabilistic programing language (PPL) Numpyro.
 
-Let's uncover each of the three key terms of the course - **epidemioligy**, **probabilistic modelling** and **probablistic programming**. You can think of them as the 'What?', 'Why?' and 'How?' of the course, correspondingly.
+Let's uncover each of the three key terms of the course - **epidemioligy**, **Bayesian modelling** and **probablistic programming**. You can think of them as the 'What?', 'Why?' and 'How?' of the course, correspondingly.
 
 (epidemiology)=
 ## Epidemiology
 
-Epidemiology is the 'What?' of this course, i.e. 'What real-life phenomena do we want to study?. 
+Epidemiology is the 'What?' of this course, i.e. 'What real-life phenomena do we want to study?'
 
-The range of computational models which we will cover is motivated by questios in epidemiology and public health.
+The range of computational models which we will cover is motivated by questions in epidemiology and public health.
 
 Epidemiology is the study of how diseases and health-related events are distributed within populations and the factors that influence these distributions. It is a branch of public health that focuses on understanding the patterns, causes, and effects of diseases and health conditions on a large scale. Epidemiologists collect and analyze *data* to investigate the occurrence of health outcomes, their risk factors, and the impact of various interventions or preventive measures.
 
@@ -17,29 +17,35 @@ Epidemiological studies are essential for understanding the health of population
 
 Key aspects of epidemiology include:
 
-- **Disease Surveillance:** Epidemiologists monitor the occurrence of diseases and health-related events over time and across different geographic areas. This involves tracking the number of cases, identifying outbreaks, and assessing trends in disease incidence and prevalence.
+- **Disease Surveillance:** Epidemiologists <font color='orange'>monitor</font> the occurrence of diseases and health-related events over time and across different geographic areas. This involves tracking the number of cases, identifying outbreaks, and assessing trends in disease incidence and prevalence.
 
-- **Outbreak Investigation:** Epidemiologists are often involved in investigating disease outbreaks, such as foodborne illnesses, infectious disease outbreaks, or clusters of chronic diseases. They work to identify the source of the outbreak and implement measures to contain and prevent further spread.
+- **Outbreak Investigation:** Epidemiologists are often involved in <font color='orange'>investigating</font> disease outbreaks, such as foodborne illnesses, infectious disease outbreaks, or clusters of chronic diseases. They work to identify the source of the outbreak and implement measures to contain and prevent further spread.
 
-- **Identifying Risk Factors:** Epidemiological studies aim to identify the factors that are associated with increases likelihood of developing a particular disease. These risk factors can include genetic predisposition, environmental exposures, lifestyle choices, and social determinants of health.
+```{margin}
+It is important to distinguish <font color='orange'>associative</font> stidies with those where researchers try to oncover <font color='orange'>causal</font> relashionships between risk factors and outcomes.
+```
+- **Identifying Risk Factors:** Epidemiological studies aim to identify the <font color='orange'>factors</font> that are <font color='orange'>associated</font> with increases likelihood of developing a particular disease. These risk factors can include genetic predisposition, environmental exposures, lifestyle choices, and social determinants of health.
 
-- **Disease Prevention and Control:** The insights gained from epidemiological research are crucial for designing and implementing public health interventions and policies aimed at preventing and controlling diseases. This may involve vaccination campaigns, health education programs, quarantine measures, and more.
+- **Disease Prevention and Control:** The insights gained from epidemiological research are crucial for designing and implementing public health <font color='orange'>interventions</font> and <font color='orange'>policies</font> aimed at preventing and controlling diseases. This may involve vaccination campaigns, health education programs, quarantine measures, and more.
 
-- **Public Health Planning:** Epidemiological data and findings play a vital role in informing public health planning and resource allocation. This includes assessing healthcare needs, identifying at-risk populations, and developing strategies to improve overall health outcomes.
+- **Public Health Planning:** Epidemiological data and findings play a vital role in informing public health planning and <font color='orange'>resource allocation</font>. This includes assessing healthcare needs, identifying at-risk populations, and developing strategies to improve overall health outcomes.
 
-- **Causality Assessment:** Epidemiologists use various study designs, including cohort studies, case-control studies, and randomized controlled trials, to determine if a specific factor or intervention causes a particular disease.
+- **Causality Assessment:** Epidemiologists use various study designs, including cohort studies, case-control studies, and randomized controlled trials, to determine if a specific factor or intervention <font color='orange'>causes</font> a particular disease.
 
-- **Epidemiological Models:** Mathematical and statistical models are frequently used in epidemiology to simulate disease spread and predict future trends. These models help in making informed decisions and planning interventions.
+- **Epidemiological Models:** Mathematical and statistical models are frequently used in epidemiology to simulate <font color='orange'>disease spread</font> and estimate <font color='orange'>disease distribution</font>. These models help in making informed decisions and planning interventions.
 
-Some models that we will build in this course are more relevant to **infectious**, and some to **chronic** diseases. The scope of applicbility will be clarified for each model once it is introduced. 
+Some models that we will build in this course are more relevant to **infectious**, and some to **chronic** diseases. The scope of applicability will be clarified for each model when it is introduced. 
 
-## Probabilistic modelling
+## Bayesian modelling
 
-Probabilistic modelling is the 'How?' of this course, i.e. 'How can we describe the generative process leading to the data we observe?'.
+```{margin}
+You musy have hearda lot recently about <font color='orange'>generative AI</font> and <font color='orange'>deep generative modelling (DGM)</font>. It is indeed the same 'generative' idea as we are talking here about. The difference is that DGM uses deep learning and neural network for the generative mechanism, and in traditionla epidemioligy it is more common to use statistical and mechanistic models for such generation. Having said that, we will DGMs in this course too.
+```
+Bayesian modelling is the 'How?' of this course, i.e. 'How can we describe the <font color='orange'>generative process</font> leading to the data we observe?'. We will use the term 'Bayesian' and 'probabilistic' interchangeably.
 
 Probabilistic modeling is a mathematical and statistical framework used to incorporate **uncertainty** and **randomness** into models to account for variability and its sources in real-world phenomena. It involves using probability theory to describe and quantify the uncertainty associated with different events, outcomes, or variables. The primary goal of probabilistic modeling is to make predictions, infer information, or make decisions in situations where there is inherent uncertainty. Probabilistic modeling is a powerful tool for dealing with real-world complexities in a quantitative manner. It plays a crucial role in data analysis, machine learning, and decision-making processes where probabilistic reasoning is necessary.
 
-Probabilistic modelling in epidemiology helps epidemiologists and public health officials make informed decisions by quantifying uncertainty, simulating realistic disease dynamics, and assessing the potential impact of various interventions. It is a powerful tool for improving our understanding of health outcomes and guiding effective public health responses.
+Probabilistic modelling in epidemiology helps epidemiologists and public health officials make informed decisions by <font color='orange'>quantifying uncertainty</font>, simulating realistic disease dynamics, and assessing the potential impact of various interventions. It is a powerful tool for improving our understanding of health outcomes and guiding effective public health responses.
 
 %Here's why probabilistic modelling is important for epidemiology:
 
@@ -74,7 +80,7 @@ Some key concepts and components of probabilistic modeling are as follows:
 - **Monte Carlo Methods:** Monte Carlo methods are a class of computational techniques used to estimate complex probabilistic models through random sampling. They involve generating random samples from probability distributions to approximate quantities of interest.
 
 
-## Probabilistics programming
+## Probabilistic programming
 
 
 Probabilistic programming is a specialized approach to building and analyzing probabilistic models that offers several advantages for epidemiology and the study of infectious disease dynamics:
diff --git a/04_probability_distributions.ipynb b/04_probability_distributions.ipynb
index 61bf032..9bce5fc 100644
--- a/04_probability_distributions.ipynb
+++ b/04_probability_distributions.ipynb
@@ -11,13 +11,13 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "To embark on an exciting journey into the realm of probabilistic thinking and programming, it's essential to establish a solid foundation. This foundation entails gaining a comprehensive understanding of probability distributions, mastering fundamental probability principles, and acquiring the skills to manipulate probabilities within code.\n",
+        "To embark on an exciting journey into the realm of probabilistic thinking and programming, it is essential to establish a solid foundation. This foundation entails gaining a comprehensive understanding of probability distributions, mastering fundamental probability principles, and acquiring the skills to manipulate probabilities within code.\n",
         "\n",
         "Probability distributions and random variables serve as tools for describing and performing calculations related to random events, specifically those whose outcomes are uncertain. An illustrative instance of such an uncertain event would be the act of flipping a coin or rolling a dice. In the former case, the potential outcomes are heads or tails.\n",
         "\n",
-        "*In the context of epidemiological modelling, we will encounter data of different type and origin. It is crucial to grasp the suitability of different probability distributions for modeling specific types of data.*\n",
+        "In the context of epidemiological modelling, we will encounter data of different type and origin. It is crucial to grasp the suitability of different probability distributions for modeling specific types of data.\n",
         "\n",
-        "Since the PPL we will be using for this course is **Numpyro**, also in this section we will use the implementations of distribution from this library `import numpyro.distributions as dist`"
+        "Since the probabilistic programming language that we will be using for this course is **Numpyro**, also in this section we will use the implementations of distributions from this library avalable via `import numpyro.distributions as dist`"
       ]
     },
     {
@@ -62,7 +62,7 @@
       "source": [
         "### The Bernoulli distribution\n",
         "\n",
-        "A Bernoulli distribution is used to describe random events with two possible outcomes e.g. when we have a random variable $X$ that takes on one of the two values $x \\in \\{0, 1\\}$ with probabilities $1-p$ and $p, 0 \\le p \\le 1$ respectively:\n",
+        "A Bernoulli distribution is used to describe random events with <span style=\"color:orange\">two possible outcomes</span> e.g. when we have a random variable $X$ that takes on one of the two values $x \\in \\{0, 1\\}$ with probabilities $1-p$ and $p, 0 \\le p \\le 1$ respectively:\n",
         "\n",
         "\\begin{align*}\n",
         "p(X = 1) &= p, \\\\\n",
@@ -75,7 +75,7 @@
         "A *discrete* probability distribution can be uniquely defined by its *probability mass function (PMF)*.\n",
         "\n",
         "```{margin}\n",
-        "The term 'mass' is used to underline that the support of the distribution is discrete, and each possible values carries a certain `mass` (probability).\n",
+        "The term 'mass' is used to underline that the support of the distribution is discrete, and each possible value carries a certain `mass` (probability).\n",
         "For continuous distributions, the analogous is *probability density function (PDF)*, we will see those later.\n",
         "```\n",
         "For the Bernoulli distribution, we write the PMF as\n",
@@ -92,7 +92,7 @@
         "\n",
         "Now let's construct a Bernoulli distribution in code so that we can play around with it and get some intuition.\n",
         "\n",
-        "**Note:** In this practical, we are going to use `numpyro` to construct our distributions. However, there are several other `jax` packages that work similarly (e.g., `distrax`) as well as several options for `tensorflow` (e.g., `tensorflow_probability`) and `pytorch` (e.g., `torch.distribution`). Don't worry too much about the specifics of how `numpyro` works, e.g., the names of the distributions and their arguments. Instead try to understand what the code is doing."
+        "**Note:** In this practical, we are going to use `numpyro` to construct our distributions. However, there are several other `jax` packages that work similarly (e.g., `distrax`) as well as several options for `tensorflow` (e.g., `tensorflow_probability`) and `pytorch` (e.g., `torch.distribution`)."
       ]
     },
     {
@@ -364,6 +364,15 @@
         "**Exercise:**  plot a panel of histograms where you vary probability $p$ horizontally and numher of samples $n$ vertically. "
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Common usage\n",
+        "\n",
+        "Bernoulli dsitribution is commonly used as a likelihood in models with bimary outcomes. For example, to model disease prevalence."
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -641,7 +650,11 @@
     {
       "cell_type": "markdown",
       "metadata": {},
-      "source": []
+      "source": [
+        "#### Common usage\n",
+        "\n",
+        "Binomial dsitribution is commonly used as a likelihood in models with bimary outcomes. For example, to model disease prevalence."
+      ]
     },
     {
       "cell_type": "markdown",
diff --git a/05_Bayesian_inference.ipynb b/05_Bayesian_inference.ipynb
index c297213..a3739d8 100644
--- a/05_Bayesian_inference.ipynb
+++ b/05_Bayesian_inference.ipynb
@@ -99,46 +99,6 @@
       "metadata": {},
       "source": []
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Chosing the prior distribution\n",
-        "\n",
-        "In the doctor example, if the doctor we go to has access to history, but only from when the patient was a child and not for their recent years as an adult, they might make the wrong inferences about the current cause of a headache. For example, if they don't know that the patient was in a car accident last month and banged their head, they could get the cause of the headache very wrong! 🥴\n",
-        "\n",
-        "The choice of the  <font color='purple'>`prior`</font> 💭 is really important! It can depend on a few things:\n",
-        "\n",
-        "- Type of distribution (we will see this in a second)\n",
-        "- Hyperparameters/hyperpriors\n",
-        "- Often there is a 'natural' candidate for prior choice\n",
-        "- Whether it creates a posterior that is mathematically solvable or not\n",
-        "- Some do (conjugate <font color='purple'>`prior`</font>)\n",
-        "- Most do not (non-conjugate)...\n",
-        "\n",
-        "## The influence of prior\n",
-        "\n",
-        "Let us explore how much <font color='purple'>`priors`</font>  can actually influence the posterior. Since tha marginal distribution $p(y)$ does not depend on the parameters, we will only explore the posterior up the to proportionality term.\n",
-        "\n",
-        "$$p(\\theta |y ) ∝ p(y| \\theta) p(\\theta).$$\n",
-        "\n",
-        "If we have access to point-wise evaluations of the <font color='teal'>`likelihood`</font> $p(y | \\theta)$ and prior $p(\\theta)$, we can compute their product to obtain this posterior.\n",
-        "\n",
-        "Consider the coin tossing problem, which we describe using the Bernoulli distribution for a single trial, and the product of Bernoullis for multiple trials. When we compute a <font color='teal'>`likelihood`</font> by multiplying independent Bernoulli trials, this is like a *permutation* in so far as the *order* of the tosses matters.\n",
-        "\n",
-        "Another formulation for a repeated Bernoulli random variable is to consider the _proportion_ of correct trials without considering order. We can normalise for this using the formula for combinations, which you may know of as \"$n$ choose $k$.\" This lets us define a random variable on the number of succeses in $n$ trials called a **Binomial random variable**.\n",
-        "\n",
-        "Let's say that out of\n",
-        "$$n=10$$\n",
-        "tosses we obtained\n",
-        "$$h=6$$\n",
-        "successes.\n",
-        "\n",
-        "Let's consider: what is the probability of \"success\" for this coin? We'll simulate some examples using a binomial random variable.\n",
-        "\n",
-        "**[Optional]:** *Show that the <font color='teal'>`likelihood`</font> for coin tosses calculated using independent Bernoulli random variables (a Bernoulli process) is proportional (up to a constant) to the likelihood for coin tosses calculated using a Binomial random variable.*"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -157,204 +117,6 @@
         "import matplotlib.pyplot as plt"
       ]
     },
-    {
-      "cell_type": "code",
-      "execution_count": 9,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "##############################################\n",
-        "# prior x likelihood = posterior\n",
-        "##############################################\n",
-        "\n",
-        "h=6\n",
-        "n=9\n",
-        "p=h/n\n",
-        "\n",
-        "# define grid\n",
-        "grid_points=100\n",
-        "\n",
-        "# define regular grid in the (0,1) interval\n",
-        "p_grid = jnp.linspace(0, 1, grid_points)\n",
-        "\n",
-        "# compute likelihood at each point in the grid\n",
-        "log_prob_likelihood = dist.Binomial(n, probs=p_grid).log_prob(h)\n",
-        "\n",
-        "# normalize likelihood to get the likelihood PMF\n",
-        "likelihood_pmf = jnp.exp(log_prob_likelihood - jnp.max(log_prob_likelihood)) / jnp.sum(jnp.exp(log_prob_likelihood - jnp.max(log_prob_likelihood)))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 10,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "def computePosterior(likelihood, prior):\n",
-        "    # this functionm computes posterior\n",
-        "    # and plots the result\n",
-        "\n",
-        "    # compute product of likelihood and prior\n",
-        "    unstd_posterior = likelihood * prior\n",
-        "\n",
-        "    # standardize posterior\n",
-        "    posterior = unstd_posterior / unstd_posterior.sum()\n",
-        "\n",
-        "    plt.figure(figsize=(17, 3))\n",
-        "    ax1 = plt.subplot(131)\n",
-        "    ax1.set_title(\"Prior\")\n",
-        "    ax1.grid(0.3)\n",
-        "    plt.plot(p_grid, prior,color='purple')\n",
-        "\n",
-        "    ax2 = plt.subplot(132)\n",
-        "    ax2.set_title(\"Likelihood\")\n",
-        "    ax2.grid(0.3)\n",
-        "    plt.plot(p_grid, likelihood,color='teal')\n",
-        "\n",
-        "    ax3 = plt.subplot(133)\n",
-        "    ax3.set_title(\"Posterior\")\n",
-        "    plt.plot(p_grid, posterior,color='gray')\n",
-        "    ax3.grid(0.3)\n",
-        "    plt.show()\n",
-        "\n",
-        "    return"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Prior 1 - Uniform\n",
-        "\n",
-        "Our first <font color='purple'>`prior`</font> will be a Uniform distribution:\n",
-        "\n",
-        "$$p(\\theta) = 1.$$\n",
-        "\n",
-        "This means we don't think the coin is likely to be weighted or not: the probability of heads could take any value between 0 and 1 equally.\n",
-        "\n",
-        "This is the same as not having a prior at all! So we should expect the likelihood and posterior distributions to look the same (if that isn't intuitive to you, speak to a tutor).\n",
-        "\n",
-        "Run the code cell below to confirm your intuitions."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 11,
-      "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 1700x300 with 3 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        }
-      ],
-      "source": [
-        "# Uniform prior\n",
-        "prior1 = jnp.repeat(1, grid_points)\n",
-        "\n",
-        "# visualise prior, likelihood, posterior\n",
-        "posterior1 = computePosterior(likelihood_pmf, prior1)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Prior 2 - step function\n",
-        "\n",
-        "Perhaps we are pretty sure that heads is more likely than tails i.e. the coin is weighted, but we don't know by how much.\n",
-        "\n",
-        "We could set this up as a step-function where the probability is 0 below a certain value, and uniform after.\n",
-        "\n",
-        "**Code task B4**: Implement the step-function prior:\n",
-        "\n",
-        "$$p(\\theta) = 1.$$\n",
-        "\n",
-        "$$\n",
-        "p(\\theta) = \\begin{cases}\n",
-        "0 \\text{ if } \\theta <= 0.5 \\\\\n",
-        "1 \\text{ otherwise. }\n",
-        "\\end{cases}\n",
-        "$$\n",
-        "\n",
-        "How do you think the posterior will change? Sketch the prior to give yourself some intuition!"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 14,
-      "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 1700x300 with 3 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        }
-      ],
-      "source": [
-        "prior2 = (p_grid >= 0.5).astype(int)\n",
-        "posterior2 = computePosterior(likelihood_pmf, prior2)\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Prior 3\n",
-        "\n",
-        "Let's imagine some prior that is centered at 0.5, and decays (exponentially) on either side. Run the below code and validate that this prior looks like you would expect, and shifts the likelihood to the posterior as you would expect."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 15,
-      "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 1700x300 with 3 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        }
-      ],
-      "source": [
-        "prior3 = jnp.exp(- 5 * abs(p_grid - 0.5))\n",
-        "posterior3 = computePosterior(likelihood_pmf, prior3)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Informative or non-informative priors\n",
-        "\n",
-        "Choosing a prior is hard!\n",
-        "\n",
-        "- Main source of criticism from non-Bayesians is how priors are chosen.\n",
-        "- Priors should be informed by existing knowledge.\n",
-        "- But what if we don't know anything before (prior to) inference?\n",
-        "- Non-informative/informative priors are outside scope of this section, but something to pay attention to when you encounter these models in the wild! 🐅"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": []
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -426,27 +188,6 @@
         "\n",
         "**Group task 6**: Does a point estimate tell us anything about our uncertainty or the distribution from which we draw the estimate? Discuss the difference between <font color='green'>`point estimates`</font> and estimating a *distribution*."
       ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
     }
   ],
   "metadata": {
diff --git a/100_acknowledgements.md b/100_acknowledgements.md
index 8f98999..45dc170 100644
--- a/100_acknowledgements.md
+++ b/100_acknowledgements.md
@@ -1,7 +1,8 @@
-# Acknowledgements
+# Acknowledgements and links
 
 - AIMS and Ulrich for the invitation
 - Kira and James for writing together the DLI-23 practical
 - 2021 Statistical Rethinking (with Numpyro) reading group at Imperial: Swapnil, Iwona, Tim (Theo? Giovanni?)
 - Stan ODE co-authors
-- Lorenzo Ciardo for telling me about the Buffon's needle problem
\ No newline at end of file
+- Lorenzo Ciardo for telling me about the Buffon's needle problem
+- Richard McEarlth for posting the prior-likelihood conflict example: https://twitter.com/rlmcelreath/status/1701165075493470644
\ No newline at end of file
diff --git a/11_hierarchical_modelling.ipynb b/11_hierarchical_modelling.ipynb
index 2ffd174..80e6a3e 100644
--- a/11_hierarchical_modelling.ipynb
+++ b/11_hierarchical_modelling.ipynb
@@ -16,7 +16,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## No Pooling:\n",
+        "## No Pooling\n",
         "\n",
         "In the \"no pooling\" approach, each data point is treated independently without any grouping or hierarchical structure. This approach assumes that there is no shared information between data points, which can be overly simplistic when there is underlying structure or dependencies in the data."
       ]
@@ -94,7 +94,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Complete Pooling:\n",
+        "## Complete Pooling\n",
         "\n",
         "In the \"complete pooling\" approach, all data points are treated as if they belong to a single group or population, and the model estimates a single set of parameters for the entire dataset. This approach assumes that there is no variation between data points, which can be overly restrictive when there is actual heterogeneity in the data."
       ]
@@ -144,132 +144,11 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Partial Pooling:\n",
+        "## Partial Pooling\n",
         "\n",
         "In the \"partial pooling\" approach, the data is grouped into distinct categories or levels, and each group has its own set of parameters. However, these parameters are constrained by a shared distribution, allowing for both individual variation within groups and shared information across groups."
       ]
     },
-    {
-      "cell_type": "code",
-      "execution_count": 28,
-      "metadata": {},
-      "outputs": [
-        {
-          "ename": "TypeError",
-          "evalue": "Using a non-tuple sequence for multidimensional indexing is not allowed; use `arr[array(seq)]` instead of `arr[seq]`. See https://github.com/google/jax/issues/4564 for more information.",
-          "output_type": "error",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-            "Cell \u001b[0;32mIn[28], line 21\u001b[0m\n\u001b[1;32m     19\u001b[0m nuts_kernel \u001b[38;5;241m=\u001b[39m NUTS(partial_pooling_model)\n\u001b[1;32m     20\u001b[0m mcmc \u001b[38;5;241m=\u001b[39m MCMC(nuts_kernel, num_samples\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1000\u001b[39m, num_warmup\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m500\u001b[39m)\n\u001b[0;32m---> 21\u001b[0m \u001b[43mmcmc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgroup_ids\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/mcmc.py:634\u001b[0m, in \u001b[0;36mMCMC.run\u001b[0;34m(self, rng_key, extra_fields, init_params, *args, **kwargs)\u001b[0m\n\u001b[1;32m    632\u001b[0m map_args \u001b[38;5;241m=\u001b[39m (rng_key, init_state, init_params)\n\u001b[1;32m    633\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_chains \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 634\u001b[0m     states_flat, last_state \u001b[38;5;241m=\u001b[39m \u001b[43mpartial_map_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmap_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    635\u001b[0m     states \u001b[38;5;241m=\u001b[39m tree_map(\u001b[38;5;28;01mlambda\u001b[39;00m x: x[jnp\u001b[38;5;241m.\u001b[39mnewaxis, \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m], states_flat)\n\u001b[1;32m    636\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/mcmc.py:416\u001b[0m, in \u001b[0;36mMCMC._single_chain_mcmc\u001b[0;34m(self, init, args, kwargs, collect_fields)\u001b[0m\n\u001b[1;32m    414\u001b[0m \u001b[38;5;66;03m# Check if _sample_fn is None, then we need to initialize the sampler.\u001b[39;00m\n\u001b[1;32m    415\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m init_state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m (\u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msampler, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_sample_fn\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m--> 416\u001b[0m     new_init_state \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msampler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    417\u001b[0m \u001b[43m        \u001b[49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    418\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_warmup\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    419\u001b[0m \u001b[43m        \u001b[49m\u001b[43minit_params\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    420\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    421\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    422\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    423\u001b[0m     init_state \u001b[38;5;241m=\u001b[39m new_init_state \u001b[38;5;28;01mif\u001b[39;00m init_state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m init_state\n\u001b[1;32m    424\u001b[0m sample_fn, postprocess_fn \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_cached_fns()\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/hmc.py:713\u001b[0m, in \u001b[0;36mHMC.init\u001b[0;34m(self, rng_key, num_warmup, init_params, model_args, model_kwargs)\u001b[0m\n\u001b[1;32m    708\u001b[0m \u001b[38;5;66;03m# vectorized\u001b[39;00m\n\u001b[1;32m    709\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    710\u001b[0m     rng_key, rng_key_init_model \u001b[38;5;241m=\u001b[39m jnp\u001b[38;5;241m.\u001b[39mswapaxes(\n\u001b[1;32m    711\u001b[0m         vmap(random\u001b[38;5;241m.\u001b[39msplit)(rng_key), \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m    712\u001b[0m     )\n\u001b[0;32m--> 713\u001b[0m init_params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_init_state\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    714\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrng_key_init_model\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minit_params\u001b[49m\n\u001b[1;32m    715\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    716\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_potential_fn \u001b[38;5;129;01mand\u001b[39;00m init_params \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    717\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m    718\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mValid value of `init_params` must be provided with\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m `potential_fn`.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    719\u001b[0m     )\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/hmc.py:657\u001b[0m, in \u001b[0;36mHMC._init_state\u001b[0;34m(self, rng_key, model_args, model_kwargs, init_params)\u001b[0m\n\u001b[1;32m    650\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_init_state\u001b[39m(\u001b[38;5;28mself\u001b[39m, rng_key, model_args, model_kwargs, init_params):\n\u001b[1;32m    651\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    652\u001b[0m         (\n\u001b[1;32m    653\u001b[0m             new_init_params,\n\u001b[1;32m    654\u001b[0m             potential_fn,\n\u001b[1;32m    655\u001b[0m             postprocess_fn,\n\u001b[1;32m    656\u001b[0m             model_trace,\n\u001b[0;32m--> 657\u001b[0m         ) \u001b[38;5;241m=\u001b[39m \u001b[43minitialize_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    658\u001b[0m \u001b[43m            \u001b[49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    659\u001b[0m \u001b[43m            \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_model\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    660\u001b[0m \u001b[43m            \u001b[49m\u001b[43mdynamic_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    661\u001b[0m \u001b[43m            \u001b[49m\u001b[43minit_strategy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_init_strategy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    662\u001b[0m \u001b[43m            \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    663\u001b[0m \u001b[43m            \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    664\u001b[0m \u001b[43m            \u001b[49m\u001b[43mforward_mode_differentiation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_forward_mode_differentiation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    665\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    666\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m init_params \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    667\u001b[0m             init_params \u001b[38;5;241m=\u001b[39m new_init_params\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/util.py:656\u001b[0m, in \u001b[0;36minitialize_model\u001b[0;34m(rng_key, model, init_strategy, dynamic_args, model_args, model_kwargs, forward_mode_differentiation, validate_grad)\u001b[0m\n\u001b[1;32m    646\u001b[0m model_kwargs \u001b[38;5;241m=\u001b[39m {} \u001b[38;5;28;01mif\u001b[39;00m model_kwargs \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m model_kwargs\n\u001b[1;32m    647\u001b[0m substituted_model \u001b[38;5;241m=\u001b[39m substitute(\n\u001b[1;32m    648\u001b[0m     seed(model, rng_key \u001b[38;5;28;01mif\u001b[39;00m is_prng_key(rng_key) \u001b[38;5;28;01melse\u001b[39;00m rng_key[\u001b[38;5;241m0\u001b[39m]),\n\u001b[1;32m    649\u001b[0m     substitute_fn\u001b[38;5;241m=\u001b[39minit_strategy,\n\u001b[1;32m    650\u001b[0m )\n\u001b[1;32m    651\u001b[0m (\n\u001b[1;32m    652\u001b[0m     inv_transforms,\n\u001b[1;32m    653\u001b[0m     replay_model,\n\u001b[1;32m    654\u001b[0m     has_enumerate_support,\n\u001b[1;32m    655\u001b[0m     model_trace,\n\u001b[0;32m--> 656\u001b[0m ) \u001b[38;5;241m=\u001b[39m \u001b[43m_get_model_transforms\u001b[49m\u001b[43m(\u001b[49m\u001b[43msubstituted_model\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    657\u001b[0m \u001b[38;5;66;03m# substitute param sites from model_trace to model so\u001b[39;00m\n\u001b[1;32m    658\u001b[0m \u001b[38;5;66;03m# we don't need to generate again parameters of `numpyro.module`\u001b[39;00m\n\u001b[1;32m    659\u001b[0m model \u001b[38;5;241m=\u001b[39m substitute(\n\u001b[1;32m    660\u001b[0m     model,\n\u001b[1;32m    661\u001b[0m     data\u001b[38;5;241m=\u001b[39m{\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    665\u001b[0m     },\n\u001b[1;32m    666\u001b[0m )\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/util.py:450\u001b[0m, in \u001b[0;36m_get_model_transforms\u001b[0;34m(model, model_args, model_kwargs)\u001b[0m\n\u001b[1;32m    448\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_get_model_transforms\u001b[39m(model, model_args\u001b[38;5;241m=\u001b[39m(), model_kwargs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m    449\u001b[0m     model_kwargs \u001b[38;5;241m=\u001b[39m {} \u001b[38;5;28;01mif\u001b[39;00m model_kwargs \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m model_kwargs\n\u001b[0;32m--> 450\u001b[0m     model_trace \u001b[38;5;241m=\u001b[39m \u001b[43mtrace\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_trace\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    451\u001b[0m     inv_transforms \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m    452\u001b[0m     \u001b[38;5;66;03m# model code may need to be replayed in the presence of deterministic sites\u001b[39;00m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/handlers.py:171\u001b[0m, in \u001b[0;36mtrace.get_trace\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    163\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_trace\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m    164\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    165\u001b[0m \u001b[38;5;124;03m    Run the wrapped callable and return the recorded trace.\u001b[39;00m\n\u001b[1;32m    166\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    169\u001b[0m \u001b[38;5;124;03m    :return: `OrderedDict` containing the execution trace.\u001b[39;00m\n\u001b[1;32m    170\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 171\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    172\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrace\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/primitives.py:105\u001b[0m, in \u001b[0;36mMessenger.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n\u001b[1;32m    104\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m--> 105\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/primitives.py:105\u001b[0m, in \u001b[0;36mMessenger.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n\u001b[1;32m    104\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m--> 105\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/primitives.py:105\u001b[0m, in \u001b[0;36mMessenger.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n\u001b[1;32m    104\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m--> 105\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-            "Cell \u001b[0;32mIn[28], line 14\u001b[0m, in \u001b[0;36mpartial_pooling_model\u001b[0;34m(group_ids, data)\u001b[0m\n\u001b[1;32m     11\u001b[0m     group_sigma \u001b[38;5;241m=\u001b[39m numpyro\u001b[38;5;241m.\u001b[39msample(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgroup_sigma\u001b[39m\u001b[38;5;124m\"\u001b[39m, dist\u001b[38;5;241m.\u001b[39mExponential(\u001b[38;5;241m1\u001b[39m))\n\u001b[1;32m     13\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m numpyro\u001b[38;5;241m.\u001b[39mplate(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdata\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mlen\u001b[39m(data)):\n\u001b[0;32m---> 14\u001b[0m     mu \u001b[38;5;241m=\u001b[39m numpyro\u001b[38;5;241m.\u001b[39mdeterministic(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmu\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[43mgroup_mu\u001b[49m\u001b[43m[\u001b[49m\u001b[43mgroup_ids\u001b[49m\u001b[43m]\u001b[49m)\n\u001b[1;32m     15\u001b[0m     sigma \u001b[38;5;241m=\u001b[39m numpyro\u001b[38;5;241m.\u001b[39mdeterministic(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msigma\u001b[39m\u001b[38;5;124m\"\u001b[39m, group_sigma[group_ids])\n\u001b[1;32m     16\u001b[0m     obs \u001b[38;5;241m=\u001b[39m numpyro\u001b[38;5;241m.\u001b[39msample(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobs\u001b[39m\u001b[38;5;124m\"\u001b[39m, dist\u001b[38;5;241m.\u001b[39mNormal(mu, sigma), obs\u001b[38;5;241m=\u001b[39mdata)\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/jax/_src/array.py:319\u001b[0m, in \u001b[0;36mArrayImpl.__getitem__\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m    317\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m lax_numpy\u001b[38;5;241m.\u001b[39m_rewriting_take(\u001b[38;5;28mself\u001b[39m, idx)\n\u001b[1;32m    318\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 319\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mlax_numpy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_rewriting_take\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43midx\u001b[49m\u001b[43m)\u001b[49m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/jax/_src/numpy/lax_numpy.py:4290\u001b[0m, in \u001b[0;36m_rewriting_take\u001b[0;34m(arr, idx, indices_are_sorted, unique_indices, mode, fill_value)\u001b[0m\n\u001b[1;32m   4284\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m (\u001b[38;5;28misinstance\u001b[39m(aval, core\u001b[38;5;241m.\u001b[39mDShapedArray) \u001b[38;5;129;01mand\u001b[39;00m aval\u001b[38;5;241m.\u001b[39mshape \u001b[38;5;241m==\u001b[39m () \u001b[38;5;129;01mand\u001b[39;00m\n\u001b[1;32m   4285\u001b[0m         dtypes\u001b[38;5;241m.\u001b[39missubdtype(aval\u001b[38;5;241m.\u001b[39mdtype, np\u001b[38;5;241m.\u001b[39minteger) \u001b[38;5;129;01mand\u001b[39;00m\n\u001b[1;32m   4286\u001b[0m         \u001b[38;5;129;01mnot\u001b[39;00m dtypes\u001b[38;5;241m.\u001b[39missubdtype(aval\u001b[38;5;241m.\u001b[39mdtype, dtypes\u001b[38;5;241m.\u001b[39mbool_) \u001b[38;5;129;01mand\u001b[39;00m\n\u001b[1;32m   4287\u001b[0m         \u001b[38;5;28misinstance\u001b[39m(arr\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], \u001b[38;5;28mint\u001b[39m)):\n\u001b[1;32m   4288\u001b[0m       \u001b[38;5;28;01mreturn\u001b[39;00m lax\u001b[38;5;241m.\u001b[39mdynamic_index_in_dim(arr, idx, keepdims\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m-> 4290\u001b[0m treedef, static_idx, dynamic_idx \u001b[38;5;241m=\u001b[39m \u001b[43m_split_index_for_jit\u001b[49m\u001b[43m(\u001b[49m\u001b[43midx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   4291\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _gather(arr, treedef, static_idx, dynamic_idx, indices_are_sorted,\n\u001b[1;32m   4292\u001b[0m                unique_indices, mode, fill_value)\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/jax/_src/numpy/lax_numpy.py:4362\u001b[0m, in \u001b[0;36m_split_index_for_jit\u001b[0;34m(idx, shape)\u001b[0m\n\u001b[1;32m   4357\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Splits indices into necessarily-static and dynamic parts.\u001b[39;00m\n\u001b[1;32m   4358\u001b[0m \n\u001b[1;32m   4359\u001b[0m \u001b[38;5;124;03mUsed to pass indices into `jit`-ted function.\u001b[39;00m\n\u001b[1;32m   4360\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m   4361\u001b[0m \u001b[38;5;66;03m# Convert list indices to tuples in cases (deprecated by NumPy.)\u001b[39;00m\n\u001b[0;32m-> 4362\u001b[0m idx \u001b[38;5;241m=\u001b[39m \u001b[43m_eliminate_deprecated_list_indexing\u001b[49m\u001b[43m(\u001b[49m\u001b[43midx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   4363\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(i, \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m idx):\n\u001b[1;32m   4364\u001b[0m   \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJAX does not support string indexing; got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00midx\u001b[38;5;132;01m=}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/jax/_src/numpy/lax_numpy.py:4645\u001b[0m, in \u001b[0;36m_eliminate_deprecated_list_indexing\u001b[0;34m(idx)\u001b[0m\n\u001b[1;32m   4641\u001b[0m   \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   4642\u001b[0m     msg \u001b[38;5;241m=\u001b[39m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUsing a non-tuple sequence for multidimensional indexing is not allowed; \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   4643\u001b[0m            \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124muse `arr[array(seq)]` instead of `arr[seq]`. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   4644\u001b[0m            \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSee https://github.com/google/jax/issues/4564 for more information.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 4645\u001b[0m   \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(msg)\n\u001b[1;32m   4646\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   4647\u001b[0m   idx \u001b[38;5;241m=\u001b[39m (idx,)\n",
-            "\u001b[0;31mTypeError\u001b[0m: Using a non-tuple sequence for multidimensional indexing is not allowed; use `arr[array(seq)]` instead of `arr[seq]`. See https://github.com/google/jax/issues/4564 for more information."
-          ]
-        }
-      ],
-      "source": [
-        "# Data with grouping information (e.g., groups A, B, C)\n",
-        "group_ids = [0, 0, 1, 1, 2]\n",
-        "data = jnp.array([10, 12, 9, 11, 8])\n",
-        "\n",
-        "# Model\n",
-        "def partial_pooling_model(group_ids, data):\n",
-        "\n",
-        "    num_groups = len(set(group_ids))\n",
-        "    with numpyro.plate(\"groups\", num_groups):\n",
-        "        group_mu = numpyro.sample(\"group_mu\", dist.Normal(0, 10))\n",
-        "        group_sigma = numpyro.sample(\"group_sigma\", dist.Exponential(1))\n",
-        "\n",
-        "    with numpyro.plate(\"data\", len(data)):\n",
-        "        mu = numpyro.deterministic(\"mu\", group_mu[group_ids])\n",
-        "        sigma = numpyro.deterministic(\"sigma\", group_sigma[group_ids])\n",
-        "        obs = numpyro.sample(\"obs\", dist.Normal(mu, sigma), obs=data)\n",
-        "\n",
-        "# Inference\n",
-        "nuts_kernel = NUTS(partial_pooling_model)\n",
-        "mcmc = MCMC(nuts_kernel, num_samples=1000, num_warmup=500)\n",
-        "mcmc.run(rng_key, group_ids, data)\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 15,
-      "metadata": {},
-      "outputs": [
-        {
-          "ename": "TypeError",
-          "evalue": "Using a non-tuple sequence for multidimensional indexing is not allowed; use `arr[array(seq)]` instead of `arr[seq]`. See https://github.com/google/jax/issues/4564 for more information.",
-          "output_type": "error",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-            "Cell \u001b[0;32mIn[15], line 18\u001b[0m\n\u001b[1;32m     16\u001b[0m nuts_kernel \u001b[38;5;241m=\u001b[39m NUTS(partial_pooling_model)\n\u001b[1;32m     17\u001b[0m mcmc \u001b[38;5;241m=\u001b[39m MCMC(nuts_kernel, num_samples\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1000\u001b[39m, num_warmup\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m500\u001b[39m)\n\u001b[0;32m---> 18\u001b[0m \u001b[43mmcmc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgroup_ids\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/mcmc.py:634\u001b[0m, in \u001b[0;36mMCMC.run\u001b[0;34m(self, rng_key, extra_fields, init_params, *args, **kwargs)\u001b[0m\n\u001b[1;32m    632\u001b[0m map_args \u001b[38;5;241m=\u001b[39m (rng_key, init_state, init_params)\n\u001b[1;32m    633\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_chains \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 634\u001b[0m     states_flat, last_state \u001b[38;5;241m=\u001b[39m \u001b[43mpartial_map_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmap_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    635\u001b[0m     states \u001b[38;5;241m=\u001b[39m tree_map(\u001b[38;5;28;01mlambda\u001b[39;00m x: x[jnp\u001b[38;5;241m.\u001b[39mnewaxis, \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m], states_flat)\n\u001b[1;32m    636\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/mcmc.py:416\u001b[0m, in \u001b[0;36mMCMC._single_chain_mcmc\u001b[0;34m(self, init, args, kwargs, collect_fields)\u001b[0m\n\u001b[1;32m    414\u001b[0m \u001b[38;5;66;03m# Check if _sample_fn is None, then we need to initialize the sampler.\u001b[39;00m\n\u001b[1;32m    415\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m init_state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m (\u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msampler, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_sample_fn\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m--> 416\u001b[0m     new_init_state \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msampler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    417\u001b[0m \u001b[43m        \u001b[49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    418\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_warmup\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    419\u001b[0m \u001b[43m        \u001b[49m\u001b[43minit_params\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    420\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    421\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    422\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    423\u001b[0m     init_state \u001b[38;5;241m=\u001b[39m new_init_state \u001b[38;5;28;01mif\u001b[39;00m init_state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m init_state\n\u001b[1;32m    424\u001b[0m sample_fn, postprocess_fn \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_cached_fns()\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/hmc.py:713\u001b[0m, in \u001b[0;36mHMC.init\u001b[0;34m(self, rng_key, num_warmup, init_params, model_args, model_kwargs)\u001b[0m\n\u001b[1;32m    708\u001b[0m \u001b[38;5;66;03m# vectorized\u001b[39;00m\n\u001b[1;32m    709\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    710\u001b[0m     rng_key, rng_key_init_model \u001b[38;5;241m=\u001b[39m jnp\u001b[38;5;241m.\u001b[39mswapaxes(\n\u001b[1;32m    711\u001b[0m         vmap(random\u001b[38;5;241m.\u001b[39msplit)(rng_key), \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m    712\u001b[0m     )\n\u001b[0;32m--> 713\u001b[0m init_params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_init_state\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    714\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrng_key_init_model\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minit_params\u001b[49m\n\u001b[1;32m    715\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    716\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_potential_fn \u001b[38;5;129;01mand\u001b[39;00m init_params \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    717\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m    718\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mValid value of `init_params` must be provided with\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m `potential_fn`.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    719\u001b[0m     )\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/hmc.py:657\u001b[0m, in \u001b[0;36mHMC._init_state\u001b[0;34m(self, rng_key, model_args, model_kwargs, init_params)\u001b[0m\n\u001b[1;32m    650\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_init_state\u001b[39m(\u001b[38;5;28mself\u001b[39m, rng_key, model_args, model_kwargs, init_params):\n\u001b[1;32m    651\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    652\u001b[0m         (\n\u001b[1;32m    653\u001b[0m             new_init_params,\n\u001b[1;32m    654\u001b[0m             potential_fn,\n\u001b[1;32m    655\u001b[0m             postprocess_fn,\n\u001b[1;32m    656\u001b[0m             model_trace,\n\u001b[0;32m--> 657\u001b[0m         ) \u001b[38;5;241m=\u001b[39m \u001b[43minitialize_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    658\u001b[0m \u001b[43m            \u001b[49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    659\u001b[0m \u001b[43m            \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_model\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    660\u001b[0m \u001b[43m            \u001b[49m\u001b[43mdynamic_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    661\u001b[0m \u001b[43m            \u001b[49m\u001b[43minit_strategy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_init_strategy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    662\u001b[0m \u001b[43m            \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    663\u001b[0m \u001b[43m            \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    664\u001b[0m \u001b[43m            \u001b[49m\u001b[43mforward_mode_differentiation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_forward_mode_differentiation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    665\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    666\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m init_params \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    667\u001b[0m             init_params \u001b[38;5;241m=\u001b[39m new_init_params\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/util.py:656\u001b[0m, in \u001b[0;36minitialize_model\u001b[0;34m(rng_key, model, init_strategy, dynamic_args, model_args, model_kwargs, forward_mode_differentiation, validate_grad)\u001b[0m\n\u001b[1;32m    646\u001b[0m model_kwargs \u001b[38;5;241m=\u001b[39m {} \u001b[38;5;28;01mif\u001b[39;00m model_kwargs \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m model_kwargs\n\u001b[1;32m    647\u001b[0m substituted_model \u001b[38;5;241m=\u001b[39m substitute(\n\u001b[1;32m    648\u001b[0m     seed(model, rng_key \u001b[38;5;28;01mif\u001b[39;00m is_prng_key(rng_key) \u001b[38;5;28;01melse\u001b[39;00m rng_key[\u001b[38;5;241m0\u001b[39m]),\n\u001b[1;32m    649\u001b[0m     substitute_fn\u001b[38;5;241m=\u001b[39minit_strategy,\n\u001b[1;32m    650\u001b[0m )\n\u001b[1;32m    651\u001b[0m (\n\u001b[1;32m    652\u001b[0m     inv_transforms,\n\u001b[1;32m    653\u001b[0m     replay_model,\n\u001b[1;32m    654\u001b[0m     has_enumerate_support,\n\u001b[1;32m    655\u001b[0m     model_trace,\n\u001b[0;32m--> 656\u001b[0m ) \u001b[38;5;241m=\u001b[39m \u001b[43m_get_model_transforms\u001b[49m\u001b[43m(\u001b[49m\u001b[43msubstituted_model\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    657\u001b[0m \u001b[38;5;66;03m# substitute param sites from model_trace to model so\u001b[39;00m\n\u001b[1;32m    658\u001b[0m \u001b[38;5;66;03m# we don't need to generate again parameters of `numpyro.module`\u001b[39;00m\n\u001b[1;32m    659\u001b[0m model \u001b[38;5;241m=\u001b[39m substitute(\n\u001b[1;32m    660\u001b[0m     model,\n\u001b[1;32m    661\u001b[0m     data\u001b[38;5;241m=\u001b[39m{\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    665\u001b[0m     },\n\u001b[1;32m    666\u001b[0m )\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/util.py:450\u001b[0m, in \u001b[0;36m_get_model_transforms\u001b[0;34m(model, model_args, model_kwargs)\u001b[0m\n\u001b[1;32m    448\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_get_model_transforms\u001b[39m(model, model_args\u001b[38;5;241m=\u001b[39m(), model_kwargs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m    449\u001b[0m     model_kwargs \u001b[38;5;241m=\u001b[39m {} \u001b[38;5;28;01mif\u001b[39;00m model_kwargs \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m model_kwargs\n\u001b[0;32m--> 450\u001b[0m     model_trace \u001b[38;5;241m=\u001b[39m \u001b[43mtrace\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_trace\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    451\u001b[0m     inv_transforms \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m    452\u001b[0m     \u001b[38;5;66;03m# model code may need to be replayed in the presence of deterministic sites\u001b[39;00m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/handlers.py:171\u001b[0m, in \u001b[0;36mtrace.get_trace\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    163\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_trace\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m    164\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    165\u001b[0m \u001b[38;5;124;03m    Run the wrapped callable and return the recorded trace.\u001b[39;00m\n\u001b[1;32m    166\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    169\u001b[0m \u001b[38;5;124;03m    :return: `OrderedDict` containing the execution trace.\u001b[39;00m\n\u001b[1;32m    170\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 171\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    172\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrace\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/primitives.py:105\u001b[0m, in \u001b[0;36mMessenger.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n\u001b[1;32m    104\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m--> 105\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/primitives.py:105\u001b[0m, in \u001b[0;36mMessenger.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n\u001b[1;32m    104\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m--> 105\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/primitives.py:105\u001b[0m, in \u001b[0;36mMessenger.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n\u001b[1;32m    104\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m--> 105\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-            "Cell \u001b[0;32mIn[15], line 11\u001b[0m, in \u001b[0;36mpartial_pooling_model\u001b[0;34m(group_ids, data)\u001b[0m\n\u001b[1;32m      9\u001b[0m     group_mu \u001b[38;5;241m=\u001b[39m numpyro\u001b[38;5;241m.\u001b[39msample(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgroup_mu\u001b[39m\u001b[38;5;124m\"\u001b[39m, dist\u001b[38;5;241m.\u001b[39mNormal(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m10\u001b[39m))\n\u001b[1;32m     10\u001b[0m     group_sigma \u001b[38;5;241m=\u001b[39m numpyro\u001b[38;5;241m.\u001b[39msample(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgroup_sigma\u001b[39m\u001b[38;5;124m\"\u001b[39m, dist\u001b[38;5;241m.\u001b[39mExponential(\u001b[38;5;241m1\u001b[39m))\n\u001b[0;32m---> 11\u001b[0m mu \u001b[38;5;241m=\u001b[39m \u001b[43mgroup_mu\u001b[49m\u001b[43m[\u001b[49m\u001b[43mgroup_ids\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m     12\u001b[0m sigma \u001b[38;5;241m=\u001b[39m group_sigma[group_ids]\n\u001b[1;32m     13\u001b[0m obs \u001b[38;5;241m=\u001b[39m numpyro\u001b[38;5;241m.\u001b[39msample(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobs\u001b[39m\u001b[38;5;124m\"\u001b[39m, dist\u001b[38;5;241m.\u001b[39mNormal(mu, sigma), obs\u001b[38;5;241m=\u001b[39mdata)\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/jax/_src/array.py:319\u001b[0m, in \u001b[0;36mArrayImpl.__getitem__\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m    317\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m lax_numpy\u001b[38;5;241m.\u001b[39m_rewriting_take(\u001b[38;5;28mself\u001b[39m, idx)\n\u001b[1;32m    318\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 319\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mlax_numpy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_rewriting_take\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43midx\u001b[49m\u001b[43m)\u001b[49m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/jax/_src/numpy/lax_numpy.py:4290\u001b[0m, in \u001b[0;36m_rewriting_take\u001b[0;34m(arr, idx, indices_are_sorted, unique_indices, mode, fill_value)\u001b[0m\n\u001b[1;32m   4284\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m (\u001b[38;5;28misinstance\u001b[39m(aval, core\u001b[38;5;241m.\u001b[39mDShapedArray) \u001b[38;5;129;01mand\u001b[39;00m aval\u001b[38;5;241m.\u001b[39mshape \u001b[38;5;241m==\u001b[39m () \u001b[38;5;129;01mand\u001b[39;00m\n\u001b[1;32m   4285\u001b[0m         dtypes\u001b[38;5;241m.\u001b[39missubdtype(aval\u001b[38;5;241m.\u001b[39mdtype, np\u001b[38;5;241m.\u001b[39minteger) \u001b[38;5;129;01mand\u001b[39;00m\n\u001b[1;32m   4286\u001b[0m         \u001b[38;5;129;01mnot\u001b[39;00m dtypes\u001b[38;5;241m.\u001b[39missubdtype(aval\u001b[38;5;241m.\u001b[39mdtype, dtypes\u001b[38;5;241m.\u001b[39mbool_) \u001b[38;5;129;01mand\u001b[39;00m\n\u001b[1;32m   4287\u001b[0m         \u001b[38;5;28misinstance\u001b[39m(arr\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], \u001b[38;5;28mint\u001b[39m)):\n\u001b[1;32m   4288\u001b[0m       \u001b[38;5;28;01mreturn\u001b[39;00m lax\u001b[38;5;241m.\u001b[39mdynamic_index_in_dim(arr, idx, keepdims\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m-> 4290\u001b[0m treedef, static_idx, dynamic_idx \u001b[38;5;241m=\u001b[39m \u001b[43m_split_index_for_jit\u001b[49m\u001b[43m(\u001b[49m\u001b[43midx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   4291\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _gather(arr, treedef, static_idx, dynamic_idx, indices_are_sorted,\n\u001b[1;32m   4292\u001b[0m                unique_indices, mode, fill_value)\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/jax/_src/numpy/lax_numpy.py:4362\u001b[0m, in \u001b[0;36m_split_index_for_jit\u001b[0;34m(idx, shape)\u001b[0m\n\u001b[1;32m   4357\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Splits indices into necessarily-static and dynamic parts.\u001b[39;00m\n\u001b[1;32m   4358\u001b[0m \n\u001b[1;32m   4359\u001b[0m \u001b[38;5;124;03mUsed to pass indices into `jit`-ted function.\u001b[39;00m\n\u001b[1;32m   4360\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m   4361\u001b[0m \u001b[38;5;66;03m# Convert list indices to tuples in cases (deprecated by NumPy.)\u001b[39;00m\n\u001b[0;32m-> 4362\u001b[0m idx \u001b[38;5;241m=\u001b[39m \u001b[43m_eliminate_deprecated_list_indexing\u001b[49m\u001b[43m(\u001b[49m\u001b[43midx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   4363\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(i, \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m idx):\n\u001b[1;32m   4364\u001b[0m   \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJAX does not support string indexing; got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00midx\u001b[38;5;132;01m=}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/jax/_src/numpy/lax_numpy.py:4645\u001b[0m, in \u001b[0;36m_eliminate_deprecated_list_indexing\u001b[0;34m(idx)\u001b[0m\n\u001b[1;32m   4641\u001b[0m   \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   4642\u001b[0m     msg \u001b[38;5;241m=\u001b[39m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUsing a non-tuple sequence for multidimensional indexing is not allowed; \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   4643\u001b[0m            \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124muse `arr[array(seq)]` instead of `arr[seq]`. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   4644\u001b[0m            \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSee https://github.com/google/jax/issues/4564 for more information.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 4645\u001b[0m   \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(msg)\n\u001b[1;32m   4646\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   4647\u001b[0m   idx \u001b[38;5;241m=\u001b[39m (idx,)\n",
-            "\u001b[0;31mTypeError\u001b[0m: Using a non-tuple sequence for multidimensional indexing is not allowed; use `arr[array(seq)]` instead of `arr[seq]`. See https://github.com/google/jax/issues/4564 for more information."
-          ]
-        }
-      ],
-      "source": [
-        "# Data with grouping information (e.g., groups A, B, C)\n",
-        "group_ids = [0, 0, 1, 1, 2]\n",
-        "data = jnp.array([10, 12, 9, 11, 8])\n",
-        "\n",
-        "# Model\n",
-        "def partial_pooling_model(group_ids, data):\n",
-        "\n",
-        "    num_groups = len(set(group_ids))\n",
-        "    with numpyro.plate(\"groups\", num_groups):\n",
-        "        group_mu = numpyro.sample(\"group_mu\", dist.Normal(0, 10))\n",
-        "        group_sigma = numpyro.sample(\"group_sigma\", dist.Exponential(1))\n",
-        "\n",
-        "    with numpyro.plate(\"data\", len(data)):    \n",
-        "        mu = numpyro.sample(\"mu\", dist.Normal(group_mu[group_ids], group_sigma[group_ids]))\n",
-        "        sigma = numpyro.sample(\"sigma\", dist.Exponential(1))\n",
-        "        obs = numpyro.sample(\"obs\", dist.Normal(mu, sigma), obs=data)\n",
-        "\n",
-        "\n",
-        "\n",
-        "    mu = group_mu[group_ids]\n",
-        "    sigma = group_sigma[group_ids]\n",
-        "    obs = numpyro.sample(\"obs\", dist.Normal(mu, sigma), obs=data)\n",
-        "\n",
-        "# Inference\n",
-        "nuts_kernel = NUTS(partial_pooling_model)\n",
-        "mcmc = MCMC(nuts_kernel, num_samples=1000, num_warmup=500)\n",
-        "mcmc.run(rng_key, group_ids, data)\n",
-        "\n",
-        "# Note how many mu-s and sigma-s are estimated\n",
-        "mcmc.print_summary()\n"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -284,97 +163,7 @@
       "execution_count": null,
       "metadata": {},
       "outputs": [],
-      "source": [
-        "def partial_pooling_model(group_ids, data):\n",
-        "    μ_α = numpyro.sample(\"μ_α\", dist.Normal(0., 100.))\n",
-        "    σ_α = numpyro.sample(\"σ_α\", dist.HalfNormal(100.))\n",
-        "    μ_β = numpyro.sample(\"μ_β\", dist.Normal(0., 100.))\n",
-        "    σ_β = numpyro.sample(\"σ_β\", dist.HalfNormal(100.))\n",
-        "\n",
-        "    unique_patient_IDs = np.unique(PatientID)\n",
-        "    n_patients = len(unique_patient_IDs)\n",
-        "\n",
-        "    with numpyro.plate(\"plate_i\", n_patients):\n",
-        "        α = numpyro.sample(\"α\", dist.Normal(μ_α, σ_α))\n",
-        "        β = numpyro.sample(\"β\", dist.Normal(μ_β, σ_β))\n",
-        "\n",
-        "    σ = numpyro.sample(\"σ\", dist.HalfNormal(100.))\n",
-        "    FVC_est = α[PatientID] + β[PatientID] * Weeks\n",
-        "\n",
-        "    with numpyro.plate(\"data\", len(PatientID)):\n",
-        "        numpyro.sample(\"obs\", dist.Normal(FVC_est, σ), obs=FVC_obs)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Data with grouping information (e.g., groups A, B, C)\n",
-        "group_ids = [0, 0, 1, 1, 2]\n",
-        "data = jnp.array([10, 12, 9, 11, 8])\n",
-        "\n",
-        "# Model\n",
-        "def partial_pooling_model(group_ids, data):\n",
-        "\n",
-        "    num_groups = len(set(group_ids))\n",
-        "    num_data = len(data)\n",
-        "\n",
-        "    with numpyro.plate(\"groups\", num_groups):\n",
-        "        group_mu = numpyro.sample(\"group_mu\", dist.Normal(0, 10))\n",
-        "        group_sigma = numpyro.sample(\"group_sigma\", dist.Exponential(1))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 30,
-      "metadata": {},
-      "outputs": [
-        {
-          "ename": "ValueError",
-          "evalue": "vmap was requested to map its argument along axis 0, which implies that its rank should be at least 1, but is only 0 (its shape is ())",
-          "output_type": "error",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/jax/_src/api.py:1279\u001b[0m, in \u001b[0;36m_mapped_axis_size.<locals>._get_axis_size\u001b[0;34m(name, shape, axis)\u001b[0m\n\u001b[1;32m   1278\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1279\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mshape\u001b[49m\u001b[43m[\u001b[49m\u001b[43maxis\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m   1280\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mIndexError\u001b[39;00m, \u001b[38;5;167;01mTypeError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m e:\n",
-            "\u001b[0;31mIndexError\u001b[0m: tuple index out of range",
-            "\nThe above exception was the direct cause of the following exception:\n",
-            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-            "Cell \u001b[0;32mIn[30], line 24\u001b[0m\n\u001b[1;32m     22\u001b[0m nuts_kernel \u001b[38;5;241m=\u001b[39m NUTS(partial_pooling_model)\n\u001b[1;32m     23\u001b[0m mcmc \u001b[38;5;241m=\u001b[39m MCMC(nuts_kernel, num_samples\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1000\u001b[39m, num_warmup\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m500\u001b[39m)\n\u001b[0;32m---> 24\u001b[0m \u001b[43mmcmc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgroup_ids\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/mcmc.py:634\u001b[0m, in \u001b[0;36mMCMC.run\u001b[0;34m(self, rng_key, extra_fields, init_params, *args, **kwargs)\u001b[0m\n\u001b[1;32m    632\u001b[0m map_args \u001b[38;5;241m=\u001b[39m (rng_key, init_state, init_params)\n\u001b[1;32m    633\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_chains \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 634\u001b[0m     states_flat, last_state \u001b[38;5;241m=\u001b[39m \u001b[43mpartial_map_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmap_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    635\u001b[0m     states \u001b[38;5;241m=\u001b[39m tree_map(\u001b[38;5;28;01mlambda\u001b[39;00m x: x[jnp\u001b[38;5;241m.\u001b[39mnewaxis, \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m], states_flat)\n\u001b[1;32m    636\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/mcmc.py:416\u001b[0m, in \u001b[0;36mMCMC._single_chain_mcmc\u001b[0;34m(self, init, args, kwargs, collect_fields)\u001b[0m\n\u001b[1;32m    414\u001b[0m \u001b[38;5;66;03m# Check if _sample_fn is None, then we need to initialize the sampler.\u001b[39;00m\n\u001b[1;32m    415\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m init_state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m (\u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msampler, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_sample_fn\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m--> 416\u001b[0m     new_init_state \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msampler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    417\u001b[0m \u001b[43m        \u001b[49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    418\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_warmup\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    419\u001b[0m \u001b[43m        \u001b[49m\u001b[43minit_params\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    420\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    421\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    422\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    423\u001b[0m     init_state \u001b[38;5;241m=\u001b[39m new_init_state \u001b[38;5;28;01mif\u001b[39;00m init_state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m init_state\n\u001b[1;32m    424\u001b[0m sample_fn, postprocess_fn \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_cached_fns()\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/numpyro/infer/hmc.py:711\u001b[0m, in \u001b[0;36mHMC.init\u001b[0;34m(self, rng_key, num_warmup, init_params, model_args, model_kwargs)\u001b[0m\n\u001b[1;32m    707\u001b[0m     rng_key, rng_key_init_model \u001b[38;5;241m=\u001b[39m random\u001b[38;5;241m.\u001b[39msplit(rng_key)\n\u001b[1;32m    708\u001b[0m \u001b[38;5;66;03m# vectorized\u001b[39;00m\n\u001b[1;32m    709\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    710\u001b[0m     rng_key, rng_key_init_model \u001b[38;5;241m=\u001b[39m jnp\u001b[38;5;241m.\u001b[39mswapaxes(\n\u001b[0;32m--> 711\u001b[0m         \u001b[43mvmap\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrng_key\u001b[49m\u001b[43m)\u001b[49m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m    712\u001b[0m     )\n\u001b[1;32m    713\u001b[0m init_params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_init_state(\n\u001b[1;32m    714\u001b[0m     rng_key_init_model, model_args, model_kwargs, init_params\n\u001b[1;32m    715\u001b[0m )\n\u001b[1;32m    716\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_potential_fn \u001b[38;5;129;01mand\u001b[39;00m init_params \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
-            "    \u001b[0;31m[... skipping hidden 6 frame]\u001b[0m\n",
-            "File \u001b[0;32m/opt/anaconda3/envs/aims/lib/python3.9/site-packages/jax/_src/api.py:1283\u001b[0m, in \u001b[0;36m_mapped_axis_size.<locals>._get_axis_size\u001b[0;34m(name, shape, axis)\u001b[0m\n\u001b[1;32m   1281\u001b[0m min_rank \u001b[38;5;241m=\u001b[39m axis \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m axis \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;241m-\u001b[39maxis\n\u001b[1;32m   1282\u001b[0m \u001b[38;5;66;03m# TODO(mattjj): better error message here\u001b[39;00m\n\u001b[0;32m-> 1283\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m   1284\u001b[0m     \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m was requested to map its argument along axis \u001b[39m\u001b[38;5;132;01m{\u001b[39;00maxis\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   1285\u001b[0m     \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwhich implies that its rank should be at least \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmin_rank\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   1286\u001b[0m     \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbut is only \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlen\u001b[39m(shape)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m (its shape is \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mshape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m)\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n",
-            "\u001b[0;31mValueError\u001b[0m: vmap was requested to map its argument along axis 0, which implies that its rank should be at least 1, but is only 0 (its shape is ())"
-          ]
-        }
-      ],
-      "source": [
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "    \n",
-        "    # Hyperparameters for group-level distributions\n",
-        "    group_mu = numpyro.sample(\"group_mu\", dist.Normal(0, 10))\n",
-        "    group_sigma = numpyro.sample(\"group_sigma\", dist.Exponential(1))\n",
-        "    \n",
-        "    # Individual parameters for each group\n",
-        "    with numpyro.plate(\"plate_group\", num_groups):\n",
-        "        mu = numpyro.sample(\"mu\", dist.Normal(group_mu, group_sigma))\n",
-        "        \n",
-        "    # Likelihood\n",
-        "    with numpyro.plate(\"plate_data\", len(data)):\n",
-        "        numpyro.sample(\"obs\", dist.Normal(mu[group_ids], 1), obs=data)\n",
-        "\n",
-        "# Inference\n",
-        "nuts_kernel = NUTS(partial_pooling_model)\n",
-        "mcmc = MCMC(nuts_kernel, num_samples=1000, num_warmup=500)\n",
-        "mcmc.run(group_ids, data)\n"
-      ]
+      "source": []
     },
     {
       "cell_type": "code",