From ded957c379a7d98f8565ab8dc19064bbd0dd04a1 Mon Sep 17 00:00:00 2001
From: "Abhishek.6122008" <Abhishek.612208@gmail.com>
Date: Sat, 22 Nov 2025 22:41:33 +0530
Subject: [PATCH 1/3] Add vector_variables.ipynb notebook

---
 .../core_notebooks/vector_variables.ipynb     | 754 ++++++++++++++++++
 1 file changed, 754 insertions(+)
 create mode 100644 docs/source/learn/core_notebooks/vector_variables.ipynb

diff --git a/docs/source/learn/core_notebooks/vector_variables.ipynb b/docs/source/learn/core_notebooks/vector_variables.ipynb
new file mode 100644
index 0000000000..23cf13a396
--- /dev/null
+++ b/docs/source/learn/core_notebooks/vector_variables.ipynb
@@ -0,0 +1,754 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bb46210d",
+   "metadata": {},
+   "source": [
+    "# Demonstrating Vector Variables in PyMC\n",
+    "\n",
+    "This tutorial shows how to work with **vector-valued random variables** in PyMC,\n",
+    "using a simple example with several groups of data that share a common\n",
+    "structure but have different means (and optionally different standard\n",
+    "deviations).\n",
+    "\n",
+    "We will:\n",
+    "\n",
+    "1. Simulate data from multiple groups.  \n",
+    "2. Build a PyMC model with vector parameters `mu` (means) and `sigma`.  \n",
+    "3. Use indexing to connect each observation to the right group parameter.  \n",
+    "4. Sample from the posterior and inspect the results.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8384f0b1",
+   "metadata": {},
+   "source": [
+    "## 1. Setup\n",
+    "\n",
+    "We start by importing the libraries we need and fixing a random seed for\n",
+    "reproducibility."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a835935a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING (pytensor.configdefaults): g++ not available, if using conda: `conda install gxx`\n",
+      "WARNING (pytensor.configdefaults): g++ not detected!  PyTensor will be unable to compile C-implementations and will default to Python. Performance may be severely degraded. To remove this warning, set PyTensor flags cxx to an empty string.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import arviz as az\n",
+    "import numpy as np\n",
+    "\n",
+    "import pymc as pm\n",
+    "\n",
+    "RANDOM_SEED = 123\n",
+    "rng = np.random.default_rng(RANDOM_SEED)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "fcadcb1d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "# Configure PyTensor to use g++ compiler if available, otherwise suppress warning\n",
+    "import pytensor\n",
+    "\n",
+    "# Try to find g++ compiler\n",
+    "gxx_paths = [\n",
+    "    r\"C:\\Users\\mrcle\\miniconda3\\Library\\bin\\x86_64-w64-mingw32-g++.exe\",\n",
+    "    \"g++\",  # Try system g++ if in PATH\n",
+    "]\n",
+    "\n",
+    "gxx_found = None\n",
+    "for path in gxx_paths:\n",
+    "    if path == \"g++\":\n",
+    "        # Check if g++ is in PATH\n",
+    "        import shutil\n",
+    "\n",
+    "        if shutil.which(\"g++\"):\n",
+    "            gxx_found = \"g++\"\n",
+    "            break\n",
+    "    elif os.path.exists(path):\n",
+    "        gxx_found = path\n",
+    "        break\n",
+    "\n",
+    "if gxx_found:\n",
+    "    pytensor.config.cxx = gxx_found\n",
+    "    print(f\"PyTensor configured to use: {gxx_found}\")\n",
+    "else:\n",
+    "    # Suppress warning if compiler not found\n",
+    "    pytensor.config.cxx = \"\"\n",
+    "    print(\n",
+    "        \"g++ compiler not found. PyTensor will use Python fallback (slower but works fine for examples).\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "87dcae3e",
+   "metadata": {},
+   "source": [
+    "## 2. Simulate grouped data\n",
+    "\n",
+    "We create:\n",
+    "\n",
+    "- `num_groups`: how many groups we have.  \n",
+    "- `group_size`: how many observations per group.  \n",
+    "- `sigma_true`: shared standard deviation of the observation noise.  \n",
+    "- `mu_true`: a vector of true group means (used only to generate fake data).\n",
+    "\n",
+    "We then build:\n",
+    "\n",
+    "- `data`: stacked observations from all groups.  \n",
+    "- `data_labels`: an integer label (0, 1, ..., `num_groups-1`) telling us\n",
+    "  which group each observation belongs to."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "041b9873",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([-1.91745688, -3.13102432, -1.95260845, -2.81115613, -2.81694979,\n",
+       "        -2.39739336, -4.02049108, -1.30239457, -3.16565035, -1.49429126]),\n",
+       " array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "num_groups = 5\n",
+    "group_size = 200\n",
+    "sigma_true = 1.0\n",
+    "\n",
+    "# True means for each group (just for simulation, not known to the model)\n",
+    "mu_true = rng.normal(loc=np.linspace(-2, 2, num_groups), scale=0.5, size=num_groups)\n",
+    "\n",
+    "# Simulate data: for each group, draw `group_size` points\n",
+    "data_per_group = [rng.normal(loc=mu, scale=sigma_true, size=group_size) for mu in mu_true]\n",
+    "data = np.concatenate(data_per_group)\n",
+    "\n",
+    "# Integer labels telling which group each observation belongs to\n",
+    "data_labels = np.concatenate(\n",
+    "    [np.full(group_size, group_id) for group_id in range(num_groups)]\n",
+    ").astype(int)\n",
+    "\n",
+    "data[:10], data_labels[:10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a50caa9",
+   "metadata": {},
+   "source": [
+    "`data` is a 1D array of length `num_groups * group_size`.\n",
+    "\n",
+    "`data_labels` is a 1D integer array of the same length, where each element is\n",
+    "the group index (from 0 to `num_groups - 1`) for the corresponding observation.\n",
+    "\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "69e4fe50",
+   "metadata": {},
+   "source": [
+    "## 3. Building the PyMC model with vector variables\n",
+    "\n",
+    "Key idea: instead of defining separate scalar parameters for each group, we\n",
+    "define *vector-valued* parameters:\n",
+    "\n",
+    "- `mu`: a length-`num_groups` vector of group means.  \n",
+    "- `sigma`: a length-`num_groups` vector of group standard deviations\n",
+    "  (or we could use a single shared `sigma` if we prefer).\n",
+    "\n",
+    "Then we use **indexing** with `data_labels` to pick the right parameter for\n",
+    "each observation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "5bc49764",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$$\n",
+       "            \\begin{array}{rcl}\n",
+       "            \\text{mu} &\\sim & \\operatorname{Normal}(0,~10)\\\\\\text{sigma} &\\sim & \\operatorname{HalfNormal}(0,~2)\\\\\\text{y} &\\sim & \\operatorname{Normal}(f(\\text{mu}),~f(\\text{sigma}))\n",
+       "            \\end{array}\n",
+       "            $$"
+      ],
+      "text/plain": [
+       "   mu ~ Normal(0, 10)\n",
+       "sigma ~ HalfNormal(0, 2)\n",
+       "    y ~ Normal(f(mu), f(sigma))"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "with pm.Model() as model:\n",
+    "    # Vector of group means\n",
+    "    mu = pm.Normal(\"mu\", mu=0.0, sigma=10.0, shape=num_groups)\n",
+    "\n",
+    "    # Vector of group standard deviations (half-normal prior)\n",
+    "    sigma = pm.HalfNormal(\"sigma\", sigma=2.0, shape=num_groups)\n",
+    "\n",
+    "    # The likelihood: for each observation i,\n",
+    "    #   data[i] ~ Normal(mu[data_labels[i]], sigma[data_labels[i]])\n",
+    "    likelihood = pm.Normal(\n",
+    "        \"y\",\n",
+    "        mu=mu[data_labels],\n",
+    "        sigma=sigma[data_labels],\n",
+    "        observed=data,\n",
+    "    )\n",
+    "\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a6f07da",
+   "metadata": {},
+   "source": [
+    "Notes:\n",
+    "\n",
+    "- `mu[data_labels]` creates a 1D array where each element is the mean\n",
+    "  corresponding to the group of that observation.  \n",
+    "- Similarly for `sigma[data_labels]`.  \n",
+    "- This is the crucial **vectorization trick** that avoids explicit Python loops.\n",
+    "\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7018a96c",
+   "metadata": {},
+   "source": [
+    "## 4. Sampling from the posterior\n",
+    "\n",
+    "Now we run MCMC to obtain samples from the posterior distribution of the\n",
+    "parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d54b6d95",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Initializing NUTS using jitter+adapt_diag...\n",
+      "Sequential sampling (1 chains in 1 job)\n",
+      "NUTS: [mu, sigma]\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2fc77221f1204793a41b2527af50d1ed",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Sampling 1 chain for 300 tune and 300 draw iterations (300 + 300 draws total) took 409 seconds.\n",
+      "Only one chain was sampled, this makes it impossible to run some convergence checks\n"
+     ]
+    }
+   ],
+   "source": [
+    "with model:\n",
+    "    idata = pm.sample(\n",
+    "        draws=300,\n",
+    "        tune=300,\n",
+    "        chains=1,\n",
+    "        cores=1,\n",
+    "        target_accept=0.9,\n",
+    "        random_seed=RANDOM_SEED,\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20d662df",
+   "metadata": {},
+   "source": [
+    "## 5. Inspecting the results\n",
+    "\n",
+    "We compare the posterior means of `mu` and `sigma` to the true values used to\n",
+    "simulate the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "a6cc57d9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "arviz - WARNING - Shape validation failed: input_shape: (1, 300), minimum_shape: (chains=2, draws=4)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Posterior summary for mu:\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>mean</th>\n",
+       "      <th>sd</th>\n",
+       "      <th>hdi_3%</th>\n",
+       "      <th>hdi_97%</th>\n",
+       "      <th>mcse_mean</th>\n",
+       "      <th>mcse_sd</th>\n",
+       "      <th>ess_bulk</th>\n",
+       "      <th>ess_tail</th>\n",
+       "      <th>r_hat</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>mu[0]</th>\n",
+       "      <td>-2.410</td>\n",
+       "      <td>0.063</td>\n",
+       "      <td>-2.548</td>\n",
+       "      <td>-2.310</td>\n",
+       "      <td>0.002</td>\n",
+       "      <td>0.004</td>\n",
+       "      <td>625.0</td>\n",
+       "      <td>218.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mu[1]</th>\n",
+       "      <td>-1.208</td>\n",
+       "      <td>0.079</td>\n",
+       "      <td>-1.355</td>\n",
+       "      <td>-1.055</td>\n",
+       "      <td>0.004</td>\n",
+       "      <td>0.005</td>\n",
+       "      <td>569.0</td>\n",
+       "      <td>99.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mu[2]</th>\n",
+       "      <td>0.620</td>\n",
+       "      <td>0.081</td>\n",
+       "      <td>0.475</td>\n",
+       "      <td>0.779</td>\n",
+       "      <td>0.004</td>\n",
+       "      <td>0.006</td>\n",
+       "      <td>515.0</td>\n",
+       "      <td>164.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mu[3]</th>\n",
+       "      <td>1.078</td>\n",
+       "      <td>0.082</td>\n",
+       "      <td>0.905</td>\n",
+       "      <td>1.203</td>\n",
+       "      <td>0.003</td>\n",
+       "      <td>0.005</td>\n",
+       "      <td>743.0</td>\n",
+       "      <td>191.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mu[4]</th>\n",
+       "      <td>2.551</td>\n",
+       "      <td>0.067</td>\n",
+       "      <td>2.425</td>\n",
+       "      <td>2.671</td>\n",
+       "      <td>0.003</td>\n",
+       "      <td>0.003</td>\n",
+       "      <td>503.0</td>\n",
+       "      <td>254.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        mean     sd  hdi_3%  hdi_97%  mcse_mean  mcse_sd  ess_bulk  ess_tail  \\\n",
+       "mu[0] -2.410  0.063  -2.548   -2.310      0.002    0.004     625.0     218.0   \n",
+       "mu[1] -1.208  0.079  -1.355   -1.055      0.004    0.005     569.0      99.0   \n",
+       "mu[2]  0.620  0.081   0.475    0.779      0.004    0.006     515.0     164.0   \n",
+       "mu[3]  1.078  0.082   0.905    1.203      0.003    0.005     743.0     191.0   \n",
+       "mu[4]  2.551  0.067   2.425    2.671      0.003    0.003     503.0     254.0   \n",
+       "\n",
+       "       r_hat  \n",
+       "mu[0]    NaN  \n",
+       "mu[1]    NaN  \n",
+       "mu[2]    NaN  \n",
+       "mu[3]    NaN  \n",
+       "mu[4]    NaN  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "arviz - WARNING - Shape validation failed: input_shape: (1, 300), minimum_shape: (chains=2, draws=4)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Posterior summary for sigma:\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>mean</th>\n",
+       "      <th>sd</th>\n",
+       "      <th>hdi_3%</th>\n",
+       "      <th>hdi_97%</th>\n",
+       "      <th>mcse_mean</th>\n",
+       "      <th>mcse_sd</th>\n",
+       "      <th>ess_bulk</th>\n",
+       "      <th>ess_tail</th>\n",
+       "      <th>r_hat</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>sigma[0]</th>\n",
+       "      <td>0.919</td>\n",
+       "      <td>0.045</td>\n",
+       "      <td>0.834</td>\n",
+       "      <td>0.999</td>\n",
+       "      <td>0.002</td>\n",
+       "      <td>0.003</td>\n",
+       "      <td>696.0</td>\n",
+       "      <td>201.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>sigma[1]</th>\n",
+       "      <td>1.087</td>\n",
+       "      <td>0.056</td>\n",
+       "      <td>0.993</td>\n",
+       "      <td>1.197</td>\n",
+       "      <td>0.002</td>\n",
+       "      <td>0.003</td>\n",
+       "      <td>743.0</td>\n",
+       "      <td>227.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>sigma[2]</th>\n",
+       "      <td>1.042</td>\n",
+       "      <td>0.050</td>\n",
+       "      <td>0.942</td>\n",
+       "      <td>1.134</td>\n",
+       "      <td>0.002</td>\n",
+       "      <td>0.004</td>\n",
+       "      <td>650.0</td>\n",
+       "      <td>208.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>sigma[3]</th>\n",
+       "      <td>1.042</td>\n",
+       "      <td>0.057</td>\n",
+       "      <td>0.928</td>\n",
+       "      <td>1.143</td>\n",
+       "      <td>0.002</td>\n",
+       "      <td>0.004</td>\n",
+       "      <td>664.0</td>\n",
+       "      <td>213.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>sigma[4]</th>\n",
+       "      <td>0.971</td>\n",
+       "      <td>0.054</td>\n",
+       "      <td>0.881</td>\n",
+       "      <td>1.072</td>\n",
+       "      <td>0.002</td>\n",
+       "      <td>0.003</td>\n",
+       "      <td>612.0</td>\n",
+       "      <td>188.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           mean     sd  hdi_3%  hdi_97%  mcse_mean  mcse_sd  ess_bulk  \\\n",
+       "sigma[0]  0.919  0.045   0.834    0.999      0.002    0.003     696.0   \n",
+       "sigma[1]  1.087  0.056   0.993    1.197      0.002    0.003     743.0   \n",
+       "sigma[2]  1.042  0.050   0.942    1.134      0.002    0.004     650.0   \n",
+       "sigma[3]  1.042  0.057   0.928    1.143      0.002    0.004     664.0   \n",
+       "sigma[4]  0.971  0.054   0.881    1.072      0.002    0.003     612.0   \n",
+       "\n",
+       "          ess_tail  r_hat  \n",
+       "sigma[0]     201.0    NaN  \n",
+       "sigma[1]     227.0    NaN  \n",
+       "sigma[2]     208.0    NaN  \n",
+       "sigma[3]     213.0    NaN  \n",
+       "sigma[4]     188.0    NaN  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"Posterior summary for mu:\")\n",
+    "display(az.summary(idata, var_names=[\"mu\"]))\n",
+    "\n",
+    "print(\"\\nPosterior summary for sigma:\")\n",
+    "display(az.summary(idata, var_names=[\"sigma\"]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81b57ed3",
+   "metadata": {},
+   "source": [
+    "### Optional: visual comparison\n",
+    "\n",
+    "If `matplotlib` is available, we can visualize the posterior mean of each\n",
+    "parameter against the true (simulated) value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "03e450bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "post_mu_means = idata.posterior[\"mu\"].mean(dim=(\"chain\", \"draw\")).values\n",
+    "post_sigma_means = idata.posterior[\"sigma\"].mean(dim=(\"chain\", \"draw\")).values\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n",
+    "\n",
+    "# Plot for mu\n",
+    "axes[0].plot(mu_true, \"o-\", label=\"True mu\")\n",
+    "axes[0].plot(post_mu_means, \"x--\", label=\"Posterior mean mu\")\n",
+    "axes[0].set_title(\"Group means\")\n",
+    "axes[0].set_xlabel(\"Group index\")\n",
+    "axes[0].legend()\n",
+    "\n",
+    "# Plot for sigma\n",
+    "axes[1].hlines(sigma_true, xmin=-0.5, xmax=num_groups - 0.5, label=\"True sigma\")\n",
+    "axes[1].plot(post_sigma_means, \"x--\", label=\"Posterior mean sigma\")\n",
+    "axes[1].set_title(\"Group standard deviations\")\n",
+    "axes[1].set_xlabel(\"Group index\")\n",
+    "axes[1].legend()\n",
+    "\n",
+    "fig.suptitle(\"Vector variables: posterior vs true values\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6ebdcb75",
+   "metadata": {},
+   "source": [
+    "## 6. Takeaways\n",
+    "\n",
+    "- You can represent many similar parameters at once by using **vector-valued\n",
+    "  random variables** with a `shape` argument.  \n",
+    "- Use integer labels (like `data_labels`) to index into these vectors and\n",
+    "  connect each observation to the right group parameter.  \n",
+    "- This pattern generalizes to more complex models, including hierarchical\n",
+    "  models where the vector parameters themselves have hyperpriors.\n",
+    "\n",
+    "You can now adapt this pattern to your own models whenever you have many\n",
+    "groups (or categories) that share the same likelihood form but different\n",
+    "parameters."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4862024f",
+   "metadata": {},
+   "source": [
+    "## Watermark\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "382a41d8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The watermark extension is already loaded. To reload it, use:\n",
+      "  %reload_ext watermark\n",
+      "Last updated: Sat Nov 22 2025\n",
+      "\n",
+      "Python implementation: CPython\n",
+      "Python version       : 3.13.9\n",
+      "IPython version      : 9.7.0\n",
+      "\n",
+      "pytensor: 2.35.1\n",
+      "xarray  : 2025.11.0\n",
+      "\n",
+      "matplotlib: 3.10.7\n",
+      "pymc      : 5.26.1\n",
+      "arviz     : 0.22.0\n",
+      "numpy     : 2.3.5\n",
+      "debugpy   : 1.8.17\n",
+      "ipykernel : 7.1.0\n",
+      "\n",
+      "Watermark: 2.5.0\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "%load_ext watermark\n",
+    "%watermark -n -u -v -iv -w -p pytensor,xarray"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 1b79b1c9f73eea320035cdf68c9f449fb6123166 Mon Sep 17 00:00:00 2001
From: "Abhishek.6122008" <Abhishek.612208@gmail.com>
Date: Tue, 25 Nov 2025 02:16:11 +0530
Subject: [PATCH 2/3] added the vector-variable files based on reference given

---
 .../core_notebooks/vector_variables.ipynb     | 1048 ++++++++++-------
 1 file changed, 626 insertions(+), 422 deletions(-)

diff --git a/docs/source/learn/core_notebooks/vector_variables.ipynb b/docs/source/learn/core_notebooks/vector_variables.ipynb
index 23cf13a396..d97c2f6adc 100644
--- a/docs/source/learn/core_notebooks/vector_variables.ipynb
+++ b/docs/source/learn/core_notebooks/vector_variables.ipynb
@@ -2,136 +2,172 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "bb46210d",
+   "id": "777d3f58",
    "metadata": {},
    "source": [
-    "# Demonstrating Vector Variables in PyMC\n",
+    "# Working with vector valued variables for multiple groups in PyMC\n",
     "\n",
-    "This tutorial shows how to work with **vector-valued random variables** in PyMC,\n",
-    "using a simple example with several groups of data that share a common\n",
-    "structure but have different means (and optionally different standard\n",
-    "deviations).\n",
+    "This notebook is written as a response to a recurring question on GitHub and Discourse:  \n",
+    "*“How do I handle multiple groups of data in PyMC and slice vector random variables correctly?”*\n",
     "\n",
-    "We will:\n",
+    "The user’s example had several groups of observations and a vector of `mu` and `sigma` values, one for each group.  \n",
+    "The confusing part was how to turn the group labels into something PyMC can index cleanly, and how to connect those indices to vector valued priors.\n",
     "\n",
-    "1. Simulate data from multiple groups.  \n",
-    "2. Build a PyMC model with vector parameters `mu` (means) and `sigma`.  \n",
-    "3. Use indexing to connect each observation to the right group parameter.  \n",
-    "4. Sample from the posterior and inspect the results.\n",
+    "To make the idea clear, I built a very small example with two levels:\n",
+    "\n",
+    "- a category (like Beverage or Snack)\n",
+    "- a family inside each category\n",
+    "\n",
+    "The goal here isn’t to create a big statistical model,\n",
+    "it’s just to show the exact pattern for:\n",
+    "- factorizing group labels  \n",
+    "- building the mapping between levels  \n",
+    "- creating vector RVs  \n",
+    "- and slicing them correctly inside the likelihood  \n",
+    "\n",
+    "Once you see this simple version working, the structure becomes easy to reuse in real models.\n",
     "\n"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "8384f0b1",
+   "id": "5269058d",
    "metadata": {},
    "source": [
     "## 1. Setup\n",
     "\n",
-    "We start by importing the libraries we need and fixing a random seed for\n",
-    "reproducibility."
+    "Before jumping into the modeling part, we just import the usual tools: NumPy, pandas, ArviZ, and PyMC.  \n",
+    "I also set a random seed so the results don’t wiggle around every time this notebook runs.\n",
+    "\n",
+    "One small thing I like doing , and it helps a lot later is defining named coordinates for the different group levels we’ll work with.  \n",
+    "These labels make ArviZ’s output much easier to read because the plots will show actual names instead of axis numbers.\n",
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "id": "a835935a",
+   "execution_count": 10,
+   "id": "e8f207b4",
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
-      "WARNING (pytensor.configdefaults): g++ not available, if using conda: `conda install gxx`\n",
-      "WARNING (pytensor.configdefaults): g++ not detected!  PyTensor will be unable to compile C-implementations and will default to Python. Performance may be severely degraded. To remove this warning, set PyTensor flags cxx to an empty string.\n"
+      "PyMC version: 5.26.1\n"
      ]
     }
    ],
    "source": [
+    "# Importing the basic libraries we need\n",
+    "# Nothing special here, just the usual stack for PyMC work\n",
     "import arviz as az\n",
+    "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
+    "import pandas as pd\n",
     "\n",
     "import pymc as pm\n",
     "\n",
-    "RANDOM_SEED = 123\n",
-    "rng = np.random.default_rng(RANDOM_SEED)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "fcadcb1d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "# Configure PyTensor to use g++ compiler if available, otherwise suppress warning\n",
-    "import pytensor\n",
-    "\n",
-    "# Try to find g++ compiler\n",
-    "gxx_paths = [\n",
-    "    r\"C:\\Users\\mrcle\\miniconda3\\Library\\bin\\x86_64-w64-mingw32-g++.exe\",\n",
-    "    \"g++\",  # Try system g++ if in PATH\n",
-    "]\n",
-    "\n",
-    "gxx_found = None\n",
-    "for path in gxx_paths:\n",
-    "    if path == \"g++\":\n",
-    "        # Check if g++ is in PATH\n",
-    "        import shutil\n",
-    "\n",
-    "        if shutil.which(\"g++\"):\n",
-    "            gxx_found = \"g++\"\n",
-    "            break\n",
-    "    elif os.path.exists(path):\n",
-    "        gxx_found = path\n",
-    "        break\n",
-    "\n",
-    "if gxx_found:\n",
-    "    pytensor.config.cxx = gxx_found\n",
-    "    print(f\"PyTensor configured to use: {gxx_found}\")\n",
-    "else:\n",
-    "    # Suppress warning if compiler not found\n",
-    "    pytensor.config.cxx = \"\"\n",
-    "    print(\n",
-    "        \"g++ compiler not found. PyTensor will use Python fallback (slower but works fine for examples).\"\n",
-    "    )"
+    "rng = np.random.default_rng(42)\n",
+    "az.style.use(\"arviz-darkgrid\")\n",
+    "\n",
+    "print(\"PyMC version:\", pm.__version__)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "87dcae3e",
+   "id": "113aa86d",
    "metadata": {},
    "source": [
-    "## 2. Simulate grouped data\n",
+    "## 2. A small dataset to illustrate the idea\n",
     "\n",
-    "We create:\n",
+    "The original GitHub issue used five groups of synthetic data.  \n",
+    "To keep things intuitive here, I’m using a slightly more “real world sounding” example: categories and families.\n",
     "\n",
-    "- `num_groups`: how many groups we have.  \n",
-    "- `group_size`: how many observations per group.  \n",
-    "- `sigma_true`: shared standard deviation of the observation noise.  \n",
-    "- `mu_true`: a vector of true group means (used only to generate fake data).\n",
+    "The dataset has three columns:\n",
     "\n",
-    "We then build:\n",
+    "- `category`  \n",
+    "- `family` (which lives inside a category)  \n",
+    "- `sales` (just some numeric values we’ll fit a model to)\n",
     "\n",
-    "- `data`: stacked observations from all groups.  \n",
-    "- `data_labels`: an integer label (0, 1, ..., `num_groups-1`) telling us\n",
-    "  which group each observation belongs to."
+    "The exact numbers don’t matter what matters is that each row belongs to one family, and each family belongs to one category.  \n",
+    "That structure is exactly the situation the user in the issue was dealing with.\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "041b9873",
+   "execution_count": 2,
+   "id": "fdbe45c3",
    "metadata": {},
    "outputs": [
     {
      "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>category</th>\n",
+       "      <th>family</th>\n",
+       "      <th>sales</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Beverage</td>\n",
+       "      <td>Tea</td>\n",
+       "      <td>15.609434</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Beverage</td>\n",
+       "      <td>Milk</td>\n",
+       "      <td>7.920032</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Beverage</td>\n",
+       "      <td>Soft Drinks</td>\n",
+       "      <td>21.500902</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Snack</td>\n",
+       "      <td>Chips</td>\n",
+       "      <td>8.881129</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Snack</td>\n",
+       "      <td>Nuts</td>\n",
+       "      <td>1.097930</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
       "text/plain": [
-       "(array([-1.91745688, -3.13102432, -1.95260845, -2.81115613, -2.81694979,\n",
-       "        -2.39739336, -4.02049108, -1.30239457, -3.16565035, -1.49429126]),\n",
-       " array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))"
+       "   category       family      sales\n",
+       "0  Beverage          Tea  15.609434\n",
+       "1  Beverage         Milk   7.920032\n",
+       "2  Beverage  Soft Drinks  21.500902\n",
+       "3     Snack        Chips   8.881129\n",
+       "4     Snack         Nuts   1.097930"
       ]
      },
      "execution_count": 2,
@@ -140,60 +176,209 @@
     }
    ],
    "source": [
-    "num_groups = 5\n",
-    "group_size = 200\n",
-    "sigma_true = 1.0\n",
+    "# Tiny example dataset\n",
+    "data = pd.DataFrame(\n",
+    "    {\n",
+    "        \"category\": [\"Beverage\", \"Beverage\", \"Beverage\", \"Snack\", \"Snack\"],\n",
+    "        \"family\": [\"Tea\", \"Milk\", \"Soft Drinks\", \"Chips\", \"Nuts\"],\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "# Pretend we observed some sales numbers (generated from a simple ground truth)\n",
+    "true_sales = {\n",
+    "    \"Tea\": 15.0,\n",
+    "    \"Milk\": 10.0,\n",
+    "    \"Soft Drinks\": 20.0,\n",
+    "    \"Chips\": 7.0,\n",
+    "    \"Nuts\": 5.0,\n",
+    "}\n",
+    "data[\"sales\"] = [true_sales[f] + rng.normal(0, 2.0) for f in data[\"family\"]]\n",
+    "\n",
+    "data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "af402ace",
+   "metadata": {},
+   "source": [
+    "## 3. Turning text labels into indices and making the mapping\n",
     "\n",
-    "# True means for each group (just for simulation, not known to the model)\n",
-    "mu_true = rng.normal(loc=np.linspace(-2, 2, num_groups), scale=0.5, size=num_groups)\n",
+    "The thing that usually trips people up is how to connect the observed labels to vector-valued priors.\n",
     "\n",
-    "# Simulate data: for each group, draw `group_size` points\n",
-    "data_per_group = [rng.normal(loc=mu, scale=sigma_true, size=group_size) for mu in mu_true]\n",
-    "data = np.concatenate(data_per_group)\n",
+    "PyMC can only index arrays with integers, so the first step is simply:\n",
+    "- convert the category names into integer codes\n",
+    "- convert the family names into integer codes\n",
     "\n",
-    "# Integer labels telling which group each observation belongs to\n",
-    "data_labels = np.concatenate(\n",
-    "    [np.full(group_size, group_id) for group_id in range(num_groups)]\n",
-    ").astype(int)\n",
+    "Once we have those, we make a small array that maps each family to its category.  \n",
+    "For example: if the 0th family belongs to the 1st category, the mapping array contains a 1 at position 0.\n",
     "\n",
-    "data[:10], data_labels[:10]"
+    "This mapping array is the heart of the whole trick.  \n",
+    "It tells PyMC how the lower level “inherits” from the upper level.\n",
+    "\n"
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "0a50caa9",
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd665a51",
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Category labels: ['Beverage', 'Snack']\n",
+      "Family labels: ['Tea', 'Milk', 'Soft Drinks', 'Chips', 'Nuts']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>category</th>\n",
+       "      <th>family</th>\n",
+       "      <th>sales</th>\n",
+       "      <th>cat_code</th>\n",
+       "      <th>fam_code</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Beverage</td>\n",
+       "      <td>Tea</td>\n",
+       "      <td>15.609434</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Beverage</td>\n",
+       "      <td>Milk</td>\n",
+       "      <td>7.920032</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Beverage</td>\n",
+       "      <td>Soft Drinks</td>\n",
+       "      <td>21.500902</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Snack</td>\n",
+       "      <td>Chips</td>\n",
+       "      <td>8.881129</td>\n",
+       "      <td>1</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Snack</td>\n",
+       "      <td>Nuts</td>\n",
+       "      <td>1.097930</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   category       family      sales  cat_code  fam_code\n",
+       "0  Beverage          Tea  15.609434         0         0\n",
+       "1  Beverage         Milk   7.920032         0         1\n",
+       "2  Beverage  Soft Drinks  21.500902         0         2\n",
+       "3     Snack        Chips   8.881129         1         3\n",
+       "4     Snack         Nuts   1.097930         1         4"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "family_to_category mapping (family index → category index): [0 0 0 1 1]\n",
+      "Length (should equal number of families): 5 vs 5\n"
+     ]
+    }
+   ],
    "source": [
-    "`data` is a 1D array of length `num_groups * group_size`.\n",
+    "# Factorize categories and families into integer codes\n",
+    "cat_codes, cat_labels = pd.factorize(data[\"category\"])\n",
+    "fam_codes, fam_labels = pd.factorize(data[\"family\"])\n",
+    "\n",
+    "data[\"cat_code\"] = cat_codes\n",
+    "data[\"fam_code\"] = fam_codes\n",
+    "\n",
+    "print(\"Category labels:\", list(cat_labels))\n",
+    "print(\"Family labels:\", list(fam_labels))\n",
+    "display(data)\n",
     "\n",
-    "`data_labels` is a 1D integer array of the same length, where each element is\n",
-    "the group index (from 0 to `num_groups - 1`) for the corresponding observation.\n",
+    "# Build mapping\n",
+    "edges = data[[\"fam_code\", \"cat_code\"]].drop_duplicates().sort_values(\"fam_code\")\n",
     "\n",
-    "---"
+    "family_to_category = edges[\"cat_code\"].to_numpy().astype(\"int64\")\n",
+    "\n",
+    "print(\"\\nfamily_to_category mapping (family index → category index):\", family_to_category)\n",
+    "print(\"Length (should equal number of families):\", len(family_to_category), \"vs\", len(fam_labels))"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "69e4fe50",
+   "id": "b6b39354",
    "metadata": {},
    "source": [
-    "## 3. Building the PyMC model with vector variables\n",
+    "## 4. Building the PyMC model\n",
+    "\n",
+    "Now that the indices and mapping are ready, the model becomes fairly straightforward.\n",
+    "\n",
+    "We set up:\n",
+    "- one global intercept\n",
+    "- one category effect per category\n",
+    "- one family effect per family\n",
+    "\n",
+    "The important part is that the family effect is centered on the category effect using the mapping array we created earlier.  \n",
+    "That’s exactly the pattern the user in the GitHub issue needed but wasn’t sure how to set up.\n",
     "\n",
-    "Key idea: instead of defining separate scalar parameters for each group, we\n",
-    "define *vector-valued* parameters:\n",
+    "For each observation, the expected value is:\n",
     "\n",
-    "- `mu`: a length-`num_groups` vector of group means.  \n",
-    "- `sigma`: a length-`num_groups` vector of group standard deviations\n",
-    "  (or we could use a single shared `sigma` if we prefer).\n",
+    "global_mu  \n",
+    "+ the effect for its category  \n",
+    "+ the effect for its family\n",
     "\n",
-    "Then we use **indexing** with `data_labels` to pick the right parameter for\n",
-    "each observation."
+    "Once the indexing is correct, PyMC takes it from there.\n",
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "5bc49764",
+   "execution_count": 11,
+   "id": "c7b47307",
    "metadata": {},
    "outputs": [
     {
@@ -201,71 +386,87 @@
       "text/latex": [
        "$$\n",
        "            \\begin{array}{rcl}\n",
-       "            \\text{mu} &\\sim & \\operatorname{Normal}(0,~10)\\\\\\text{sigma} &\\sim & \\operatorname{HalfNormal}(0,~2)\\\\\\text{y} &\\sim & \\operatorname{Normal}(f(\\text{mu}),~f(\\text{sigma}))\n",
+       "            \\text{global\\_mu} &\\sim & \\operatorname{Normal}(10,~10)\\\\\\text{sigma\\_cat} &\\sim & \\operatorname{HalfNormal}(0,~5)\\\\\\text{category\\_effect} &\\sim & \\operatorname{Normal}(\\text{global\\_mu},~\\text{sigma\\_cat})\\\\\\text{sigma\\_fam} &\\sim & \\operatorname{HalfNormal}(0,~3)\\\\\\text{family\\_effect} &\\sim & \\operatorname{Normal}(f(\\text{category\\_effect}),~\\text{sigma\\_fam})\\\\\\text{sigma\\_obs} &\\sim & \\operatorname{HalfNormal}(0,~2)\\\\\\text{sales} &\\sim & \\operatorname{Normal}(f(\\text{family\\_effect}),~\\text{sigma\\_obs})\n",
        "            \\end{array}\n",
        "            $$"
       ],
       "text/plain": [
-       "   mu ~ Normal(0, 10)\n",
-       "sigma ~ HalfNormal(0, 2)\n",
-       "    y ~ Normal(f(mu), f(sigma))"
+       "      global_mu ~ Normal(10, 10)\n",
+       "      sigma_cat ~ HalfNormal(0, 5)\n",
+       "category_effect ~ Normal(global_mu, sigma_cat)\n",
+       "      sigma_fam ~ HalfNormal(0, 3)\n",
+       "  family_effect ~ Normal(f(category_effect), sigma_fam)\n",
+       "      sigma_obs ~ HalfNormal(0, 2)\n",
+       "          sales ~ Normal(f(family_effect), sigma_obs)"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "with pm.Model() as model:\n",
-    "    # Vector of group means\n",
-    "    mu = pm.Normal(\"mu\", mu=0.0, sigma=10.0, shape=num_groups)\n",
-    "\n",
-    "    # Vector of group standard deviations (half-normal prior)\n",
-    "    sigma = pm.HalfNormal(\"sigma\", sigma=2.0, shape=num_groups)\n",
-    "\n",
-    "    # The likelihood: for each observation i,\n",
-    "    #   data[i] ~ Normal(mu[data_labels[i]], sigma[data_labels[i]])\n",
-    "    likelihood = pm.Normal(\n",
-    "        \"y\",\n",
-    "        mu=mu[data_labels],\n",
-    "        sigma=sigma[data_labels],\n",
-    "        observed=data,\n",
+    "coords = {\n",
+    "    \"category\": cat_labels,\n",
+    "    \"family\": fam_labels,\n",
+    "    \"obs\": np.arange(len(data)),\n",
+    "}\n",
+    "\n",
+    "with pm.Model(coords=coords) as model:\n",
+    "    # Global mean\n",
+    "    global_mu = pm.Normal(\"global_mu\", mu=10.0, sigma=10.0)\n",
+    "\n",
+    "    # Level 0: category level vector variable\n",
+    "    sigma_cat = pm.HalfNormal(\"sigma_cat\", sigma=5.0)\n",
+    "    category_effect = pm.Normal(\n",
+    "        \"category_effect\",\n",
+    "        mu=global_mu,\n",
+    "        sigma=sigma_cat,\n",
+    "        dims=\"category\",\n",
     "    )\n",
     "\n",
-    "model"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7a6f07da",
-   "metadata": {},
-   "source": [
-    "Notes:\n",
+    "    # Level 1: family level vector variable, centered on its category\n",
+    "    sigma_fam = pm.HalfNormal(\"sigma_fam\", sigma=3.0)\n",
+    "    family_effect = pm.Normal(\n",
+    "        \"family_effect\",\n",
+    "        mu=category_effect[family_to_category],\n",
+    "        sigma=sigma_fam,\n",
+    "        dims=\"family\",\n",
+    "    )\n",
+    "\n",
+    "    # Observation model: each row uses its family's effect\n",
+    "    sigma_obs = pm.HalfNormal(\"sigma_obs\", sigma=2.0)\n",
+    "    mu = family_effect[fam_codes]\n",
     "\n",
-    "- `mu[data_labels]` creates a 1D array where each element is the mean\n",
-    "  corresponding to the group of that observation.  \n",
-    "- Similarly for `sigma[data_labels]`.  \n",
-    "- This is the crucial **vectorization trick** that avoids explicit Python loops.\n",
+    "    sales = pm.Normal(\n",
+    "        \"sales\",\n",
+    "        mu=mu,\n",
+    "        sigma=sigma_obs,\n",
+    "        observed=data[\"sales\"].values,\n",
+    "        dims=\"obs\",\n",
+    "    )\n",
     "\n",
-    "---"
+    "model"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "7018a96c",
+   "id": "2a52eb49",
    "metadata": {},
    "source": [
-    "## 4. Sampling from the posterior\n",
+    "## 5. Sampling\n",
     "\n",
-    "Now we run MCMC to obtain samples from the posterior distribution of the\n",
-    "parameters."
+    "Here we let PyMC run `pm.sample()` to draw posterior samples.  \n",
+    "Because the dataset is tiny, this finishes quickly.\n",
+    "\n",
+    "In real modeling work, I’d look at the diagnostics (R-hat, effective sample size, divergences).  \n",
+    "But since this notebook is mainly about *how* to wire up the hierarchical structure, I’m keeping this part simple.\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "id": "d54b6d95",
+   "execution_count": 16,
+   "id": "b8044151",
    "metadata": {},
    "outputs": [
     {
@@ -273,84 +474,39 @@
      "output_type": "stream",
      "text": [
       "Initializing NUTS using jitter+adapt_diag...\n",
-      "Sequential sampling (1 chains in 1 job)\n",
-      "NUTS: [mu, sigma]\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "2fc77221f1204793a41b2527af50d1ed",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Output()"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling 1 chain for 300 tune and 300 draw iterations (300 + 300 draws total) took 409 seconds.\n",
-      "Only one chain was sampled, this makes it impossible to run some convergence checks\n"
+      "Multiprocess sampling (4 chains in 4 jobs)\n",
+      "NUTS: [global_mu, sigma_cat, category_effect, sigma_fam, family_effect, sigma_obs]\n",
+      "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 47 seconds.\n",
+      "There were 132 divergences after tuning. Increase `target_accept` or reparameterize.\n",
+      "The rhat statistic is larger than 1.01 for some parameters. This indicates problems during sampling. See https://arxiv.org/abs/1903.08008 for details\n",
+      "The effective sample size per chain is smaller than 100 for some parameters.  A higher number is needed for reliable rhat and ess computation. See https://arxiv.org/abs/1903.08008 for details\n"
      ]
     }
    ],
    "source": [
+    "%%capture sampling_output\n",
+    "\n",
     "with model:\n",
     "    idata = pm.sample(\n",
-    "        draws=300,\n",
-    "        tune=300,\n",
-    "        chains=1,\n",
-    "        cores=1,\n",
-    "        target_accept=0.9,\n",
-    "        random_seed=RANDOM_SEED,\n",
+    "        draws=1000,\n",
+    "        tune=1000,\n",
+    "        target_accept=0.95,\n",
+    "        chains=4,\n",
+    "        random_seed=42,\n",
     "    )"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "20d662df",
-   "metadata": {},
-   "source": [
-    "## 5. Inspecting the results\n",
-    "\n",
-    "We compare the posterior means of `mu` and `sigma` to the true values used to\n",
-    "simulate the data."
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "id": "a6cc57d9",
+   "execution_count": 13,
+   "id": "edfaacb3",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "arviz - WARNING - Shape validation failed: input_shape: (1, 300), minimum_shape: (chains=2, draws=4)\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Posterior summary for mu:\n"
+      "Sampling finished\n"
      ]
     },
     {
@@ -387,103 +543,161 @@
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>mu[0]</th>\n",
-       "      <td>-2.410</td>\n",
-       "      <td>0.063</td>\n",
-       "      <td>-2.548</td>\n",
-       "      <td>-2.310</td>\n",
-       "      <td>0.002</td>\n",
-       "      <td>0.004</td>\n",
-       "      <td>625.0</td>\n",
-       "      <td>218.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th>global_mu</th>\n",
+       "      <td>10.388</td>\n",
+       "      <td>3.948</td>\n",
+       "      <td>2.743</td>\n",
+       "      <td>17.829</td>\n",
+       "      <td>0.128</td>\n",
+       "      <td>0.116</td>\n",
+       "      <td>957.0</td>\n",
+       "      <td>1060.0</td>\n",
+       "      <td>1.00</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>mu[1]</th>\n",
-       "      <td>-1.208</td>\n",
-       "      <td>0.079</td>\n",
-       "      <td>-1.355</td>\n",
-       "      <td>-1.055</td>\n",
-       "      <td>0.004</td>\n",
-       "      <td>0.005</td>\n",
-       "      <td>569.0</td>\n",
-       "      <td>99.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th>category_effect[Beverage]</th>\n",
+       "      <td>13.100</td>\n",
+       "      <td>3.043</td>\n",
+       "      <td>7.167</td>\n",
+       "      <td>18.509</td>\n",
+       "      <td>0.114</td>\n",
+       "      <td>0.087</td>\n",
+       "      <td>708.0</td>\n",
+       "      <td>992.0</td>\n",
+       "      <td>1.00</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>mu[2]</th>\n",
-       "      <td>0.620</td>\n",
-       "      <td>0.081</td>\n",
-       "      <td>0.475</td>\n",
-       "      <td>0.779</td>\n",
-       "      <td>0.004</td>\n",
-       "      <td>0.006</td>\n",
-       "      <td>515.0</td>\n",
-       "      <td>164.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th>category_effect[Snack]</th>\n",
+       "      <td>7.666</td>\n",
+       "      <td>3.451</td>\n",
+       "      <td>1.303</td>\n",
+       "      <td>14.143</td>\n",
+       "      <td>0.140</td>\n",
+       "      <td>0.086</td>\n",
+       "      <td>607.0</td>\n",
+       "      <td>967.0</td>\n",
+       "      <td>1.00</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>mu[3]</th>\n",
-       "      <td>1.078</td>\n",
-       "      <td>0.082</td>\n",
-       "      <td>0.905</td>\n",
-       "      <td>1.203</td>\n",
-       "      <td>0.003</td>\n",
-       "      <td>0.005</td>\n",
-       "      <td>743.0</td>\n",
-       "      <td>191.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th>family_effect[Tea]</th>\n",
+       "      <td>14.867</td>\n",
+       "      <td>2.355</td>\n",
+       "      <td>9.928</td>\n",
+       "      <td>19.003</td>\n",
+       "      <td>0.100</td>\n",
+       "      <td>0.112</td>\n",
+       "      <td>680.0</td>\n",
+       "      <td>444.0</td>\n",
+       "      <td>1.01</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>mu[4]</th>\n",
-       "      <td>2.551</td>\n",
-       "      <td>0.067</td>\n",
-       "      <td>2.425</td>\n",
-       "      <td>2.671</td>\n",
-       "      <td>0.003</td>\n",
-       "      <td>0.003</td>\n",
-       "      <td>503.0</td>\n",
-       "      <td>254.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th>family_effect[Milk]</th>\n",
+       "      <td>9.568</td>\n",
+       "      <td>2.792</td>\n",
+       "      <td>5.356</td>\n",
+       "      <td>15.709</td>\n",
+       "      <td>0.122</td>\n",
+       "      <td>0.086</td>\n",
+       "      <td>594.0</td>\n",
+       "      <td>1149.0</td>\n",
+       "      <td>1.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>family_effect[Soft Drinks]</th>\n",
+       "      <td>18.811</td>\n",
+       "      <td>3.406</td>\n",
+       "      <td>12.028</td>\n",
+       "      <td>23.687</td>\n",
+       "      <td>0.210</td>\n",
+       "      <td>0.140</td>\n",
+       "      <td>307.0</td>\n",
+       "      <td>561.0</td>\n",
+       "      <td>1.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>family_effect[Chips]</th>\n",
+       "      <td>8.474</td>\n",
+       "      <td>2.405</td>\n",
+       "      <td>3.576</td>\n",
+       "      <td>13.231</td>\n",
+       "      <td>0.086</td>\n",
+       "      <td>0.103</td>\n",
+       "      <td>834.0</td>\n",
+       "      <td>797.0</td>\n",
+       "      <td>1.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>family_effect[Nuts]</th>\n",
+       "      <td>3.094</td>\n",
+       "      <td>3.050</td>\n",
+       "      <td>-1.599</td>\n",
+       "      <td>9.550</td>\n",
+       "      <td>0.157</td>\n",
+       "      <td>0.117</td>\n",
+       "      <td>442.0</td>\n",
+       "      <td>652.0</td>\n",
+       "      <td>1.00</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "        mean     sd  hdi_3%  hdi_97%  mcse_mean  mcse_sd  ess_bulk  ess_tail  \\\n",
-       "mu[0] -2.410  0.063  -2.548   -2.310      0.002    0.004     625.0     218.0   \n",
-       "mu[1] -1.208  0.079  -1.355   -1.055      0.004    0.005     569.0      99.0   \n",
-       "mu[2]  0.620  0.081   0.475    0.779      0.004    0.006     515.0     164.0   \n",
-       "mu[3]  1.078  0.082   0.905    1.203      0.003    0.005     743.0     191.0   \n",
-       "mu[4]  2.551  0.067   2.425    2.671      0.003    0.003     503.0     254.0   \n",
+       "                              mean     sd  hdi_3%  hdi_97%  mcse_mean  \\\n",
+       "global_mu                   10.388  3.948   2.743   17.829      0.128   \n",
+       "category_effect[Beverage]   13.100  3.043   7.167   18.509      0.114   \n",
+       "category_effect[Snack]       7.666  3.451   1.303   14.143      0.140   \n",
+       "family_effect[Tea]          14.867  2.355   9.928   19.003      0.100   \n",
+       "family_effect[Milk]          9.568  2.792   5.356   15.709      0.122   \n",
+       "family_effect[Soft Drinks]  18.811  3.406  12.028   23.687      0.210   \n",
+       "family_effect[Chips]         8.474  2.405   3.576   13.231      0.086   \n",
+       "family_effect[Nuts]          3.094  3.050  -1.599    9.550      0.157   \n",
        "\n",
-       "       r_hat  \n",
-       "mu[0]    NaN  \n",
-       "mu[1]    NaN  \n",
-       "mu[2]    NaN  \n",
-       "mu[3]    NaN  \n",
-       "mu[4]    NaN  "
+       "                            mcse_sd  ess_bulk  ess_tail  r_hat  \n",
+       "global_mu                     0.116     957.0    1060.0   1.00  \n",
+       "category_effect[Beverage]     0.087     708.0     992.0   1.00  \n",
+       "category_effect[Snack]        0.086     607.0     967.0   1.00  \n",
+       "family_effect[Tea]            0.112     680.0     444.0   1.01  \n",
+       "family_effect[Milk]           0.086     594.0    1149.0   1.00  \n",
+       "family_effect[Soft Drinks]    0.140     307.0     561.0   1.00  \n",
+       "family_effect[Chips]          0.103     834.0     797.0   1.00  \n",
+       "family_effect[Nuts]           0.117     442.0     652.0   1.00  "
       ]
      },
+     "execution_count": 13,
      "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "arviz - WARNING - Shape validation failed: input_shape: (1, 300), minimum_shape: (chains=2, draws=4)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Posterior summary for sigma:\n"
-     ]
-    },
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "print(\"Sampling finished\")\n",
+    "\n",
+    "az.summary(idata, var_names=[\"global_mu\", \"category_effect\", \"family_effect\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3e783202",
+   "metadata": {},
+   "source": [
+    "## 6. Inspecting the results\n",
+    "\n",
+    "Now we look at the fitted parameters.  \n",
+    "You should see something like:\n",
+    "\n",
+    "- category effects (one per category)\n",
+    "- family effects (one per family), roughly centered on their category’s effect\n",
+    "\n",
+    "Thanks to the named dimensions we defined earlier, ArviZ will label everything clearly in the plots.  \n",
+    "That was one of the frustrations mentioned in the GitHub issue things got confusing fast without readable labels.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "11ef7bcb",
+   "metadata": {},
+   "outputs": [
     {
      "data": {
       "text/html": [
@@ -518,119 +732,133 @@
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>sigma[0]</th>\n",
-       "      <td>0.919</td>\n",
-       "      <td>0.045</td>\n",
-       "      <td>0.834</td>\n",
-       "      <td>0.999</td>\n",
-       "      <td>0.002</td>\n",
-       "      <td>0.003</td>\n",
-       "      <td>696.0</td>\n",
-       "      <td>201.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th>category_effect[Beverage]</th>\n",
+       "      <td>13.233</td>\n",
+       "      <td>3.067</td>\n",
+       "      <td>7.351</td>\n",
+       "      <td>18.924</td>\n",
+       "      <td>0.117</td>\n",
+       "      <td>0.101</td>\n",
+       "      <td>688.0</td>\n",
+       "      <td>830.0</td>\n",
+       "      <td>1.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>sigma[1]</th>\n",
-       "      <td>1.087</td>\n",
-       "      <td>0.056</td>\n",
-       "      <td>0.993</td>\n",
-       "      <td>1.197</td>\n",
-       "      <td>0.002</td>\n",
-       "      <td>0.003</td>\n",
-       "      <td>743.0</td>\n",
-       "      <td>227.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th>category_effect[Snack]</th>\n",
+       "      <td>7.731</td>\n",
+       "      <td>3.501</td>\n",
+       "      <td>1.323</td>\n",
+       "      <td>14.254</td>\n",
+       "      <td>0.137</td>\n",
+       "      <td>0.086</td>\n",
+       "      <td>648.0</td>\n",
+       "      <td>718.0</td>\n",
+       "      <td>1.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>sigma[2]</th>\n",
-       "      <td>1.042</td>\n",
-       "      <td>0.050</td>\n",
-       "      <td>0.942</td>\n",
-       "      <td>1.134</td>\n",
-       "      <td>0.002</td>\n",
-       "      <td>0.004</td>\n",
-       "      <td>650.0</td>\n",
-       "      <td>208.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th>family_effect[Tea]</th>\n",
+       "      <td>14.814</td>\n",
+       "      <td>2.436</td>\n",
+       "      <td>9.550</td>\n",
+       "      <td>18.912</td>\n",
+       "      <td>0.093</td>\n",
+       "      <td>0.112</td>\n",
+       "      <td>609.0</td>\n",
+       "      <td>909.0</td>\n",
+       "      <td>1.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>sigma[3]</th>\n",
-       "      <td>1.042</td>\n",
-       "      <td>0.057</td>\n",
-       "      <td>0.928</td>\n",
-       "      <td>1.143</td>\n",
-       "      <td>0.002</td>\n",
-       "      <td>0.004</td>\n",
-       "      <td>664.0</td>\n",
-       "      <td>213.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th>family_effect[Milk]</th>\n",
+       "      <td>9.731</td>\n",
+       "      <td>2.897</td>\n",
+       "      <td>4.775</td>\n",
+       "      <td>15.363</td>\n",
+       "      <td>0.168</td>\n",
+       "      <td>0.152</td>\n",
+       "      <td>363.0</td>\n",
+       "      <td>477.0</td>\n",
+       "      <td>1.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>sigma[4]</th>\n",
-       "      <td>0.971</td>\n",
-       "      <td>0.054</td>\n",
-       "      <td>0.881</td>\n",
-       "      <td>1.072</td>\n",
-       "      <td>0.002</td>\n",
-       "      <td>0.003</td>\n",
-       "      <td>612.0</td>\n",
-       "      <td>188.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <th>family_effect[Soft Drinks]</th>\n",
+       "      <td>18.828</td>\n",
+       "      <td>3.397</td>\n",
+       "      <td>12.115</td>\n",
+       "      <td>23.949</td>\n",
+       "      <td>0.234</td>\n",
+       "      <td>0.128</td>\n",
+       "      <td>254.0</td>\n",
+       "      <td>681.0</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>family_effect[Chips]</th>\n",
+       "      <td>8.505</td>\n",
+       "      <td>2.368</td>\n",
+       "      <td>3.783</td>\n",
+       "      <td>12.998</td>\n",
+       "      <td>0.090</td>\n",
+       "      <td>0.107</td>\n",
+       "      <td>746.0</td>\n",
+       "      <td>600.0</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>family_effect[Nuts]</th>\n",
+       "      <td>3.243</td>\n",
+       "      <td>3.056</td>\n",
+       "      <td>-1.170</td>\n",
+       "      <td>10.038</td>\n",
+       "      <td>0.201</td>\n",
+       "      <td>0.147</td>\n",
+       "      <td>309.0</td>\n",
+       "      <td>437.0</td>\n",
+       "      <td>1.0</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "           mean     sd  hdi_3%  hdi_97%  mcse_mean  mcse_sd  ess_bulk  \\\n",
-       "sigma[0]  0.919  0.045   0.834    0.999      0.002    0.003     696.0   \n",
-       "sigma[1]  1.087  0.056   0.993    1.197      0.002    0.003     743.0   \n",
-       "sigma[2]  1.042  0.050   0.942    1.134      0.002    0.004     650.0   \n",
-       "sigma[3]  1.042  0.057   0.928    1.143      0.002    0.004     664.0   \n",
-       "sigma[4]  0.971  0.054   0.881    1.072      0.002    0.003     612.0   \n",
+       "                              mean     sd  hdi_3%  hdi_97%  mcse_mean  \\\n",
+       "category_effect[Beverage]   13.233  3.067   7.351   18.924      0.117   \n",
+       "category_effect[Snack]       7.731  3.501   1.323   14.254      0.137   \n",
+       "family_effect[Tea]          14.814  2.436   9.550   18.912      0.093   \n",
+       "family_effect[Milk]          9.731  2.897   4.775   15.363      0.168   \n",
+       "family_effect[Soft Drinks]  18.828  3.397  12.115   23.949      0.234   \n",
+       "family_effect[Chips]         8.505  2.368   3.783   12.998      0.090   \n",
+       "family_effect[Nuts]          3.243  3.056  -1.170   10.038      0.201   \n",
        "\n",
-       "          ess_tail  r_hat  \n",
-       "sigma[0]     201.0    NaN  \n",
-       "sigma[1]     227.0    NaN  \n",
-       "sigma[2]     208.0    NaN  \n",
-       "sigma[3]     213.0    NaN  \n",
-       "sigma[4]     188.0    NaN  "
+       "                            mcse_sd  ess_bulk  ess_tail  r_hat  \n",
+       "category_effect[Beverage]     0.101     688.0     830.0    1.0  \n",
+       "category_effect[Snack]        0.086     648.0     718.0    1.0  \n",
+       "family_effect[Tea]            0.112     609.0     909.0    1.0  \n",
+       "family_effect[Milk]           0.152     363.0     477.0    1.0  \n",
+       "family_effect[Soft Drinks]    0.128     254.0     681.0    1.0  \n",
+       "family_effect[Chips]          0.107     746.0     600.0    1.0  \n",
+       "family_effect[Nuts]           0.147     309.0     437.0    1.0  "
       ]
      },
+     "execution_count": 6,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "print(\"Posterior summary for mu:\")\n",
-    "display(az.summary(idata, var_names=[\"mu\"]))\n",
-    "\n",
-    "print(\"\\nPosterior summary for sigma:\")\n",
-    "display(az.summary(idata, var_names=[\"sigma\"]))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "81b57ed3",
-   "metadata": {},
-   "source": [
-    "### Optional: visual comparison\n",
-    "\n",
-    "If `matplotlib` is available, we can visualize the posterior mean of each\n",
-    "parameter against the true (simulated) value."
+    "az.summary(idata, var_names=[\"category_effect\", \"family_effect\"])"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
-   "id": "03e450bf",
+   "id": "47795582",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1000x400 with 2 Axes>"
+       "<Figure size 600x570 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -638,86 +866,62 @@
     }
    ],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "post_mu_means = idata.posterior[\"mu\"].mean(dim=(\"chain\", \"draw\")).values\n",
-    "post_sigma_means = idata.posterior[\"sigma\"].mean(dim=(\"chain\", \"draw\")).values\n",
-    "\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n",
-    "\n",
-    "# Plot for mu\n",
-    "axes[0].plot(mu_true, \"o-\", label=\"True mu\")\n",
-    "axes[0].plot(post_mu_means, \"x--\", label=\"Posterior mean mu\")\n",
-    "axes[0].set_title(\"Group means\")\n",
-    "axes[0].set_xlabel(\"Group index\")\n",
-    "axes[0].legend()\n",
-    "\n",
-    "# Plot for sigma\n",
-    "axes[1].hlines(sigma_true, xmin=-0.5, xmax=num_groups - 0.5, label=\"True sigma\")\n",
-    "axes[1].plot(post_sigma_means, \"x--\", label=\"Posterior mean sigma\")\n",
-    "axes[1].set_title(\"Group standard deviations\")\n",
-    "axes[1].set_xlabel(\"Group index\")\n",
-    "axes[1].legend()\n",
-    "\n",
-    "fig.suptitle(\"Vector variables: posterior vs true values\")\n",
-    "plt.tight_layout()\n",
+    "az.plot_forest(\n",
+    "    idata,\n",
+    "    var_names=[\"category_effect\", \"family_effect\"],\n",
+    "    combined=True,\n",
+    ")\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "6ebdcb75",
+   "id": "e3c83a47",
    "metadata": {},
    "source": [
-    "## 6. Takeaways\n",
-    "\n",
-    "- You can represent many similar parameters at once by using **vector-valued\n",
-    "  random variables** with a `shape` argument.  \n",
-    "- Use integer labels (like `data_labels`) to index into these vectors and\n",
-    "  connect each observation to the right group parameter.  \n",
-    "- This pattern generalizes to more complex models, including hierarchical\n",
-    "  models where the vector parameters themselves have hyperpriors.\n",
-    "\n",
-    "You can now adapt this pattern to your own models whenever you have many\n",
-    "groups (or categories) that share the same likelihood form but different\n",
-    "parameters."
+    "## 7. Takeaways\n",
+    "\n",
+    "Once you walk through this pattern once, it becomes much easier to set up similar models:\n",
+    "\n",
+    "- factorize the labels into integer indices  \n",
+    "- build one mapping array from the lower level to the upper level  \n",
+    "- index the upper level parameters using that mapping  \n",
+    "- use those indexed values to center the lower level parameters\n",
+    "\n",
+    "This is all the original GitHub post was struggling with on how to slice vector RVs cleanly.\n",
+    "\n",
+    "Once the mapping is in place, the rest of the model looks like any other hierarchical setup.\n"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "4862024f",
+   "id": "39c4c0af",
    "metadata": {},
    "source": [
-    "## Watermark\n"
+    "## Watermark"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
-   "id": "382a41d8",
+   "id": "33e5147c",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "The watermark extension is already loaded. To reload it, use:\n",
-      "  %reload_ext watermark\n",
-      "Last updated: Sat Nov 22 2025\n",
+      "Last updated: Tue Nov 25 2025\n",
       "\n",
       "Python implementation: CPython\n",
-      "Python version       : 3.13.9\n",
+      "Python version       : 3.11.14\n",
       "IPython version      : 9.7.0\n",
       "\n",
-      "pytensor: 2.35.1\n",
-      "xarray  : 2025.11.0\n",
-      "\n",
       "matplotlib: 3.10.7\n",
-      "pymc      : 5.26.1\n",
+      "pymc      : 5.26.1+28.g4ad7fa8f8\n",
       "arviz     : 0.22.0\n",
+      "pandas    : 2.3.3\n",
       "numpy     : 2.3.5\n",
-      "debugpy   : 1.8.17\n",
-      "ipykernel : 7.1.0\n",
       "\n",
       "Watermark: 2.5.0\n",
       "\n"
@@ -726,13 +930,13 @@
    ],
    "source": [
     "%load_ext watermark\n",
-    "%watermark -n -u -v -iv -w -p pytensor,xarray"
+    "%watermark -n -u -v -iv -w"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "venv",
+   "display_name": "pymc-dev",
    "language": "python",
    "name": "python3"
   },
@@ -746,7 +950,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.9"
+   "version": "3.11.14"
   }
  },
  "nbformat": 4,

From f075e33a68d1790624f7a055493f76f2a32f6cca Mon Sep 17 00:00:00 2001
From: "Abhishek.6122008" <Abhishek.612208@gmail.com>
Date: Tue, 25 Nov 2025 02:25:42 +0530
Subject: [PATCH 3/3] added an optional cell block for extending the pattern to
 more than two levels

---
 .../core_notebooks/vector_variables.ipynb     | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/docs/source/learn/core_notebooks/vector_variables.ipynb b/docs/source/learn/core_notebooks/vector_variables.ipynb
index d97c2f6adc..894b5dd4e0 100644
--- a/docs/source/learn/core_notebooks/vector_variables.ipynb
+++ b/docs/source/learn/core_notebooks/vector_variables.ipynb
@@ -893,6 +893,43 @@
     "Once the mapping is in place, the rest of the model looks like any other hierarchical setup.\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "1be8ea9b",
+   "metadata": {},
+   "source": [
+    "## Optional: Extending this pattern to more than two levels\n",
+    "\n",
+    "This example uses two levels (category and family), but the same idea works for any number of levels.  \n",
+    "The key ingredients stay the same:\n",
+    "\n",
+    "1. factorize each level of labels into integer codes  \n",
+    "2. build a mapping array from each level to the one above it  \n",
+    "3. use that mapping to index the parent vector inside the next level’s prior\n",
+    "\n",
+    "For example, if you had three levels:\n",
+    "\n",
+    "- level_0\n",
+    "- level_1\n",
+    "- level_2\n",
+    "\n",
+    "You would create the following:\n",
+    "\n",
+    "- level_1_to_level_0\n",
+    "- level_2_to_level_1\n",
+    "\n",
+    "Then you would define priors like this:\n",
+    "\n",
+    "- level_0_effect\n",
+    "- level_1_effect, centered on level_0_effect[level_1_to_level_0]\n",
+    "- level_2_effect, centered on level_1_effect[level_2_to_level_1]\n",
+    "\n",
+    "Each additional level only requires one more factorized index and one more mapping array.  \n",
+    "Nothing else about the PyMC model needs to change.\n",
+    "\n",
+    "This is what people sometimes call a telescoping hierarchy: every group is centered on the group above it, and the indexing arrays connect the levels together.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "39c4c0af",