diff --git a/.gitignore b/.gitignore
index ebe8e61bd0..d2c130f80a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -55,3 +55,16 @@ pytensor-venv/
 testing-report.html
 coverage.xml
 .coverage.*
+
+# ai
+.ai/
+.claude/
+.cursor/
+.CLAUDE.md
+
+# gallery notebook downloaded data
+doc/gallery/**/data/
+
+# JupyterLab session artifacts
+.jupyter/
+.jupyter_ystore.db
\ No newline at end of file
diff --git a/doc/gallery/transformers/tiny_transformer_llm.ipynb b/doc/gallery/transformers/tiny_transformer_llm.ipynb
new file mode 100644
index 0000000000..2f1e8771e9
--- /dev/null
+++ b/doc/gallery/transformers/tiny_transformer_llm.ipynb
@@ -0,0 +1,1278 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "(Tiny_Transformer_LLM)=\n",
+        "# A Tiny Transformer LLM in PyTensor\n",
+        "\n",
+        "Can you train a transformer language model end-to-end in PyTensor? Yes — and that is exactly what we do in this notebook. We build a small **decoder-only GPT** on character-level Tiny Shakespeare, train it with a hand-rolled **Adam** optimizer, and sample from it. Along the way we showcase what makes PyTensor distinctive for deep learning:\n",
+        "\n",
+        "* `pytensor.xtensor` **named dimensions** drive multi-head attention, so the `(batch, head, time, head_dim)` reshape gymnastics become self-documenting code,\n",
+        "* a **static graph** you can inspect with `pytensor.dprint`,\n",
+        "* symbolic **reverse-mode auto-diff** via `pytensor.grad`,\n",
+        "* `pytensor.shared` parameter state with **in-graph optimizer updates**, and\n",
+        "* `pytensor.scan` for **autoregressive generation** — the entire sampling loop, including all forward passes and all categorical draws, runs inside a single compiled call.\n",
+        "\n",
+        "The model is intentionally tiny (~100k parameters, a few thousand training steps) so the whole notebook runs on a laptop CPU in a couple of minutes.\n",
+        "\n",
+        "## Prepare notebook"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:26.660089Z",
+          "iopub.status.busy": "2026-05-07T13:13:26.659993Z",
+          "iopub.status.idle": "2026-05-07T13:13:27.126450Z",
+          "shell.execute_reply": "2026-05-07T13:13:27.125234Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "pytensor: 3.0.5+30.g1bb3ee02f | floatX: float64\n"
+          ]
+        }
+      ],
+      "source": [
+        "from __future__ import annotations\n",
+        "\n",
+        "import time\n",
+        "import urllib.request\n",
+        "from dataclasses import dataclass\n",
+        "from pathlib import Path\n",
+        "\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "\n",
+        "import pytensor\n",
+        "import pytensor.tensor as pt\n",
+        "import pytensor.xtensor as ptx\n",
+        "\n",
+        "\n",
+        "plt.style.use(\"seaborn-v0_8\")\n",
+        "\n",
+        "%config InlineBackend.figure_format = \"retina\"\n",
+        "\n",
+        "rng_np = np.random.default_rng(0)\n",
+        "floatX = pytensor.config.floatX\n",
+        "print(\"pytensor:\", pytensor.__version__, \"| floatX:\", floatX)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Data — Tiny Shakespeare\n",
+        "\n",
+        "We download Andrej Karpathy's 1.1 MB **Tiny Shakespeare** corpus into a local cache directory and use a character-level vocabulary (~65 unique characters). To keep training fast on a laptop, we slice off only the first ~50,000 characters — plenty for the model to learn the shape, rhythm, and common words of Shakespearean English."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:27.129250Z",
+          "iopub.status.busy": "2026-05-07T13:13:27.128943Z",
+          "iopub.status.idle": "2026-05-07T13:13:27.134375Z",
+          "shell.execute_reply": "2026-05-07T13:13:27.133378Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Downloading https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt\n",
+            "Full corpus: 1,115,394 characters\n",
+            "Used slice : 50,000 characters\n",
+            "\n",
+            "--- First 200 characters ---\n",
+            "\n",
+            "First Citizen:\n",
+            "Before we proceed any further, hear me speak.\n",
+            "\n",
+            "All:\n",
+            "Speak, speak.\n",
+            "\n",
+            "First Citizen:\n",
+            "You are all resolved rather to die than to famish?\n",
+            "\n",
+            "All:\n",
+            "Resolved. resolved.\n",
+            "\n",
+            "First Citizen:\n",
+            "First, you\n"
+          ]
+        }
+      ],
+      "source": [
+        "DATA_DIR = Path(\"data\")\n",
+        "DATA_DIR.mkdir(parents=True, exist_ok=True)\n",
+        "DATA_FILE = DATA_DIR / \"tinyshakespeare.txt\"\n",
+        "DATA_URL = (\n",
+        "    \"https://raw.githubusercontent.com/karpathy/char-rnn/\"\n",
+        "    \"master/data/tinyshakespeare/input.txt\"\n",
+        ")\n",
+        "\n",
+        "if not DATA_FILE.exists():\n",
+        "    print(\"Downloading\", DATA_URL)\n",
+        "    urllib.request.urlretrieve(DATA_URL, DATA_FILE)\n",
+        "\n",
+        "full_text = DATA_FILE.read_text()\n",
+        "print(f\"Full corpus: {len(full_text):,} characters\")\n",
+        "\n",
+        "# Use a small slice so training is fast in a notebook.\n",
+        "text = full_text[:50_000]\n",
+        "print(f\"Used slice : {len(text):,} characters\")\n",
+        "print(\"\\n--- First 200 characters ---\\n\")\n",
+        "print(text[:200])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:27.136096Z",
+          "iopub.status.busy": "2026-05-07T13:13:27.135971Z",
+          "iopub.status.idle": "2026-05-07T13:13:27.143040Z",
+          "shell.execute_reply": "2026-05-07T13:13:27.141910Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "vocab_size = 59\n",
+            "first 20 ids: [15, 41, 50, 51, 52, 1, 12, 41, 52, 41, 58, 37, 46, 7, 0, 11, 37, 38, 47, 50]\n",
+            "round-trip : 'First Citizen:\\nBefor'\n"
+          ]
+        }
+      ],
+      "source": [
+        "chars = sorted(set(text))\n",
+        "vocab_size = len(chars)\n",
+        "stoi = {c: i for i, c in enumerate(chars)}\n",
+        "itos = {i: c for i, c in enumerate(chars)}\n",
+        "\n",
+        "def encode(s: str) -> np.ndarray:\n",
+        "    return np.array([stoi[c] for c in s], dtype=\"int64\")\n",
+        "\n",
+        "def decode(arr: np.ndarray) -> str:\n",
+        "    return \"\".join(itos[int(i)] for i in arr)\n",
+        "\n",
+        "data_ids = encode(text)\n",
+        "print(f\"vocab_size = {vocab_size}\")\n",
+        "print(f\"first 20 ids: {data_ids[:20].tolist()}\")\n",
+        "print(f\"round-trip : {decode(data_ids[:20])!r}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Mini-batches of `(context, next-char)` pairs\n",
+        "\n",
+        "The transformer reads a window of `block_size` characters and predicts the next character at every position, so a batch element is a pair `(x, y)` of `block_size`-length sequences where `y[t] = x[t + 1]`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:27.145023Z",
+          "iopub.status.busy": "2026-05-07T13:13:27.144920Z",
+          "iopub.status.idle": "2026-05-07T13:13:27.149354Z",
+          "shell.execute_reply": "2026-05-07T13:13:27.148415Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "x[0]: 'renowned Coriola'\n",
+            "y[0]: 'enowned Coriolan'\n"
+          ]
+        }
+      ],
+      "source": [
+        "def get_batch(rng: np.random.Generator, batch_size: int, block_size: int):\n",
+        "    \"\"\"Sample `batch_size` random windows of length `block_size + 1` from the corpus.\"\"\"\n",
+        "    starts = rng.integers(0, len(data_ids) - block_size - 1, size=batch_size)\n",
+        "    x = np.stack([data_ids[s : s + block_size] for s in starts])\n",
+        "    y = np.stack([data_ids[s + 1 : s + 1 + block_size] for s in starts])\n",
+        "    return x, y\n",
+        "\n",
+        "x_demo, y_demo = get_batch(rng_np, batch_size=2, block_size=16)\n",
+        "print(\"x[0]:\", repr(decode(x_demo[0])))\n",
+        "print(\"y[0]:\", repr(decode(y_demo[0])))\n",
+        "assert (x_demo[:, 1:] == y_demo[:, :-1]).all(), \"y is x shifted by one\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Hyper-parameters and parameter init\n",
+        "\n",
+        "A tiny GPT-style transformer with a few thousand parameters. Note that `block_size` is *static* in the PyTensor graph (it appears in the causal-mask shape), while `batch_size` is left symbolic so we can train on `B=16` and sample at `B=1` with the **same** compiled graph."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:27.151290Z",
+          "iopub.status.busy": "2026-05-07T13:13:27.151119Z",
+          "iopub.status.idle": "2026-05-07T13:13:27.156816Z",
+          "shell.execute_reply": "2026-05-07T13:13:27.156272Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "Config(vocab_size=59, block_size=32, n_embd=64, n_head=4, n_layer=2)"
+            ]
+          },
+          "execution_count": 5,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "@dataclass\n",
+        "class Config:\n",
+        "    vocab_size: int\n",
+        "    block_size: int = 32\n",
+        "    n_embd: int = 64\n",
+        "    n_head: int = 4\n",
+        "    n_layer: int = 2\n",
+        "\n",
+        "    @property\n",
+        "    def head_dim(self) -> int:\n",
+        "        assert self.n_embd % self.n_head == 0, \"n_embd must be divisible by n_head\"\n",
+        "        return self.n_embd // self.n_head\n",
+        "\n",
+        "cfg = Config(vocab_size=vocab_size)\n",
+        "cfg"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:27.158183Z",
+          "iopub.status.busy": "2026-05-07T13:13:27.158078Z",
+          "iopub.status.idle": "2026-05-07T13:13:27.167215Z",
+          "shell.execute_reply": "2026-05-07T13:13:27.166803Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "20 shared variables, 104,768 total parameters\n"
+          ]
+        }
+      ],
+      "source": [
+        "def init_params(cfg: Config, rng: np.random.Generator) -> dict[str, np.ndarray]:\n",
+        "    D = cfg.n_embd\n",
+        "    p: dict[str, np.ndarray] = {}\n",
+        "\n",
+        "    p[\"tok_embed\"] = rng.normal(0, 0.02, (cfg.vocab_size, D)).astype(floatX)\n",
+        "    p[\"pos_embed\"] = rng.normal(0, 0.02, (cfg.block_size, D)).astype(floatX)\n",
+        "\n",
+        "    for i in range(cfg.n_layer):\n",
+        "        p[f\"l{i}.ln1_g\"] = np.ones(D, dtype=floatX)\n",
+        "        p[f\"l{i}.ln1_b\"] = np.zeros(D, dtype=floatX)\n",
+        "        p[f\"l{i}.W_qkv\"] = rng.normal(0, 0.02, (D, 3 * D)).astype(floatX)\n",
+        "        p[f\"l{i}.W_proj\"] = rng.normal(0, 0.02, (D, D)).astype(floatX)\n",
+        "        p[f\"l{i}.ln2_g\"] = np.ones(D, dtype=floatX)\n",
+        "        p[f\"l{i}.ln2_b\"] = np.zeros(D, dtype=floatX)\n",
+        "        p[f\"l{i}.W_fc\"] = rng.normal(0, 0.02, (D, 4 * D)).astype(floatX)\n",
+        "        p[f\"l{i}.W_proj2\"] = rng.normal(0, 0.02, (4 * D, D)).astype(floatX)\n",
+        "\n",
+        "    p[\"ln_f_g\"] = np.ones(D, dtype=floatX)\n",
+        "    p[\"ln_f_b\"] = np.zeros(D, dtype=floatX)\n",
+        "    return p\n",
+        "\n",
+        "# Wrap each numpy array in a `pytensor.shared` so the optimizer can update it in-graph.\n",
+        "init_arrays = init_params(cfg, np.random.default_rng(42))\n",
+        "params = {name: pytensor.shared(arr, name=name) for name, arr in init_arrays.items()}\n",
+        "\n",
+        "n_params = sum(arr.size for arr in init_arrays.values())\n",
+        "print(f\"{len(params)} shared variables, {n_params:,} total parameters\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## The model with named-dimension attention\n",
+        "\n",
+        "Multi-head attention is the place in transformer code where axis bookkeeping bites the hardest: `(B, T, D)` becomes `(B, T, H, hd)` and then `(B, H, T, hd)`, and you have to remember every transpose. We build attention with [`pytensor.xtensor`](../../library/xtensor.rst), which gives every dimension a **name**, so each operation is driven by what the axis *means* rather than its index. The xtensor sub-graph is lowered to ordinary tensor ops at compile time, so the same Numba / JAX / C / MLX backends still apply.\n",
+        "\n",
+        "Layernorm, MLP, embeddings, and the residual stream stay as plain `pytensor.tensor`, where named dimensions add little. Every component is a Python function that **builds a symbolic graph** from its inputs; these functions run *once* at graph-construction time, so there is no per-batch Python overhead during training."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:27.168815Z",
+          "iopub.status.busy": "2026-05-07T13:13:27.168689Z",
+          "iopub.status.idle": "2026-05-07T13:13:27.173978Z",
+          "shell.execute_reply": "2026-05-07T13:13:27.173296Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "def layernorm(x, gamma, beta, eps=1e-5):\n",
+        "    mu = x.mean(axis=-1, keepdims=True)\n",
+        "    var = x.var(axis=-1, keepdims=True)\n",
+        "    return (x - mu) / pt.sqrt(var + eps) * gamma + beta\n",
+        "\n",
+        "\n",
+        "def causal_self_attention(x, p, n_head, head_dim, block_size):\n",
+        "    \"\"\"Multi-head causal self-attention with named dimensions.\n",
+        "\n",
+        "    Inputs/outputs are plain `(B, T, D)` tensors. Internally we wrap them as\n",
+        "    xtensors with named dims and reshape `W_qkv` to expose ('qkv', 'head', 'hd')\n",
+        "    as named axes — from then on every op is pure semantics: contract over\n",
+        "    'embd', contract over 'hd' (head_dim), softmax over 'time_k'. The `assert`s\n",
+        "    on `.dims` aren't just documentation: PyTensor xtensors carry their dim\n",
+        "    names symbolically, so they're always available for introspection.\n",
+        "    \"\"\"\n",
+        "    D = n_head * head_dim\n",
+        "    x_x = ptx.as_xtensor(x, dims=(\"batch\", \"time\", \"embd\"))\n",
+        "    Wqkv = ptx.as_xtensor(\n",
+        "        p[\"W_qkv\"].reshape((D, 3, n_head, head_dim)),\n",
+        "        dims=(\"embd\", \"qkv\", \"head\", \"hd\"),\n",
+        "    )\n",
+        "    Wproj = ptx.as_xtensor(p[\"W_proj\"], dims=(\"embd\", \"embd_out\"))\n",
+        "\n",
+        "    qkv = ptx.dot(x_x, Wqkv, dim=\"embd\")\n",
+        "    assert qkv.dims == (\"batch\", \"time\", \"qkv\", \"head\", \"hd\")\n",
+        "    q = qkv.isel(qkv=0).rename(time=\"time_q\")\n",
+        "    k = qkv.isel(qkv=1).rename(time=\"time_k\")\n",
+        "    v = qkv.isel(qkv=2).rename(time=\"time_k\")\n",
+        "\n",
+        "    scale = np.sqrt(head_dim).astype(floatX)\n",
+        "    scores = ptx.dot(q, k, dim=\"hd\") / scale\n",
+        "    assert scores.dims == (\"batch\", \"time_q\", \"head\", \"time_k\")\n",
+        "\n",
+        "    mask = ptx.as_xtensor(\n",
+        "        pt.tril(pt.ones((block_size, block_size), dtype=\"bool\")),\n",
+        "        dims=(\"time_q\", \"time_k\"),\n",
+        "    )\n",
+        "    scores = ptx.where(mask, scores, np.float64(-1e9))\n",
+        "    attn = ptx.math.softmax(scores, dim=\"time_k\")\n",
+        "\n",
+        "    out = ptx.dot(attn, v, dim=\"time_k\")\n",
+        "    assert out.dims == (\"time_q\", \"batch\", \"head\", \"hd\")\n",
+        "    out = ptx.stack(out, embd=(\"head\", \"hd\"))\n",
+        "    assert out.dims == (\"time_q\", \"batch\", \"embd\")\n",
+        "    out = ptx.dot(out, Wproj, dim=\"embd\").rename(time_q=\"time\", embd_out=\"embd\")\n",
+        "    return out.transpose(\"batch\", \"time\", \"embd\").values\n",
+        "\n",
+        "\n",
+        "def mlp(x, p):\n",
+        "    h = pt.tanh(x @ p[\"W_fc\"])              # tanh keeps the toy model simple\n",
+        "    return h @ p[\"W_proj2\"]\n",
+        "\n",
+        "\n",
+        "def block(x, params, layer: int, n_head: int, head_dim: int, block_size: int):\n",
+        "    p = {k.split(\".\", 1)[1]: v for k, v in params.items() if k.startswith(f\"l{layer}.\")}\n",
+        "    x = x + causal_self_attention(\n",
+        "        layernorm(x, p[\"ln1_g\"], p[\"ln1_b\"]), p, n_head, head_dim, block_size\n",
+        "    )\n",
+        "    x = x + mlp(layernorm(x, p[\"ln2_g\"], p[\"ln2_b\"]), p)\n",
+        "    return x\n",
+        "\n",
+        "\n",
+        "def forward(tokens, params, cfg: Config):\n",
+        "    \"\"\"Returns logits of shape (B, T, vocab_size). Uses tied embeddings.\"\"\"\n",
+        "    h = params[\"tok_embed\"][tokens] + params[\"pos_embed\"]\n",
+        "    for i in range(cfg.n_layer):\n",
+        "        h = block(h, params, i, cfg.n_head, cfg.head_dim, cfg.block_size)\n",
+        "    h = layernorm(h, params[\"ln_f_g\"], params[\"ln_f_b\"])\n",
+        "    return h @ params[\"tok_embed\"].T        # tied output head"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now we build the symbolic logits graph and inspect it. The whole forward pass is a single `TensorVariable`, with the named-dimension attention sub-graph showing up as a wrapped xtensor block. The `lower_xtensor` rewrite (which runs automatically at compile time) replaces those xtensor ops with plain tensor ops."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:27.175559Z",
+          "iopub.status.busy": "2026-05-07T13:13:27.175439Z",
+          "iopub.status.idle": "2026-05-07T13:13:27.284973Z",
+          "shell.execute_reply": "2026-05-07T13:13:27.284421Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "logits type: Tensor3(float64, shape=(?, 32, ?))\n",
+            "\n",
+            "--- forward graph (truncated) ---\n",
+            "Matmul [id A]\n",
+            " ├─ Add [id B]\n",
+            " │  ├─ Mul [id C]\n",
+            " │  │  ├─ True_div [id D]\n",
+            " │  │  └─ ExpandDims{axes=(0, 1)} [id E]\n",
+            " │  └─ ExpandDims{axes=(0, 1)} [id F]\n",
+            " │     └─ ln_f_b [id G]\n",
+            " └─ ExpandDims{axis=0} [id H]\n",
+            "    └─ MatrixTranspose [id I] 'tok_embed.T'\n",
+            "       └─ tok_embed [id J]\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "<ipykernel.iostream.OutStream at 0x118c454b0>"
+            ]
+          },
+          "execution_count": 8,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "X_sym = pt.tensor(\"X\", shape=(None, cfg.block_size), dtype=\"int64\")\n",
+        "logits = forward(X_sym, params, cfg)\n",
+        "print(\"logits type:\", logits.type)\n",
+        "print(\"\\n--- forward graph (truncated) ---\")\n",
+        "logits.dprint(depth=4)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:27.286619Z",
+          "iopub.status.busy": "2026-05-07T13:13:27.286405Z",
+          "iopub.status.idle": "2026-05-07T13:13:30.359631Z",
+          "shell.execute_reply": "2026-05-07T13:13:30.359060Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "input shape : (4, 32)\n",
+            "logits shape: (4, 32, 59)\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Sanity check: compile the forward pass and feed a real batch.\n",
+        "f_forward = pytensor.function([X_sym], logits)\n",
+        "x_batch, _ = get_batch(rng_np, batch_size=4, block_size=cfg.block_size)\n",
+        "out = f_forward(x_batch)\n",
+        "print(\"input shape :\", x_batch.shape)\n",
+        "print(\"logits shape:\", out.shape)\n",
+        "assert out.shape == (4, cfg.block_size, cfg.vocab_size)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Loss and gradients\n",
+        "\n",
+        "We use cross-entropy averaged over `(B, T)`, computed with `pt.special.log_softmax` for numerical stability and advanced indexing to gather the log-prob assigned to the true target at every position.\n",
+        "\n",
+        "Because the forward graph contains xtensor ops (inside attention) and `pytensor.grad` runs *before* compile-time lowering, we explicitly lower the xtensor sub-graph first with `rewrite_graph(..., include=(\"lower_xtensor\",))`. From there one line of PyTensor gives us the gradients of the loss with respect to **every** parameter — as a *new symbolic graph*."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:30.361026Z",
+          "iopub.status.busy": "2026-05-07T13:13:30.360867Z",
+          "iopub.status.idle": "2026-05-07T13:13:30.435791Z",
+          "shell.execute_reply": "2026-05-07T13:13:30.435284Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Loss is a Scalar(float64, shape=())\n",
+            "pytensor.grad returned 20 gradient graphs (one per shared variable).\n"
+          ]
+        }
+      ],
+      "source": [
+        "from pytensor.graph.rewriting.utils import rewrite_graph\n",
+        "\n",
+        "Y_sym = pt.tensor(\"Y\", shape=(None, cfg.block_size), dtype=\"int64\")\n",
+        "\n",
+        "log_probs = pt.special.log_softmax(logits, axis=-1)            # (B, T, V)\n",
+        "B_sym = X_sym.shape[0]\n",
+        "T_sym = X_sym.shape[1]\n",
+        "batch_idx = pt.arange(B_sym)[:, None]                           # (B, 1)\n",
+        "time_idx = pt.arange(T_sym)[None, :]                            # (1, T)\n",
+        "nll = -log_probs[batch_idx, time_idx, Y_sym]                    # (B, T)\n",
+        "loss = nll.mean()\n",
+        "\n",
+        "# Lower xtensor ops to plain tensor ops so `pytensor.grad` can pull back through them.\n",
+        "loss = rewrite_graph(loss, include=(\"lower_xtensor\",))\n",
+        "\n",
+        "flat_params = list(params.values())\n",
+        "grads = pytensor.grad(loss, flat_params)\n",
+        "print(f\"Loss is a {loss.type}\")\n",
+        "print(f\"pytensor.grad returned {len(grads)} gradient graphs (one per shared variable).\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Adam optimizer\n",
+        "\n",
+        "The optimizer is just a function that returns a list of `(shared_var, new_value)` updates. PyTensor weaves those updates into the same compiled function as the forward and backward pass, so there is no Python overhead per step — the entire forward/backward/update is one C/Numba call."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:30.437214Z",
+          "iopub.status.busy": "2026-05-07T13:13:30.437105Z",
+          "iopub.status.idle": "2026-05-07T13:13:30.487164Z",
+          "shell.execute_reply": "2026-05-07T13:13:30.486661Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Adam adds 61 updates (20 params x 3 + 1 step counter).\n"
+          ]
+        }
+      ],
+      "source": [
+        "def adam_updates(\n",
+        "    params, grads, lr=3e-3, b1=0.9, b2=0.999, eps=1e-8\n",
+        "):\n",
+        "    t = pytensor.shared(np.array(0.0, dtype=floatX), name=\"adam_t\")\n",
+        "    t_new = t + 1\n",
+        "    updates = [(t, t_new)]\n",
+        "    for p, g in zip(params, grads):\n",
+        "        m = pytensor.shared(np.zeros_like(p.get_value()), name=p.name + \"_m\")\n",
+        "        v = pytensor.shared(np.zeros_like(p.get_value()), name=p.name + \"_v\")\n",
+        "        m_new = b1 * m + (1 - b1) * g\n",
+        "        v_new = b2 * v + (1 - b2) * pt.square(g)\n",
+        "        m_hat = m_new / (1 - b1 ** t_new)\n",
+        "        v_hat = v_new / (1 - b2 ** t_new)\n",
+        "        p_new = p - lr * m_hat / (pt.sqrt(v_hat) + eps)\n",
+        "        updates += [(m, m_new), (v, v_new), (p, p_new)]\n",
+        "    return updates\n",
+        "\n",
+        "updates = adam_updates(flat_params, grads, lr=3e-3)\n",
+        "print(f\"Adam adds {len(updates)} updates ({len(flat_params)} params x 3 + 1 step counter).\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Compile the train step and train\n",
+        "\n",
+        "The first call to `pytensor.function` takes a few seconds while PyTensor optimises and compiles the graph. Each subsequent call is a pure C / Numba invocation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:30.488447Z",
+          "iopub.status.busy": "2026-05-07T13:13:30.488361Z",
+          "iopub.status.idle": "2026-05-07T13:13:44.104011Z",
+          "shell.execute_reply": "2026-05-07T13:13:44.103622Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Compilation took 3.5s\n",
+            "Initial loss = 4.078  (random baseline = 4.078)\n"
+          ]
+        }
+      ],
+      "source": [
+        "t0 = time.time()\n",
+        "train_step = pytensor.function([X_sym, Y_sym], loss, updates=updates)\n",
+        "print(f\"Compilation took {time.time() - t0:.1f}s\")\n",
+        "\n",
+        "# Initial loss should be near ln(vocab_size) for a randomly initialised model.\n",
+        "x_init, y_init = get_batch(rng_np, batch_size=4, block_size=cfg.block_size)\n",
+        "initial_loss = float(train_step(x_init, y_init))\n",
+        "print(f\"Initial loss = {initial_loss:.3f}  (random baseline = {np.log(vocab_size):.3f})\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:13:44.105474Z",
+          "iopub.status.busy": "2026-05-07T13:13:44.105383Z",
+          "iopub.status.idle": "2026-05-07T13:14:19.641951Z",
+          "shell.execute_reply": "2026-05-07T13:14:19.641513Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "step    0  recent-mean loss = 3.886\n",
+            "step  100  recent-mean loss = 2.835\n",
+            "step  200  recent-mean loss = 2.398\n",
+            "step  300  recent-mean loss = 2.234\n",
+            "step  400  recent-mean loss = 2.129\n",
+            "step  500  recent-mean loss = 2.050\n",
+            "step  600  recent-mean loss = 1.984\n",
+            "step  700  recent-mean loss = 1.930\n",
+            "step  800  recent-mean loss = 1.884\n",
+            "step  900  recent-mean loss = 1.833\n",
+            "step 1000  recent-mean loss = 1.793\n",
+            "step 1100  recent-mean loss = 1.770\n",
+            "step 1200  recent-mean loss = 1.728\n",
+            "step 1300  recent-mean loss = 1.705\n",
+            "step 1400  recent-mean loss = 1.674\n",
+            "step 1499  recent-mean loss = 1.650\n",
+            "\n",
+            "Total training time: 32.3s\n"
+          ]
+        }
+      ],
+      "source": [
+        "BATCH_SIZE = 32\n",
+        "N_STEPS = 1500\n",
+        "LOG_EVERY = 100\n",
+        "\n",
+        "losses = []\n",
+        "t0 = time.time()\n",
+        "for step in range(N_STEPS):\n",
+        "    x_b, y_b = get_batch(rng_np, BATCH_SIZE, cfg.block_size)\n",
+        "    losses.append(float(train_step(x_b, y_b)))\n",
+        "    if step % LOG_EVERY == 0 or step == N_STEPS - 1:\n",
+        "        recent = np.mean(losses[-LOG_EVERY:])\n",
+        "        print(f\"step {step:>4d}  recent-mean loss = {recent:.3f}\")\n",
+        "print(f\"\\nTotal training time: {time.time() - t0:.1f}s\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:14:19.643434Z",
+          "iopub.status.busy": "2026-05-07T13:14:19.643321Z",
+          "iopub.status.idle": "2026-05-07T13:14:19.739221Z",
+          "shell.execute_reply": "2026-05-07T13:14:19.738756Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 800x400 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "image/png": {
+              "height": 391,
+              "width": 689
+            }
+          },
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "fig, ax = plt.subplots(figsize=(8, 4))\n",
+        "ax.plot(losses, lw=0.6, alpha=0.5, label=\"raw\")\n",
+        "win = 50\n",
+        "ax.plot(\n",
+        "    np.arange(len(losses) - win + 1),\n",
+        "    np.convolve(losses, np.ones(win) / win, mode=\"valid\"),\n",
+        "    lw=2, label=f\"{win}-step rolling mean\",\n",
+        ")\n",
+        "ax.axhline(np.log(vocab_size), color=\"grey\", ls=\"--\", label=\"random baseline\")\n",
+        "ax.set_xlabel(\"training step\")\n",
+        "ax.set_ylabel(\"cross-entropy loss\")\n",
+        "ax.legend()\n",
+        "ax.set_title(\"Training curve\");"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Sampling — the autoregressive loop lives inside `pytensor.scan`\n",
+        "\n",
+        "For inference we feed the model a context window and sample the next character from the predicted distribution over the vocabulary. PyTensor lets us push the entire autoregressive loop **into the compiled graph** with `pytensor.scan`: every forward pass, every categorical draw, all the context-window bookkeeping becomes a single C/Numba call. We use `ptx.random.shared_rng` so the RNG state advances **inside** the compiled function — each call returns an independent draw. This pattern matches the one in the [scan tutorial](../scan/scan_tutorial.ipynb).\n",
+        "\n",
+        "We keep the context window and the categorical sampling as **xtensor** ops: that way the sliding window is a named-dim `concat` rather than positional `pt.concatenate`, and `categorical` consumes a `probs` xtensor with a `vocab` core dim. `pytensor.scan` itself only carries plain tensor variables across iterations, so we cross the xtensor↔tensor boundary in four places: convert to tensor before passing into the scan, back to xtensor at the top of the body, back to tensor before returning, and back to xtensor as soon as we get the scan outputs out.\n",
+        "\n",
+        "We also turn this into a **while-scan**: `pytensor.scan` accepts a `(outputs, until(cond))` return from the body and stops as soon as `cond` becomes true. Here we stop on the first newline — Tiny Shakespeare uses `\\n` as a hard break between speakers — capped by `n_new_sym` as a safety net."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:14:19.741016Z",
+          "iopub.status.busy": "2026-05-07T13:14:19.740900Z",
+          "iopub.status.idle": "2026-05-07T13:14:22.515333Z",
+          "shell.execute_reply": "2026-05-07T13:14:22.514743Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "ROMEO:\n",
+            "He have shut thing disp: eat fitorer, which bee spose!\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "from pytensor.scan import until\n",
+        "\n",
+        "EOS_ID = stoi[\"\\n\"]\n",
+        "rng_sym = ptx.random.shared_rng(seed=2026, name=\"rng_sample\")\n",
+        "\n",
+        "\n",
+        "def gen_step(context_t, rng):\n",
+        "    \"\"\"One generation step inside the scan loop.\n",
+        "\n",
+        "    `context_t` arrives as a length-`block_size` int64 *tensor* — scan only\n",
+        "    carries tensor variables across iterations — and we immediately wrap it\n",
+        "    as an xtensor with a `time` dim. The forward pass is tensor-native, so\n",
+        "    we dip back to tensor land for that single call, then go back to\n",
+        "    xtensor for the sample + window slide.\n",
+        "    \"\"\"\n",
+        "    context = ptx.as_xtensor(context_t, dims=(\"time\",))\n",
+        "    assert context.dims == (\"time\",)\n",
+        "\n",
+        "    logits_step = ptx.as_xtensor(\n",
+        "        forward(context_t[None, :], params, cfg)[0, -1], dims=(\"vocab\",)\n",
+        "    )\n",
+        "    probs_step = ptx.math.softmax(logits_step, dim=\"vocab\")\n",
+        "    next_rng, next_tok = rng.categorical(probs_step, core_dims=\"vocab\")\n",
+        "    assert next_tok.dims == ()\n",
+        "\n",
+        "    new_context = ptx.concat(\n",
+        "        [context.isel(time=slice(1, None)), next_tok.expand_dims(\"time\")],\n",
+        "        dim=\"time\",\n",
+        "    )\n",
+        "    assert new_context.dims == (\"time\",)\n",
+        "\n",
+        "    return (\n",
+        "        [new_context.values, next_tok.values, next_rng],\n",
+        "        until(pt.eq(next_tok.values, EOS_ID)),\n",
+        "    )\n",
+        "\n",
+        "\n",
+        "init_ctx_x = ptx.xtensor(\n",
+        "    \"init_ctx\", dims=(\"time\",), shape=(cfg.block_size,), dtype=\"int64\"\n",
+        ")\n",
+        "n_new_sym = pt.iscalar(\"n_new\")\n",
+        "\n",
+        "ctx_seq_t, tok_seq_t, rng_final = pytensor.scan(\n",
+        "    fn=gen_step,\n",
+        "    outputs_info=[init_ctx_x.values, None, rng_sym],\n",
+        "    n_steps=n_new_sym,\n",
+        "    return_updates=False,\n",
+        ")\n",
+        "tok_seq = ptx.as_xtensor(tok_seq_t, dims=(\"step\",))\n",
+        "assert tok_seq.dims == (\"step\",)\n",
+        "\n",
+        "generate_fn = pytensor.function(\n",
+        "    [init_ctx_x, n_new_sym],\n",
+        "    tok_seq.values,\n",
+        "    updates={rng_sym: rng_final},\n",
+        ")\n",
+        "\n",
+        "\n",
+        "def generate(prompt: str, n_new_tokens: int = 400) -> str:\n",
+        "    \"\"\"Run autoregressive generation. The Python wrapper only handles text ↔ ids;\n",
+        "    every forward pass and every sample lives inside the compiled scan, which\n",
+        "    stops early at the first newline or after ``n_new_tokens`` steps.\n",
+        "    \"\"\"\n",
+        "    ids = list(encode(prompt)) or [EOS_ID]\n",
+        "    init_ctx = np.full(cfg.block_size, EOS_ID, dtype=\"int64\")\n",
+        "    init_ctx[-len(ids):] = ids[-cfg.block_size:]\n",
+        "    sampled = generate_fn(init_ctx, n_new_tokens)\n",
+        "    return prompt + decode(sampled)\n",
+        "\n",
+        "\n",
+        "print(generate(\"ROMEO:\\n\", n_new_tokens=400))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Scaling up: a deeper model on more data\n",
+        "\n",
+        "The sections above used a 50 K-character slice and a small 2-layer model. Now we double both and train a 4-layer transformer on a 100 K-character slice (and double `block_size`), still on the default Numba backend. We then compare the two models head-to-head on a held-out slice of Shakespeare that neither has seen — the training losses on their own are not directly comparable because the corpora, vocabularies, and context windows differ.\n",
+        "\n",
+        "## Re-tokenize a 100 K-character slice and rebuild the model\n",
+        "\n",
+        "We use a fresh `Config` and a freshly initialised parameter dict so this section is independent of everything above."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "corpus slice: 100,000 chars, vocab: 61\n",
+            "cfg_full    : Config(vocab_size=61, block_size=64, n_embd=64, n_head=4, n_layer=4)\n",
+            "params      : 205,760\n"
+          ]
+        }
+      ],
+      "source": [
+        "text_full = full_text[:100_000]\n",
+        "chars_full = sorted(set(text_full))\n",
+        "vocab_size_full = len(chars_full)\n",
+        "stoi_full = {c: i for i, c in enumerate(chars_full)}\n",
+        "itos_full = {i: c for i, c in enumerate(chars_full)}\n",
+        "data_full = np.array([stoi_full[c] for c in text_full], dtype=\"int64\")\n",
+        "\n",
+        "cfg_full = Config(\n",
+        "    vocab_size=vocab_size_full,\n",
+        "    block_size=64,\n",
+        "    n_embd=64,\n",
+        "    n_head=4,\n",
+        "    n_layer=4,\n",
+        ")\n",
+        "print(f\"corpus slice: {len(data_full):,} chars, vocab: {vocab_size_full}\")\n",
+        "print(f\"cfg_full    : {cfg_full}\")\n",
+        "\n",
+        "init_arrays_full = init_params(cfg_full, np.random.default_rng(7))\n",
+        "print(f\"params      : {sum(a.size for a in init_arrays_full.values()):,}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Compile a fresh `train_step` and train\n",
+        "\n",
+        "We wrap the now-familiar pattern — fresh `shared` params, symbolic loss, lower the xtensor sub-graph, `pytensor.grad`, Adam updates, compile — into a small helper so this section reads top-to-bottom."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def build_train_step(cfg, init_arrays, *, lr=3e-3):\n",
+        "    p = {n: pytensor.shared(arr.copy(), name=n) for n, arr in init_arrays.items()}\n",
+        "    X = pt.tensor(\"X\", shape=(None, cfg.block_size), dtype=\"int64\")\n",
+        "    Y = pt.tensor(\"Y\", shape=(None, cfg.block_size), dtype=\"int64\")\n",
+        "    logits = forward(X, p, cfg)\n",
+        "    log_probs = pt.special.log_softmax(logits, axis=-1)\n",
+        "    bidx = pt.arange(X.shape[0])[:, None]\n",
+        "    tidx = pt.arange(X.shape[1])[None, :]\n",
+        "    loss = (-log_probs[bidx, tidx, Y]).mean()\n",
+        "    # Lower xtensor ops before grad (see the smaller-model section above).\n",
+        "    loss = rewrite_graph(loss, include=(\"lower_xtensor\",))\n",
+        "    grads = pytensor.grad(loss, list(p.values()))\n",
+        "    upd = adam_updates(list(p.values()), grads, lr=lr)\n",
+        "    t0 = time.time()\n",
+        "    fn = pytensor.function([X, Y], loss, updates=upd)\n",
+        "    return fn, p, time.time() - t0"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Compilation took 10.3s\n"
+          ]
+        }
+      ],
+      "source": [
+        "BATCH_FULL = 32\n",
+        "N_STEPS_FULL = 1500\n",
+        "\n",
+        "train_step_full, params_full, ct_numba = build_train_step(cfg_full, init_arrays_full)\n",
+        "print(f\"Compilation took {ct_numba:.1f}s\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "step    0  recent-mean loss = 4.141\n",
+            "step  100  recent-mean loss = 2.934\n",
+            "step  200  recent-mean loss = 2.462\n",
+            "step  300  recent-mean loss = 2.297\n",
+            "step  400  recent-mean loss = 2.163\n",
+            "step  500  recent-mean loss = 2.051\n",
+            "step  600  recent-mean loss = 1.962\n",
+            "step  700  recent-mean loss = 1.884\n",
+            "step  800  recent-mean loss = 1.822\n",
+            "step  900  recent-mean loss = 1.763\n",
+            "step 1000  recent-mean loss = 1.722\n",
+            "step 1100  recent-mean loss = 1.688\n",
+            "step 1200  recent-mean loss = 1.658\n",
+            "step 1300  recent-mean loss = 1.628\n",
+            "step 1400  recent-mean loss = 1.598\n",
+            "step 1499  recent-mean loss = 1.569\n",
+            "\n",
+            "Total training time: 185.1s\n"
+          ]
+        }
+      ],
+      "source": [
+        "rng_full = np.random.default_rng(123)\n",
+        "losses_full: list[float] = []\n",
+        "t0 = time.time()\n",
+        "for step in range(N_STEPS_FULL):\n",
+        "    starts = rng_full.integers(0, len(data_full) - cfg_full.block_size - 1, size=BATCH_FULL)\n",
+        "    xb = np.stack([data_full[s : s + cfg_full.block_size] for s in starts])\n",
+        "    yb = np.stack([data_full[s + 1 : s + 1 + cfg_full.block_size] for s in starts])\n",
+        "    losses_full.append(float(train_step_full(xb, yb)))\n",
+        "    if step % 100 == 0 or step == N_STEPS_FULL - 1:\n",
+        "        print(f\"step {step:>4d}  recent-mean loss = {np.mean(losses_full[-100:]):.3f}\")\n",
+        "print(f\"\\nTotal training time: {time.time() - t0:.1f}s\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 900x400 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "image/png": {
+              "height": 391,
+              "width": 766
+            }
+          },
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "fig, ax = plt.subplots(figsize=(9, 4))\n",
+        "ax.plot(losses_full, alpha=0.4, label=\"raw\")\n",
+        "rolling = np.convolve(losses_full, np.ones(50) / 50, mode=\"valid\")\n",
+        "ax.plot(np.arange(len(rolling)) + 49, rolling, lw=2, label=\"50-step rolling mean\")\n",
+        "ax.axhline(np.log(cfg_full.vocab_size), ls=\"--\", color=\"gray\", label=\"random baseline\")\n",
+        "ax.set_xlabel(\"training step\")\n",
+        "ax.set_ylabel(\"cross-entropy loss\")\n",
+        "ax.set_title(\"Training curve — deeper model on 100 K characters\")\n",
+        "ax.legend()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## A fair side-by-side: held-out perplexity\n",
+        "\n",
+        "The two training losses (≈ 1.65 vs ≈ 1.57) aren't directly comparable. The models saw different corpus slices (50 K vs 100 K characters), have different vocabularies (59 vs 61), and — most importantly — a different `block_size` (32 vs 64). Doubling the context window alone tends to drive per-token cross-entropy down, even at equal model quality.\n",
+        "\n",
+        "To get an honest comparison we evaluate both models on the same 10 K-character slice that **neither** of them saw during training (`full_text[100_000:110_000]`). For the small model we simply skip the handful of characters that aren't in its vocabulary."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "held-out CE  (small, 2-layer, block 32): 1.841  ppl = 6.31\n",
+            "held-out CE  (large, 4-layer, block 64): 1.738  ppl = 5.69\n"
+          ]
+        }
+      ],
+      "source": [
+        "def build_eval_fn(cfg, params_dict):\n",
+        "    \"\"\"Compile a forward + cross-entropy function that reads from the shared params.\"\"\"\n",
+        "    X = pt.tensor(\"X_eval\", shape=(None, cfg.block_size), dtype=\"int64\")\n",
+        "    Y = pt.tensor(\"Y_eval\", shape=(None, cfg.block_size), dtype=\"int64\")\n",
+        "    log_probs = pt.special.log_softmax(forward(X, params_dict, cfg), axis=-1)\n",
+        "    bidx = pt.arange(X.shape[0])[:, None]\n",
+        "    tidx = pt.arange(X.shape[1])[None, :]\n",
+        "    loss = (-log_probs[bidx, tidx, Y]).mean()\n",
+        "    loss = rewrite_graph(loss, include=(\"lower_xtensor\",))\n",
+        "    return pytensor.function([X, Y], loss)\n",
+        "\n",
+        "\n",
+        "def held_out_loss(eval_fn, cfg, stoi_local, holdout_text):\n",
+        "    \"\"\"Mean per-token cross-entropy over non-overlapping windows of `holdout_text`.\n",
+        "    Characters absent from `stoi_local` are skipped (vocabularies can differ slightly).\"\"\"\n",
+        "    ids = np.array([stoi_local[c] for c in holdout_text if c in stoi_local], dtype=\"int64\")\n",
+        "    starts = np.arange(0, len(ids) - cfg.block_size - 1, cfg.block_size)\n",
+        "    total, n = 0.0, 0\n",
+        "    for i in range(0, len(starts), 64):\n",
+        "        batch = starts[i : i + 64]\n",
+        "        xb = np.stack([ids[s : s + cfg.block_size] for s in batch])\n",
+        "        yb = np.stack([ids[s + 1 : s + 1 + cfg.block_size] for s in batch])\n",
+        "        total += float(eval_fn(xb, yb)) * len(batch)\n",
+        "        n += len(batch)\n",
+        "    return total / n\n",
+        "\n",
+        "\n",
+        "holdout_text = full_text[100_000:110_000]\n",
+        "L_small = held_out_loss(build_eval_fn(cfg, params),           cfg,      stoi,      holdout_text)\n",
+        "L_full  = held_out_loss(build_eval_fn(cfg_full, params_full), cfg_full, stoi_full, holdout_text)\n",
+        "\n",
+        "print(f\"held-out CE  (small, 2-layer, block 32): {L_small:.3f}  ppl = {np.exp(L_small):.2f}\")\n",
+        "print(f\"held-out CE  (large, 4-layer, block 64): {L_full :.3f}  ppl = {np.exp(L_full ):.2f}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## A sample from the deeper model\n",
+        "\n",
+        "On held-out text the deeper model is genuinely better — about 0.10 nats per character lower cross-entropy, or **~10% lower perplexity** (5.69 vs 6.31). At this scale and training budget that is *not* enough to make the samples *look* coherent: both models still produce Shakespearean gibberish at the word level. What you can see in the sample below is firmer speaker-name structure and slightly more believable rhythm. We reuse the same `pytensor.scan` generator pattern — the entire autoregressive loop still lives inside one compiled call."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "EOS_ID_FULL = stoi_full[\"\\n\"]\n",
+        "rng_full_sym = ptx.random.shared_rng(seed=2027, name=\"rng_full\")\n",
+        "\n",
+        "\n",
+        "def gen_step_full(context_t, rng):\n",
+        "    context = ptx.as_xtensor(context_t, dims=(\"time\",))\n",
+        "    logits_step = ptx.as_xtensor(\n",
+        "        forward(context_t[None, :], params_full, cfg_full)[0, -1], dims=(\"vocab\",)\n",
+        "    )\n",
+        "    probs_step = ptx.math.softmax(logits_step, dim=\"vocab\")\n",
+        "    next_rng, next_tok = rng.categorical(probs_step, core_dims=\"vocab\")\n",
+        "    new_context = ptx.concat(\n",
+        "        [context.isel(time=slice(1, None)), next_tok.expand_dims(\"time\")],\n",
+        "        dim=\"time\",\n",
+        "    )\n",
+        "    return (\n",
+        "        [new_context.values, next_tok.values, next_rng],\n",
+        "        until(pt.eq(next_tok.values, EOS_ID_FULL)),\n",
+        "    )\n",
+        "\n",
+        "\n",
+        "init_ctx_full = ptx.xtensor(\n",
+        "    \"init_ctx_full\", dims=(\"time\",), shape=(cfg_full.block_size,), dtype=\"int64\"\n",
+        ")\n",
+        "n_new_full = pt.iscalar(\"n_new_full\")\n",
+        "\n",
+        "_, tok_seq_full_t, rng_final_full = pytensor.scan(\n",
+        "    fn=gen_step_full,\n",
+        "    outputs_info=[init_ctx_full.values, None, rng_full_sym],\n",
+        "    n_steps=n_new_full,\n",
+        "    return_updates=False,\n",
+        ")\n",
+        "tok_seq_full = ptx.as_xtensor(tok_seq_full_t, dims=(\"step\",))\n",
+        "\n",
+        "generate_full_fn = pytensor.function(\n",
+        "    [init_ctx_full, n_new_full],\n",
+        "    tok_seq_full.values,\n",
+        "    updates={rng_full_sym: rng_final_full},\n",
+        ")\n",
+        "\n",
+        "\n",
+        "def generate_full(prompt: str, n_new_tokens: int = 400) -> str:\n",
+        "    ids = list(np.array([stoi_full[c] for c in prompt], dtype=\"int64\")) or [EOS_ID_FULL]\n",
+        "    init_ctx = np.full(cfg_full.block_size, EOS_ID_FULL, dtype=\"int64\")\n",
+        "    init_ctx[-len(ids):] = ids[-cfg_full.block_size:]\n",
+        "    sampled = generate_full_fn(init_ctx, n_new_tokens)\n",
+        "    return prompt + \"\".join(itos_full[int(i)] for i in sampled)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 31,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "ROMEO:\n",
+            "But be teak of the thus.\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(generate_full(\"ROMEO:\\n\", n_new_tokens=400))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Takeaways\n",
+        "\n",
+        "* A full **decoder-only transformer** — embeddings, multi-head causal attention, MLP, layernorm, tied softmax head, cross-entropy loss, and Adam — fits in roughly 100 lines of PyTensor. No custom `Op`, no backend-specific code.\n",
+        "* `pytensor.xtensor` named dimensions turned the trickiest part of the model (multi-head attention) into self-documenting code. The named-dim sub-graph is lowered to plain tensor ops at compile time — we just had to call `rewrite_graph(loss, include=(\"lower_xtensor\",))` once before `pytensor.grad` so the gradient pass walks the lowered graph.\n",
+        "* `pytensor.grad` gave us back-propagation through the entire stack as a *new symbolic graph*. We optimised that graph and compiled it into a single C/Numba `train_step`.\n",
+        "* `pytensor.shared` plus `updates=` made Adam a 15-line helper. Optimizer state lives next to the parameters in the graph, not in Python.\n",
+        "* `pytensor.scan` let us push autoregressive generation entirely inside the compiled graph — the Python wrapper only translates between text and ids; every forward pass and every categorical draw lives inside one C/Numba call.\n",
+        "\n",
+        "## Where to go from here\n",
+        "\n",
+        "* Swap `mode=\"NUMBA\"` (default) for `mode=\"JAX\"` to train on a GPU/TPU.\n",
+        "* Replace `tanh` with a real GELU and try a longer training run on the full 1.1 M-character corpus.\n",
+        "* Use `pytensor.dprint(train_step)` to inspect the optimised post-rewrite graph and see how many ops PyTensor's rewriter fused away.\n",
+        "\n",
+        "## Authors\n",
+        "\n",
+        "* Authored by the PyTensor developers in May 2026.\n",
+        "\n",
+        "## Watermark"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2026-05-07T13:16:56.512277Z",
+          "iopub.status.busy": "2026-05-07T13:16:56.512148Z",
+          "iopub.status.idle": "2026-05-07T13:16:56.518894Z",
+          "shell.execute_reply": "2026-05-07T13:16:56.518316Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Last updated: Tue, 16 Jun 2026\n",
+            "\n",
+            "Python implementation: CPython\n",
+            "Python version       : 3.14.4\n",
+            "IPython version      : 9.13.0\n",
+            "\n",
+            "pytensor: 3.0.5+30.g1bb3ee02f\n",
+            "\n",
+            "matplotlib: 3.10.9\n",
+            "numpy     : 2.4.3\n",
+            "pytensor  : 3.0.5+30.g1bb3ee02f\n",
+            "\n",
+            "Watermark: 2.6.0\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "%load_ext watermark\n",
+        "%watermark -n -u -v -iv -w -p pytensor"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        ":::{include} ../page_footer.md\n",
+        ":::\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "pytensor-dev",
+      "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.14.4"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 4
+}
diff --git a/pytensor/xtensor/__init__.py b/pytensor/xtensor/__init__.py
index 22de7642f1..c2ab4126f5 100644
--- a/pytensor/xtensor/__init__.py
+++ b/pytensor/xtensor/__init__.py
@@ -1,7 +1,14 @@
 import pytensor.xtensor.rewriting
 from pytensor.xtensor import linalg, math, random, signal
 from pytensor.xtensor.math import dot, where
-from pytensor.xtensor.shape import broadcast, concat, full_like, ones_like, zeros_like
+from pytensor.xtensor.shape import (
+    broadcast,
+    concat,
+    full_like,
+    ones_like,
+    stack,
+    zeros_like,
+)
 from pytensor.xtensor.type import (
     as_xtensor,
     xtensor,