diff --git a/borrowing_strenght_hierarchical_model.ipynb b/borrowing_strenght_hierarchical_model.ipynb
index 9c628db..2932893 100644
--- a/borrowing_strenght_hierarchical_model.ipynb
+++ b/borrowing_strenght_hierarchical_model.ipynb
@@ -50,49 +50,18 @@
     "Fix $m$, $s^2$, $\\tau$ to sensible values, and use an MCMC algorithm of your\n",
     "choice to sample from the model and produce posterior distribution on\n",
     "$\\{\\lambda_j\\}^J_{j=1}, \\mu _0, \\sigma _0$ (a sensible choice might be $J = 10$\n",
-    "hospitals).\n",
-    "\n",
-    "____\n",
-    "\n",
-    "(b) Determine the marginal posterior distribution for the admission rate for\n",
-    "each hospital, and compare it with the posterior estimate in a model with no\n",
-    "pooling (i.e., where each hospital’s rate is inferred exclusively from its\n",
-    "observed counts, i.e. $\\ln \\lambda_j \\sim \\mathcal{N} (\\mu_0, \\sigma^2_0)$ and\n",
-    "the same priors as above, and the posterior for hospital j comes exclusively\n",
-    "from its own data). Check that the posterior means for hospitals with a smaller\n",
-    "number of records (i.e., $n_j = 12$) exhibit stronger shrinkage towards the\n",
-    "global mean, thus demonstrating borrowing of strength, and typically have 68%\n",
-    "HPD credible intervals that are shorter than in the pooling model. You may use a\n",
-    "violin plot to make this comparison.\n",
-    "\n",
-    "___\n",
-    "\n",
-    "(c) Consider the prior predictive distribution for possible data within the BHM:\n",
-    "\n",
-    "$$ Pr( y_{ij} \\mid priors) = \\int Pr ( y_{ij} \\mid \\lambda_j) Pr(\\lambda_j \\mid \\mu_0, \\sigma_0) Pr (\\mu_0,\\sigma_0) d \\mu_0 d \\sigma_0$$\n",
-    "\n",
-    "and simulate from it predictions for the possible counts $y_{ij}$ from the model\n",
-    "(before you see any data). Evaluate the degree of shrinkage by using as metric\n",
-    "the average shrinkage in the standard deviation of the posterior with respect to\n",
-    "the no-pooling scenario, i.e.\n",
-    "\n",
-    "$$ S = \\frac {1} {J} \\sum_{j=1}^{J}{1 - \\frac{\\text{std}_\\text{BHM}(\\ln \\lambda_j \\mid \\bold y)}{\\text{std}_\\text{no pool}(\\ln \\lambda_j \\mid \\bold y)}}$$\n",
-    "\n",
-    "where a smaller S corresponds to higher degree of shrinkage.\n",
-    "\n",
-    "Determine which hyperparameter among $(m, s, \\tau)$ has the most effect on the\n",
-    "degree of shrinkage, and tune each to avoid predictions that are too diffuse\n",
-    "(i.e., the predictive spread is unreasonably wide) or too narrow (i.e., the\n",
-    "predictive spread is over-constraining)."
+    "hospitals)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "id": "49307215",
    "metadata": {},
    "outputs": [],
    "source": [
+    "from typing import List, Callable, Tuple\n",
+    "\n",
     "import corner\n",
     "import emcee\n",
     "import matplotlib.pyplot as plt\n",
@@ -145,13 +114,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 25,
    "id": "4a09b1d3",
    "metadata": {},
    "outputs": [],
    "source": [
-    "true_lambdas = []\n",
-    "\n",
     "def get_expected_admission_counts(mu: float, sigma: float, size: int):\n",
     "    \"\"\"Get expected number of admissions to a hospital at 'size' time points.\n",
     "    \n",
@@ -165,28 +132,31 @@
     "        mu, sigma\n",
     "    )\n",
     "    admission_rate = np.exp(log_admission_rate)\n",
-    "    true_lambdas.append(admission_rate)\n",
     "    admission_counts = np.random.poisson(\n",
     "        admission_rate, size=size\n",
     "    )\n",
-    "    return admission_counts"
+    "    return admission_counts, admission_rate"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 26,
    "id": "2f6b2f3c",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def get_admission_count_matrix(mu: float, sigma: float) -> pd.DataFrame:\n",
+    "def get_admission_count_matrix(\n",
+    "    mu: float, sigma: float\n",
+    ") -> Tuple[pd.DataFrame, List[float]]:\n",
     "    data = {}\n",
+    "    true_lambdas = []\n",
     "    total_array_length = max(reporting_frequency)\n",
     "    for j in range(J):  # For each hospital\n",
     "        data_array_length = reporting_frequency[j]\n",
-    "        admission_records = get_expected_admission_counts(\n",
+    "        admission_records, admission_rate = get_expected_admission_counts(\n",
     "            mu, sigma, size=data_array_length\n",
     "        )\n",
+    "        true_lambdas.append(admission_rate)\n",
     "        padding = np.full(total_array_length - data_array_length, 0, dtype=int)\n",
     "        admission_records = np.concatenate([\n",
     "            admission_records,\n",
@@ -195,7 +165,7 @@
     "        data[f\"Hospital {j+1}\"] = admission_records\n",
     "    data = pd.DataFrame(data)\n",
     "    data.index.name = \"Time point\"\n",
-    "    return data.transpose()"
+    "    return data.transpose(), true_lambdas"
    ]
   },
   {
@@ -222,7 +192,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "4b5ee692",
    "metadata": {},
    "outputs": [
@@ -262,7 +232,7 @@
     "true_mu_0 = np.random.normal(np.log(m), s)\n",
     "true_sigma_0 = np.random.exponential(tau)\n",
     "\n",
-    "df = get_admission_count_matrix(mu=true_mu_0, sigma=true_sigma_0)\n",
+    "df, true_lambdas = get_admission_count_matrix(mu=true_mu_0, sigma=true_sigma_0)\n",
     "\n",
     "print(df)"
    ]
@@ -289,33 +259,13 @@
   {
    "cell_type": "code",
    "execution_count": 7,
-   "id": "35c25880",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "pandas.core.series.Series"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "j=6\n",
-    "type(df.iloc[j,:reporting_frequency[j]])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
    "id": "10a1de3d",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def log_posterior(parameters, m: float, s: float, tau: float, J: int):\n",
+    "def log_posterior(parameters,\n",
+    "                  m: float, s: float, tau: float,\n",
+    "                  J: int, df: pd.DataFrame):\n",
     "    # lambda_j is an array of length J with the admission rate for each hospital\n",
     "    mu_0, sigma_0, *lambdas = parameters\n",
     "    # Check parameters that have to be strictly positive\n",
@@ -359,7 +309,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "id": "1e393c9f",
    "metadata": {},
    "outputs": [
@@ -367,45 +317,58 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 5000/5000 [03:36<00:00, 23.12it/s]\n"
+      "100%|██████████| 5000/5000 [03:45<00:00, 22.17it/s]\n"
      ]
     }
    ],
    "source": [
-    "# Data: observed_admissions (from previous synthetic data generation)\n",
-    "# Assuming observed_admissions is a pandas df (J * max(reporting_frequency))\n",
+    "def get_samples_from_full_bhm(true_mu_0: float, true_sigma_0: float,\n",
+    "                              true_lambdas: List[float],\n",
+    "                              log_posterior: Callable,\n",
+    "                              m: float, s: float, tau: float,\n",
+    "                              J: int, df: pd.DataFrame):\n",
+    "      # Data: observed_admissions (from previous synthetic data generation)\n",
+    "      # Assuming observed_admissions is a pandas df (J * max(reporting_frequency))\n",
     "\n",
-    "# Number of dimensions and walkers\n",
-    "ndim = 2 + J  # [mu_0, sigma_0, lambda_1, ..., lambda_J]\n",
-    "num_walkers = 32\n",
+    "      # Number of dimensions and walkers\n",
+    "      ndim = 2 + J  # [mu_0, sigma_0, lambda_1, ..., lambda_J]\n",
+    "      num_walkers = 32\n",
     "\n",
-    "# Initial guess for parameters\n",
-    "initial_guess = [\n",
-    "      true_mu_0,\n",
-    "      true_sigma_0,\n",
-    "      *true_lambdas\n",
-    "]\n",
+    "      # Initial guess for parameters\n",
+    "      initial_guess = [\n",
+    "            true_mu_0,\n",
+    "            true_sigma_0,\n",
+    "            *true_lambdas\n",
+    "      ]\n",
     "\n",
-    "# Initialize walkers in a small ball around the initial guess\n",
-    "pos = initial_guess + 1e-4 * np.random.randn(num_walkers, ndim)\n",
+    "      # Initialize walkers in a small ball around the initial guess\n",
+    "      pos = initial_guess + 1e-4 * np.random.randn(num_walkers, ndim)\n",
     "\n",
-    "# Create the sampler\n",
-    "sampler = emcee.EnsembleSampler(\n",
-    "      num_walkers, ndim, log_posterior,\n",
-    "      args=(m, s, tau, J)\n",
-    ")\n",
+    "      # Create the sampler\n",
+    "      sampler = emcee.EnsembleSampler(\n",
+    "            num_walkers, ndim, log_posterior,\n",
+    "            args=(m, s, tau, J, df)\n",
+    "      )\n",
     "\n",
-    "# Run MCMC\n",
-    "nsteps = 5000\n",
-    "sampler.run_mcmc(pos, nsteps, progress=True)\n",
+    "      # Run MCMC\n",
+    "      nsteps = 5000\n",
+    "      sampler.run_mcmc(pos, nsteps, progress=True)\n",
     "\n",
-    "# Get one sample every 'thin' steps, discarding the burn-in (first 'discard' steps)\n",
-    "samples = sampler.get_chain(discard=1000, thin=10, flat=True)"
+    "      # Get one sample every 'thin' steps, discarding the burn-in (first 'discard' steps)\n",
+    "      return sampler.get_chain(discard=1000, thin=10, flat=True)\n",
+    "\n",
+    "\n",
+    "samples = get_samples_from_full_bhm(\n",
+    "      true_mu_0=true_mu_0, true_sigma_0=true_sigma_0,\n",
+    "      true_lambdas=true_lambdas,\n",
+    "      log_posterior=log_posterior,\n",
+    "      m=m, s=s, tau=tau, J=J, df=df\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "id": "bcedf091",
    "metadata": {},
    "outputs": [
@@ -439,15 +402,28 @@
   },
   {
    "cell_type": "markdown",
-   "id": "3ce8571e",
+   "id": "66182918",
    "metadata": {},
    "source": [
-    "### (b) Here are the marginal posterior distributions of admission rates for every hospital:"
+    "____\n",
+    "\n",
+    "(b) Determine the marginal posterior distribution for the admission rate for\n",
+    "each hospital, and compare it with the posterior estimate in a model with no\n",
+    "pooling (i.e., where each hospital’s rate is inferred exclusively from its\n",
+    "observed counts, i.e. $\\ln \\lambda_j \\sim \\mathcal{N} (\\mu_0, \\sigma^2_0)$ and\n",
+    "the same priors as above, and the posterior for hospital j comes exclusively\n",
+    "from its own data). Check that the posterior means for hospitals with a smaller\n",
+    "number of records (i.e., $n_j = 12$) exhibit stronger shrinkage towards the\n",
+    "global mean, thus demonstrating borrowing of strength, and typically have 68%\n",
+    "HPD credible intervals that are shorter than in the pooling model. You may use a\n",
+    "violin plot to make this comparison.\n",
+    "\n",
+    "#### With pooling"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 10,
    "id": "03ee076c",
    "metadata": {},
    "outputs": [
@@ -455,31 +431,31 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "          Reporting frequency  16th percentile  84th percentile  \\\n",
-      "Hospital                                                          \n",
-      "1                          12       155.772971       160.241098   \n",
-      "2                          54       157.656116       160.502618   \n",
-      "3                          12       156.272260       160.602153   \n",
-      "4                          12       158.177209       162.292523   \n",
-      "5                          54       157.382752       160.187262   \n",
-      "6                          54       160.169699       163.533840   \n",
-      "7                          12       158.731447       162.830338   \n",
-      "8                          24       159.015641       162.708823   \n",
-      "9                          12       154.559953       159.806722   \n",
-      "10                         12       157.219515       161.435273   \n",
+      "          Reporting frequency  log lambda 16th percentile  \\\n",
+      "Hospital                                                    \n",
+      "1                          12                    5.048400   \n",
+      "2                          54                    5.060416   \n",
+      "3                          12                    5.051600   \n",
+      "4                          12                    5.063716   \n",
+      "5                          54                    5.058681   \n",
+      "6                          54                    5.076234   \n",
+      "7                          12                    5.067214   \n",
+      "8                          24                    5.069003   \n",
+      "9                          12                    5.040582   \n",
+      "10                         12                    5.057643   \n",
       "\n",
-      "          HPD width (68%)      mu_0   sigma_0  \n",
-      "Hospital                                       \n",
-      "1                4.468127  5.070992  0.016259  \n",
-      "2                2.846502  5.070992  0.016259  \n",
-      "3                4.329893  5.070992  0.016259  \n",
-      "4                4.115313  5.070992  0.016259  \n",
-      "5                2.804511  5.070992  0.016259  \n",
-      "6                3.364141  5.070992  0.016259  \n",
-      "7                4.098891  5.070992  0.016259  \n",
-      "8                3.693182  5.070992  0.016259  \n",
-      "9                5.246769  5.070992  0.016259  \n",
-      "10               4.215758  5.070992  0.016259  \n"
+      "          log lambda 84th percentile  HPD width (68%)      mu_0   sigma_0  \n",
+      "Hospital                                                                   \n",
+      "1                           5.076680         0.028280  5.070992  0.016259  \n",
+      "2                           5.078310         0.017894  5.070992  0.016259  \n",
+      "3                           5.078930         0.027330  5.070992  0.016259  \n",
+      "4                           5.089400         0.025684  5.070992  0.016259  \n",
+      "5                           5.076344         0.017663  5.070992  0.016259  \n",
+      "6                           5.097020         0.020786  5.070992  0.016259  \n",
+      "7                           5.092709         0.025495  5.070992  0.016259  \n",
+      "8                           5.091962         0.022960  5.070992  0.016259  \n",
+      "9                           5.073965         0.033383  5.070992  0.016259  \n",
+      "10                          5.084104         0.026461  5.070992  0.016259  \n"
      ]
     }
    ],
@@ -489,13 +465,13 @@
     "for j in range(J):\n",
     "    mu_0_j = samples[:, 0]\n",
     "    sigma_0_j = samples[:, 1]\n",
-    "    lambda_samples_j = samples[:, 2 + j]\n",
+    "    lambda_samples_j = np.log(samples[:, 2 + j])\n",
     "    lower, upper = np.percentile(lambda_samples_j, [16, 84])\n",
     "    rows.append({\n",
     "        \"Hospital\": j + 1,\n",
     "        \"Reporting frequency\": reporting_frequency[j],\n",
-    "        \"16th percentile\": lower,\n",
-    "        \"84th percentile\": upper,\n",
+    "        \"log lambda 16th percentile\": lower,\n",
+    "        \"log lambda 84th percentile\": upper,\n",
     "        \"HPD width (68%)\": upper - lower,\n",
     "        \"mu_0\": np.mean(mu_0_j),\n",
     "        \"sigma_0\": np.mean(sigma_0_j)\n",
@@ -508,7 +484,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "id": "70b92966",
    "metadata": {},
    "outputs": [
@@ -516,9 +492,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Pearson r = -0.874\n",
-      "R^2 = 0.764\n",
-      "p-value = 9.495e-04\n"
+      "Pearson r = -0.865\n",
+      "R^2 = 0.749\n",
+      "p-value = 1.224e-03\n"
      ]
     }
    ],
@@ -536,13 +512,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 12,
    "id": "74dbf9b4",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -568,6 +544,357 @@
     ")\n",
     "plt.show()\n"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d586de09",
+   "metadata": {},
+   "source": [
+    "#### Without pooling"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "eb404c06",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 3000/3000 [00:21<00:00, 141.02it/s]\n",
+      "100%|██████████| 3000/3000 [00:19<00:00, 151.97it/s]\n",
+      "100%|██████████| 3000/3000 [00:17<00:00, 169.06it/s]\n",
+      "100%|██████████| 3000/3000 [00:18<00:00, 158.46it/s]\n",
+      "100%|██████████| 3000/3000 [00:19<00:00, 154.37it/s]\n",
+      "100%|██████████| 3000/3000 [00:17<00:00, 168.49it/s]\n",
+      "100%|██████████| 3000/3000 [00:17<00:00, 170.60it/s]\n",
+      "100%|██████████| 3000/3000 [00:17<00:00, 169.70it/s]\n",
+      "100%|██████████| 3000/3000 [00:17<00:00, 170.22it/s]\n",
+      "100%|██████████| 3000/3000 [00:17<00:00, 171.07it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "mu_fixed = np.log(m)\n",
+    "sigma_fixed = s\n",
+    "\n",
+    "\n",
+    "def log_posterior_without_pooling(parameters: np.ndarray,\n",
+    "                                  mu_0: float, sigma_0: float,\n",
+    "                                  j: int, df: pd.DataFrame):\n",
+    "    lambda_j, *_ = parameters\n",
+    "    if lambda_j <= 0:\n",
+    "        return -np.inf\n",
+    "    # Prior on 'lambda_j' (log-normally distributed, parameters 'mu_0' and 'sigma_0')\n",
+    "    log_prior = (\n",
+    "        -np.log(lambda_j * sigma_0 * np.sqrt(2 * np.pi))\n",
+    "        - (np.log(lambda_j) - mu_0)**2 / (2 * sigma_0**2)\n",
+    "    )\n",
+    "    observed_admissions = df.iloc[j,:reporting_frequency[j]].to_numpy()\n",
+    "    # Likelihood: Poisson\n",
+    "    log_likelihood = np.sum(\n",
+    "        observed_admissions * np.log(lambda_j)\n",
+    "        - lambda_j\n",
+    "        - gammaln(observed_admissions + 1)\n",
+    "    )\n",
+    "\n",
+    "    return log_prior + log_likelihood\n",
+    "\n",
+    "\n",
+    "def get_samples_without_pooling(true_lambdas: List[float],\n",
+    "                                log_posterior_without_pooling: Callable,\n",
+    "                                mu_fixed: float, sigma_fixed: float,\n",
+    "                                J: int, df: pd.DataFrame):\n",
+    "    samples_without_pooling = {}\n",
+    "    for j in range(J):\n",
+    "        # Number of dimensions and walkers\n",
+    "        ndim = 1  # Only lambda_j\n",
+    "        num_walkers = 32\n",
+    "\n",
+    "        # Initial guess for parameters\n",
+    "        initial_guess = [\n",
+    "            true_lambdas[j]\n",
+    "        ]\n",
+    "\n",
+    "        # Initialize walkers in a small ball around the initial guess\n",
+    "        pos = initial_guess + 1e-4 * np.random.randn(num_walkers, ndim)\n",
+    "\n",
+    "        # Create the sampler\n",
+    "        sampler = emcee.EnsembleSampler(\n",
+    "            num_walkers, ndim, log_posterior_without_pooling,\n",
+    "            args=(mu_fixed, sigma_fixed, j, df)\n",
+    "        )\n",
+    "\n",
+    "        # Run MCMC\n",
+    "        nsteps = 3000\n",
+    "        sampler.run_mcmc(pos, nsteps, progress=True)\n",
+    "\n",
+    "        # Get one sample every 'thin' steps, discarding the burn-in (first 'discard' steps)\n",
+    "        samples_without_pooling[j] = sampler.get_chain(discard=1000, thin=10, flat=True)\n",
+    "    return samples_without_pooling\n",
+    "\n",
+    "\n",
+    "samples_without_pooling = get_samples_without_pooling(\n",
+    "    true_lambdas=true_lambdas,\n",
+    "    log_posterior_without_pooling=log_posterior_without_pooling,\n",
+    "    mu_fixed=mu_fixed, sigma_fixed=sigma_fixed,\n",
+    "    J=J, df=df\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "aa76a65f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "          Reporting frequency  log lambda 16th percentile  \\\n",
+      "Hospital                                                    \n",
+      "1                          12                    5.017023   \n",
+      "2                          54                    5.057103   \n",
+      "3                          12                    5.027284   \n",
+      "4                          12                    5.057264   \n",
+      "5                          54                    5.054388   \n",
+      "6                          54                    5.085134   \n",
+      "7                          12                    5.070524   \n",
+      "8                          24                    5.072232   \n",
+      "9                          12                    5.000043   \n",
+      "10                         12                    5.046290   \n",
+      "\n",
+      "          log lambda 84th percentile  HPD width (68%)      mu_0  sigma_0  \n",
+      "Hospital                                                                  \n",
+      "1                           5.062971         0.045948  4.442651      0.4  \n",
+      "2                           5.078878         0.021775  4.442651      0.4  \n",
+      "3                           5.072929         0.045645  4.442651      0.4  \n",
+      "4                           5.103612         0.046349  4.442651      0.4  \n",
+      "5                           5.076058         0.021670  4.442651      0.4  \n",
+      "6                           5.106324         0.021190  4.442651      0.4  \n",
+      "7                           5.115854         0.045329  4.442651      0.4  \n",
+      "8                           5.104386         0.032154  4.442651      0.4  \n",
+      "9                           5.046979         0.046936  4.442651      0.4  \n",
+      "10                          5.091491         0.045202  4.442651      0.4  \n"
+     ]
+    }
+   ],
+   "source": [
+    "rows = []\n",
+    "\n",
+    "for j in range(J):\n",
+    "    swp = samples_without_pooling[j]\n",
+    "    lambda_samples_j = np.log(swp[:, 0])\n",
+    "    lower, upper = np.percentile(lambda_samples_j, [16, 84])\n",
+    "    rows.append({\n",
+    "        \"Hospital\": j + 1,\n",
+    "        \"Reporting frequency\": reporting_frequency[j],\n",
+    "        \"log lambda 16th percentile\": lower,\n",
+    "        \"log lambda 84th percentile\": upper,\n",
+    "        \"HPD width (68%)\": upper - lower,\n",
+    "        \"mu_0\": np.mean(mu_fixed),\n",
+    "        \"sigma_0\": np.mean(sigma_fixed)\n",
+    "    })\n",
+    "\n",
+    "temp = pd.DataFrame(rows)\n",
+    "temp = pd.DataFrame(rows).set_index(\"Hospital\")\n",
+    "print(temp)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "0117285c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = []\n",
+    "positions = []\n",
+    "groups = []\n",
+    "\n",
+    "pos, offset, step = 1.0, 0.35, 1.2\n",
+    "\n",
+    "for j in range(J):\n",
+    "    # With pooling\n",
+    "    data.append(np.log(samples[:, 2 + j]))\n",
+    "    positions.append(pos)\n",
+    "    groups.append(\"bhm\")\n",
+    "    # Without pooling\n",
+    "    data.append(np.log(samples_without_pooling[j][:, 0]))\n",
+    "    positions.append(pos + offset)\n",
+    "    groups.append(\"nopool\")\n",
+    "    pos += step\n",
+    "\n",
+    "plt.figure(figsize=(14, 6))\n",
+    "\n",
+    "vp = plt.violinplot(\n",
+    "    data,\n",
+    "    positions=positions,\n",
+    "    widths=0.3,\n",
+    "    #showmeans=False,\n",
+    "    showmedians=True,\n",
+    "    #showextrema=False\n",
+    ")\n",
+    "\n",
+    "# Color each violin plot according to group (with or without pooling)\n",
+    "for body, group in zip(vp[\"bodies\"], groups):\n",
+    "    body.set_facecolor(\n",
+    "        {\n",
+    "            \"bhm\": \"orange\",\n",
+    "            \"nopool\": \"darkblue\"\n",
+    "        }[group]\n",
+    "    )\n",
+    "    body.set_alpha(0.7)\n",
+    "\n",
+    "vp[\"cmedians\"].set_color(\"white\")\n",
+    "vp[\"cmedians\"].set_alpha(1.0)\n",
+    "vp[\"cmedians\"].set_linewidth(2.0)\n",
+    "\n",
+    "# Set axes labels and plot title\n",
+    "plt.xticks(\n",
+    "    [1 + step * j + offset/2 for j in range(J)],\n",
+    "    [f\"Hospital {j+1}\\n(n={reporting_frequency[j]})\" for j in range(J)]\n",
+    ")\n",
+    "plt.ylabel(r\"$\\ln \\lambda_j$\")\n",
+    "plt.title(r\"Distribution of $\\ln \\lambda_y$\"\"\\n\"r\"Full BHM vs w/out pooling\")\n",
+    "\n",
+    "from matplotlib.patches import Patch\n",
+    "plt.legend(\n",
+    "    handles=[\n",
+    "        Patch(color=\"orange\", label=\"With pooling\"),\n",
+    "        Patch(color=\"darkblue\", label=\"No pooling\")\n",
+    "    ],\n",
+    "    loc=\"upper right\"\n",
+    ")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd561fbc",
+   "metadata": {},
+   "source": [
+    "___\n",
+    "\n",
+    "(c) Consider the prior predictive distribution for possible data within the BHM:\n",
+    "\n",
+    "$$ Pr( y_{ij} \\mid priors) = \\int Pr ( y_{ij} \\mid \\lambda_j) Pr(\\lambda_j \\mid \\mu_0, \\sigma_0) Pr (\\mu_0,\\sigma_0) d \\mu_0 d \\sigma_0$$\n",
+    "\n",
+    "and simulate from it predictions for the possible counts $y_{ij}$ from the model\n",
+    "(before you see any data). Evaluate the degree of shrinkage by using as metric\n",
+    "the average shrinkage in the standard deviation of the posterior with respect to\n",
+    "the no-pooling scenario, i.e.\n",
+    "\n",
+    "$$ S = \\frac {1} {J} \\sum_{j=1}^{J}{1 - \\frac{\\text{std}_\\text{BHM}(\\ln \\lambda_j \\mid \\bold y)}{\\text{std}_\\text{no pool}(\\ln \\lambda_j \\mid \\bold y)}}$$\n",
+    "\n",
+    "where a smaller S corresponds to higher degree of shrinkage.\n",
+    "\n",
+    "Determine which hyperparameter among $(m, s, \\tau)$ has the most effect on the\n",
+    "degree of shrinkage, and tune each to avoid predictions that are too diffuse\n",
+    "(i.e., the predictive spread is unreasonably wide) or too narrow (i.e., the\n",
+    "predictive spread is over-constraining)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "3366ea7e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The degree of shrinkage S for m = 85, s = 0.4, tau = 0.1 is: 0.281\n"
+     ]
+    }
+   ],
+   "source": [
+    "S = np.mean([\n",
+    "    1 - (\n",
+    "        np.std(np.log(samples[:, 2 + j]))\n",
+    "        / np.std(np.log(samples_without_pooling[j][:, 0]))\n",
+    "    )\n",
+    "    for j in range(J)\n",
+    "])\n",
+    "\n",
+    "print(\n",
+    "    f\"The degree of shrinkage S for m = {m}, s = {s}, tau = {tau} is: {S:.3f}\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9ddb9e81",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 80%|███████▉  | 3977/5000 [03:49<00:56, 17.96it/s]"
+     ]
+    }
+   ],
+   "source": [
+    "m = 85\n",
+    "s = 0.4\n",
+    "tau = 0.1\n",
+    "\n",
+    "def evaluate_degree_of_shrinkage(m, s, tau):\n",
+    "    true_mu_0 = np.random.normal(np.log(m), s)\n",
+    "    true_sigma_0 = np.random.exponential(tau)\n",
+    "    df, true_lambdas = get_admission_count_matrix(\n",
+    "        mu=true_mu_0, sigma=true_sigma_0\n",
+    "    )\n",
+    "    # Samples from joint posterior (full BHM)\n",
+    "    samples_bhm = get_samples_from_full_bhm(\n",
+    "        true_mu_0=true_mu_0, true_sigma_0=true_sigma_0,\n",
+    "        true_lambdas=true_lambdas,\n",
+    "        log_posterior=log_posterior,\n",
+    "        m=m, s=s, tau=tau,\n",
+    "        J=J, df=df\n",
+    "    )\n",
+    "    # Samples from non-pooling model\n",
+    "    samples_without_pooling = get_samples_without_pooling(\n",
+    "        true_lambdas=true_lambdas,\n",
+    "        log_posterior_without_pooling=log_posterior_without_pooling,\n",
+    "        mu_fixed=true_mu_0, sigma_fixed=true_sigma_0,\n",
+    "        J=J, df=df\n",
+    "    )\n",
+    "    S = np.mean([\n",
+    "        1 - (\n",
+    "            np.std(np.log(samples_bhm[:, 2 + j]))\n",
+    "            / np.std(np.log(samples_without_pooling[j][:, 0]))\n",
+    "        )\n",
+    "        for j in range(J)\n",
+    "    ])\n",
+    "    print(\n",
+    "        f\"The degree of shrinkage S for m = {m}, s = {s}, tau = {tau} is: {S:.3f}\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "evaluate_degree_of_shrinkage(m=(2 * m), s=s, tau=tau)\n",
+    "evaluate_degree_of_shrinkage(m=m, s=(2 * s), tau=tau)\n",
+    "evaluate_degree_of_shrinkage(m=m, s=s, tau=(2 * tau))"
+   ]
   }
  ],
  "metadata": {