From a6ab0d6acfedfd7523600f7df969d4e0a0018521 Mon Sep 17 00:00:00 2001
From: Carlos Trujillo <59846724+cetagostini@users.noreply.github.com>
Date: Fri, 22 May 2026 00:53:46 +0900
Subject: [PATCH 1/2] Add tiny transformer LLM notebook

Add a new gallery notebook demonstrating a tiny decoder-only transformer LLM implemented with pytensor/xtensor (doc/gallery/transformers/tiny_transformer_llm.ipynb). Update .gitignore to exclude AI tool artifacts, gallery downloaded data, and JupyterLab session files. Also apply related updates to math implementation and rewrites (pytensor/tensor/math.py, pytensor/xtensor/rewriting/math.py) and adjust tests (tests/tensor/test_math.py, tests/xtensor/test_math.py) to match the changes.
---
 .gitignore                                    |   13 +
 .../transformers/tiny_transformer_llm.ipynb   | 1246 +++++++++++++++++
 pytensor/tensor/math.py                       |   38 +-
 pytensor/xtensor/rewriting/math.py            |  195 ++-
 tests/tensor/test_math.py                     |   19 +
 tests/xtensor/test_math.py                    |   53 +
 6 files changed, 1533 insertions(+), 31 deletions(-)
 create mode 100644 doc/gallery/transformers/tiny_transformer_llm.ipynb

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..c1f116c9f2
--- /dev/null
+++ b/doc/gallery/transformers/tiny_transformer_llm.ipynb
@@ -0,0 +1,1246 @@
+{
+  "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": null,
+      "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.0+18.g62e079c0e.dirty | 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.tensor.random as ptr\n",
+        "import pytensor.xtensor as px\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": null,
+      "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": [
+            "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": null,
+      "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": null,
+      "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": null,
+      "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": 28,
+          "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": null,
+      "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": null,
+      "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": [
+        "from pytensor.xtensor.shape import stack as xstack\n",
+        "\n",
+        "\n",
+        "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'.\n",
+        "    \"\"\"\n",
+        "    D = n_head * head_dim\n",
+        "    x_x = px.as_xtensor(x, dims=(\"batch\", \"time\", \"embd\"))\n",
+        "    Wqkv = px.as_xtensor(\n",
+        "        p[\"W_qkv\"].reshape((D, 3, n_head, head_dim)),\n",
+        "        dims=(\"embd\", \"qkv\", \"head\", \"hd\"),\n",
+        "    )\n",
+        "    Wproj = px.as_xtensor(p[\"W_proj\"], dims=(\"embd\", \"embd_out\"))\n",
+        "\n",
+        "    qkv = px.dot(x_x, Wqkv, dim=\"embd\")              # (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 = px.dot(q, k, dim=\"hd\") / scale          # (batch, head, time_q, time_k)\n",
+        "\n",
+        "    mask = px.as_xtensor(\n",
+        "        pt.tril(pt.ones((block_size, block_size), dtype=\"bool\")),\n",
+        "        dims=(\"time_q\", \"time_k\"),\n",
+        "    )\n",
+        "    scores = px.where(mask, scores, np.float64(-1e9))\n",
+        "    attn = px.math.softmax(scores, dim=\"time_k\")\n",
+        "\n",
+        "    out = px.dot(attn, v, dim=\"time_k\")              # (batch, head, time_q, hd)\n",
+        "    out = xstack(out, embd=(\"head\", \"hd\"))           # merge heads back\n",
+        "    out = px.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": null,
+      "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 0x105ea54e0>"
+            ]
+          },
+          "execution_count": 31,
+          "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": null,
+      "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": null,
+      "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": null,
+      "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": null,
+      "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 2.0s\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": null,
+      "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.8s\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": null,
+      "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 `pt.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)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "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",
+            "Thaction wranter toge. A godd some; at, powarth libout quh e and such arothy to prome-cany be frie thing.\n",
+            "\n",
+            "COMINIUS:\n",
+            "Now ust, pry state more veily, the cry mam fors,\n",
+            "Our fithy done for thy baraddy at, doubt ithen\n",
+            "diesws sagch.\n",
+            "\n",
+            "MENENIUS:\n",
+            "Node most\n",
+            "Rele's buths is ather shencered honours\n",
+            "To made the neme of then you thums,\n",
+            "Them heate the me the\n"
+          ]
+        }
+      ],
+      "source": [
+        "rng_sym = ptr.shared_rng(seed=2026, name=\"rng_sample\")\n",
+        "\n",
+        "\n",
+        "def gen_step(context, rng):\n",
+        "    \"\"\"One generation step inside the scan loop.\n",
+        "\n",
+        "    `context` is a length-`block_size` int64 vector. We forward through the model, sample the\n",
+        "    next token, then shift the context window left by one and append the new token.\n",
+        "    \"\"\"\n",
+        "    logits_step = forward(context[None, :], params, cfg)[0, -1, :]   # (V,)\n",
+        "    probs_step = pt.special.softmax(logits_step)\n",
+        "    next_rng, next_tok = rng.categorical(p=probs_step)\n",
+        "    new_context = pt.concatenate([context[1:], next_tok[None]])\n",
+        "    return new_context, next_tok, next_rng\n",
+        "\n",
+        "\n",
+        "init_ctx_sym = pt.vector(\"init_ctx\", dtype=\"int64\")\n",
+        "n_new_sym = pt.iscalar(\"n_new\")\n",
+        "\n",
+        "ctx_seq, tok_seq, rng_final = pytensor.scan(\n",
+        "    fn=gen_step,\n",
+        "    outputs_info=[init_ctx_sym, None, rng_sym],\n",
+        "    n_steps=n_new_sym,\n",
+        "    return_updates=False,\n",
+        ")\n",
+        "\n",
+        "generate_fn = pytensor.function(\n",
+        "    [init_ctx_sym, n_new_sym],\n",
+        "    tok_seq,\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.\n",
+        "    \"\"\"\n",
+        "    ids = list(encode(prompt)) or [stoi[\"\\n\"]]\n",
+        "    pad_id = stoi[\"\\n\"]\n",
+        "    init_ctx = np.full(cfg.block_size, pad_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": null,
+      "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": null,
+      "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": null,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Compilation took 4.9s\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": null,
+      "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: 211.8s\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": null,
+      "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": null,
+      "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.12 nats per character lower cross-entropy, or **~11 % lower perplexity** (5.69 vs 6.39). 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": null,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "ROMEO:\n",
+            "\n",
+            "Has remie my with to by many shots is ded thet.\n",
+            "\n",
+            "VIRGILILIA:\n",
+            "Let know Come, peopl! It mile, my which has men\n",
+            "As mark'd throw abe wors way aur palwind;' lis feed to Romme to\n",
+            "Come turn as pestile; and tgide for your to to the\n",
+            "a plutten tike kitie will it. Him awill, as; wheirs be\n",
+            "Our mocke.\n",
+            "\n",
+            "VIRLERIA:\n",
+            "The't deather, lor good! till.\n",
+            "\n",
+            "VIRILess!\n",
+            "\n",
+            "CICINIUS:\n",
+            "Net trimine eneman we aske,\n",
+            "That I mile appir\n"
+          ]
+        }
+      ],
+      "source": [
+        "rng_full_sym = ptr.shared_rng(seed=2027, name=\"rng_full\")\n",
+        "\n",
+        "\n",
+        "def gen_step_full(context, rng):\n",
+        "    logits_step = forward(context[None, :], params_full, cfg_full)[0, -1, :]\n",
+        "    probs_step = pt.special.softmax(logits_step)\n",
+        "    next_rng, next_tok = rng.categorical(p=probs_step)\n",
+        "    new_context = pt.concatenate([context[1:], next_tok[None]])\n",
+        "    return new_context, next_tok, next_rng\n",
+        "\n",
+        "\n",
+        "init_ctx_full = pt.vector(\"init_ctx_full\", dtype=\"int64\")\n",
+        "n_new_full = pt.iscalar(\"n_new_full\")\n",
+        "\n",
+        "_, tok_seq_full, rng_final_full = pytensor.scan(\n",
+        "    fn=gen_step_full,\n",
+        "    outputs_info=[init_ctx_full, None, rng_full_sym],\n",
+        "    n_steps=n_new_full,\n",
+        "    return_updates=False,\n",
+        ")\n",
+        "\n",
+        "generate_full_fn = pytensor.function(\n",
+        "    [init_ctx_full, n_new_full],\n",
+        "    tok_seq_full,\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 [stoi_full[\"\\n\"]]\n",
+        "    pad_id = stoi_full[\"\\n\"]\n",
+        "    init_ctx = np.full(cfg_full.block_size, pad_id, 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)\n",
+        "\n",
+        "\n",
+        "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": null,
+      "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": [
+            "The watermark extension is already loaded. To reload it, use:\n",
+            "  %reload_ext watermark\n",
+            "Last updated: Fri, 22 May 2026\n",
+            "\n",
+            "Python implementation: CPython\n",
+            "Python version       : 3.14.4\n",
+            "IPython version      : 9.13.0\n",
+            "\n",
+            "pytensor: 3.0.0+18.g62e079c0e.dirty\n",
+            "\n",
+            "matplotlib: 3.10.9\n",
+            "numpy     : 2.4.3\n",
+            "pytensor  : 3.0.0+18.g62e079c0e.dirty\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": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3",
+      "path": "/Users/carlostrujillo/Library/Python/3.9/share/jupyter/kernels/python3"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 4
+}
diff --git a/pytensor/tensor/math.py b/pytensor/tensor/math.py
index 139d22529d..ebbaf43ddb 100644
--- a/pytensor/tensor/math.py
+++ b/pytensor/tensor/math.py
@@ -38,7 +38,7 @@
     get_normalized_batch_axes,
     scalar_elemwise,
 )
-from pytensor.tensor.shape import shape, specify_shape
+from pytensor.tensor.shape import shape, shape_tuple, specify_shape
 from pytensor.tensor.type import (
     DenseTensorType,
     complex_dtypes,
@@ -3358,9 +3358,31 @@ def tensordot(
 
     # Convert tensordot into a stacked dot product.
     # We stack the summed axes and the non-summed axes of each tensor separately,
-    # and place the summed axes at the end of a and the beginning of b
+    # and place the summed axes at the end of a and the beginning of b.
+    # We use `shape_tuple` so static dims come back as `ScalarConstant`s and
+    # multiply known dims together in Python (see `_axes_product`) so that the
+    # reshape shape vector is a plain int constant when all participating dims
+    # are static, instead of a chain of Mul nodes over runtime Shape lookups.
+    shape_a = shape_tuple(a)
+    shape_b = shape_tuple(b)
+
+    def _axes_product(static_shape, sym_shape, axes):
+        static_product = 1
+        runtime_terms = []
+        for axis in axes:
+            s = static_shape[axis]
+            if s is None:
+                runtime_terms.append(sym_shape[axis])
+            else:
+                static_product *= s
+        if not runtime_terms:
+            return constant(static_product, dtype="int64")
+        if static_product == 1:
+            return variadic_mul(*runtime_terms)
+        return variadic_mul(constant(static_product, dtype="int64"), *runtime_terms)
+
     non_summed_axes_a = [k for k in range(ndim_a) if k not in axes_a]
-    non_summed_dims_a = [runtime_shape_a[axis] for axis in non_summed_axes_a]
+    non_summed_dims_a = [shape_a[axis] for axis in non_summed_axes_a]
     transpose_axes_a = non_summed_axes_a + axes_a
     # We only need a reshape when we need to combine summed or non-summed dims
     # or introduce a new dimension (expand_dims) when doing a non-scalar outer product (len(axes) = 0)
@@ -3369,7 +3391,7 @@ def tensordot(
     )
 
     non_summed_axes_b = [k for k in range(ndim_b) if k not in axes_b]
-    non_summed_dims_b = [runtime_shape_b[axis] for axis in non_summed_axes_b]
+    non_summed_dims_b = [shape_b[axis] for axis in non_summed_axes_b]
     transpose_axes_b = axes_b + non_summed_axes_b
     b_needs_reshape = (ndim_b != 0) and (
         (len(non_summed_axes_b) > 1) or (len(axes_b) != 1)
@@ -3379,14 +3401,14 @@ def tensordot(
     # but to facilitate reasoning about useless reshapes we compute both from their shapes
     at = a.transpose(transpose_axes_a)
     if a_needs_reshape:
-        non_summed_size_a = variadic_mul(*non_summed_dims_a)
-        summed_size_a = variadic_mul(*[runtime_shape_a[axis] for axis in axes_a])
+        non_summed_size_a = _axes_product(static_shape_a, shape_a, non_summed_axes_a)
+        summed_size_a = _axes_product(static_shape_a, shape_a, axes_a)
         at = at.reshape((non_summed_size_a, summed_size_a))
 
     bt = b.transpose(transpose_axes_b)
     if b_needs_reshape:
-        non_summed_size_b = variadic_mul(*non_summed_dims_b)
-        summed_size_b = variadic_mul(*[runtime_shape_b[axis] for axis in axes_b])
+        non_summed_size_b = _axes_product(static_shape_b, shape_b, non_summed_axes_b)
+        summed_size_b = _axes_product(static_shape_b, shape_b, axes_b)
         bt = bt.reshape((summed_size_b, non_summed_size_b))
 
     res = dot(at, bt)
diff --git a/pytensor/xtensor/rewriting/math.py b/pytensor/xtensor/rewriting/math.py
index c767ec490e..13483f0c18 100644
--- a/pytensor/xtensor/rewriting/math.py
+++ b/pytensor/xtensor/rewriting/math.py
@@ -2,46 +2,195 @@
 
 from pytensor.graph import node_rewriter
 from pytensor.tensor import einsum
-from pytensor.tensor.shape import specify_shape
+from pytensor.tensor.basic import constant
+from pytensor.tensor.basic import stack as tstack
+from pytensor.tensor.einsum import Einsum
+from pytensor.tensor.math import matmul, variadic_mul
+from pytensor.tensor.rewriting.ofg import inline_ofg_node
+from pytensor.tensor.shape import shape_tuple, specify_shape
 from pytensor.xtensor.basic import tensor_from_xtensor, xtensor_from_tensor
 from pytensor.xtensor.math import Dot
 from pytensor.xtensor.rewriting.utils import register_lower_xtensor
 
 
+def _combined_size(tensor, axes):
+    """Return the product of ``tensor``'s sizes at ``axes`` as a scalar variable.
+
+    Static dims are multiplied together in Python so the result is a single
+    constant when possible, instead of a chain of ``Mul`` nodes over individual
+    ``ScalarConstant``s.
+    """
+    sizes = shape_tuple(tensor)
+    static_product = 1
+    runtime_terms = []
+    for axis in axes:
+        s = tensor.type.shape[axis]
+        if s is None:
+            runtime_terms.append(sizes[axis])
+        else:
+            static_product *= s
+    if not runtime_terms:
+        return constant(static_product, dtype="int64")
+    if static_product == 1:
+        return variadic_mul(*runtime_terms)
+    return variadic_mul(constant(static_product, dtype="int64"), *runtime_terms)
+
+
+def _matmul_lower(x, y, x_dims, y_dims, contracted, out_dims):
+    """Lower a 2-operand xtensor.dot to a single ``matmul`` when possible.
+
+    Returns ``None`` for pure outer products (no shared contracted dim), in
+    which case the caller should fall back to ``einsum``.
+
+    Shared dims become matmul batch axes; multi-dim M / K / N groups are
+    collapsed via ``reshape`` and uncollapsed after the matmul.
+    """
+    x_dims = list(x_dims)
+    y_dims = list(y_dims)
+    contracted = list(contracted)
+
+    # Dims listed as contracted but present in only one operand are pure
+    # reductions (xarray semantics): sum them out before the matmul.
+    x_only_contracted = [d for d in contracted if d in x_dims and d not in y_dims]
+    y_only_contracted = [d for d in contracted if d in y_dims and d not in x_dims]
+    if x_only_contracted:
+        x = x.sum([x_dims.index(d) for d in x_only_contracted])
+        for d in x_only_contracted:
+            x_dims.remove(d)
+    if y_only_contracted:
+        y = y.sum([y_dims.index(d) for d in y_only_contracted])
+        for d in y_only_contracted:
+            y_dims.remove(d)
+
+    k_dims = [d for d in contracted if d in x_dims and d in y_dims]
+    if not k_dims:
+        # No shared contracted dim -> outer product; not matmul-shaped.
+        return None
+
+    shared = [d for d in x_dims if d in y_dims and d not in k_dims]
+    x_only = [d for d in x_dims if d not in y_dims and d not in k_dims]
+    y_only = [d for d in y_dims if d not in x_dims and d not in k_dims]
+
+    # Cache original per-dim sizes (static if possible) so we can uncollapse
+    # M / N groups after matmul.
+    dim_sizes: dict[str, object] = {}
+    x_shape = shape_tuple(x)
+    y_shape = shape_tuple(y)
+    for axis, d in enumerate(x_dims):
+        dim_sizes[d] = x_shape[axis]
+    for axis, d in enumerate(y_dims):
+        dim_sizes.setdefault(d, y_shape[axis])
+
+    # Permute to (shared..., x_only..., k...) and (shared..., k..., y_only...).
+    x_perm = [x_dims.index(d) for d in shared + x_only + k_dims]
+    if x_perm != list(range(len(x_dims))):
+        x = x.transpose(x_perm)
+    y_perm = [y_dims.index(d) for d in shared + k_dims + y_only]
+    if y_perm != list(range(len(y_dims))):
+        y = y.transpose(y_perm)
+
+    n_shared = len(shared)
+    n_k = len(k_dims)
+
+    # Collapse multi-dim outer / contracted groups so the trailing two axes
+    # are exactly the (M, K) / (K, N) matmul axes. Empty outer groups get a
+    # dummy length-1 axis (squeezed back out below). ``k_dims`` is always
+    # non-empty here.
+    def _collapse(tensor, outer_axes, k_axes, is_lhs):
+        n_outer = len(outer_axes)
+        if n_outer == 1 and n_k == 1:
+            # Already in the right layout: just a single M (or N) and a single K.
+            return tensor
+
+        new_shape = list(shape_tuple(tensor)[:n_shared])
+        if n_outer == 0:
+            outer_size = constant(1, dtype="int64")
+        else:
+            outer_size = _combined_size(tensor, outer_axes)
+        k_size = _combined_size(tensor, k_axes)
+
+        if is_lhs:
+            new_shape += [outer_size, k_size]
+        else:
+            new_shape += [k_size, outer_size]
+        return tensor.reshape(tstack(new_shape))
+
+    # After the transposes above, x's outer axes are [n_shared, n_shared+len(x_only))
+    # and its k axes are [n_shared+len(x_only), n_shared+len(x_only)+n_k). For y,
+    # k axes are [n_shared, n_shared+n_k) and outer axes are [n_shared+n_k, ...).
+    x_outer_axes = range(n_shared, n_shared + len(x_only))
+    x_k_axes = range(n_shared + len(x_only), n_shared + len(x_only) + n_k)
+    y_k_axes = range(n_shared, n_shared + n_k)
+    y_outer_axes = range(n_shared + n_k, n_shared + n_k + len(y_only))
+
+    x = _collapse(x, x_outer_axes, x_k_axes, is_lhs=True)
+    y = _collapse(y, y_outer_axes, y_k_axes, is_lhs=False)
+
+    res = matmul(x, y)
+
+    # If x_only / y_only were empty, M / N is a dummy length-1 axis: squeeze it.
+    squeeze_axes: list[int] = []
+    if not y_only:
+        squeeze_axes.append(res.type.ndim - 1)
+    if not x_only:
+        squeeze_axes.append(res.type.ndim - 2)
+    if squeeze_axes:
+        res = res.squeeze(tuple(squeeze_axes))
+
+    # Uncollapse multi-dim M / N groups back to their original axes.
+    if len(x_only) > 1 or len(y_only) > 1:
+        new_shape = list(shape_tuple(res)[:n_shared])
+        new_shape.extend(dim_sizes[d] for d in x_only)
+        new_shape.extend(dim_sizes[d] for d in y_only)
+        res = res.reshape(tstack(new_shape))
+
+    current_dims = shared + x_only + y_only
+    if current_dims != list(out_dims):
+        res = res.transpose([current_dims.index(d) for d in out_dims])
+
+    return res
+
+
 @register_lower_xtensor
 @node_rewriter(tracks=[Dot])
 def lower_dot(fgraph, node):
-    """Rewrite XDot to tensor.dot.
+    """Lower an xtensor ``Dot`` to plain tensor ops.
 
-    This rewrite converts an XDot operation to a tensor-based dot operation,
-    handling dimension alignment and contraction.
+    Matmul-shaped contractions (anything with at least one shared contracted
+    dim) lower to a single ``matmul`` (``Blockwise(Dot)``), with reshape only
+    where multiple M / K / N dims must be collapsed and uncollapsed. Pure
+    outer products fall back to ``einsum`` and inline the resulting
+    ``OpFromGraph`` so ``pytensor.grad`` sees flat ops.
     """
     [x, y] = node.inputs
     [out] = node.outputs
 
-    # Convert inputs to tensors
     x_tensor = tensor_from_xtensor(x)
     y_tensor = tensor_from_xtensor(y)
 
-    # Collect all dimension names across inputs and output
-    all_dims = list(
-        dict.fromkeys(x.type.dims + y.type.dims + out.type.dims)
-    )  # preserve order
-    if len(all_dims) > len(ascii_lowercase):
-        raise ValueError("Too many dimensions to map to einsum subscripts")
+    out_tensor = _matmul_lower(
+        x_tensor,
+        y_tensor,
+        x.type.dims,
+        y.type.dims,
+        node.op.dims,
+        out.type.dims,
+    )
 
-    dim_to_char = dict(zip(all_dims, ascii_lowercase))
+    if out_tensor is None:
+        # Outer-product fallback: build an einsum string and lower via einsum.
+        all_dims = list(dict.fromkeys(x.type.dims + y.type.dims + out.type.dims))
+        if len(all_dims) > len(ascii_lowercase):
+            raise ValueError("Too many dimensions to map to einsum subscripts")
+        dim_to_char = dict(zip(all_dims, ascii_lowercase))
+        x_subs = "".join(dim_to_char[d] for d in x.type.dims)
+        y_subs = "".join(dim_to_char[d] for d in y.type.dims)
+        out_subs = "".join(dim_to_char[d] for d in out.type.dims)
+        einsum_str = f"{x_subs},{y_subs}->{out_subs}"
+        out_tensor = einsum(einsum_str, x_tensor, y_tensor)
+        if out_tensor.owner is not None and isinstance(out_tensor.owner.op, Einsum):
+            # Inline so grad / ShapeOpt see flat ops instead of an OFG wrapper.
+            [out_tensor] = inline_ofg_node(out_tensor.owner)
 
-    # Build einsum string
-    x_subs = "".join(dim_to_char[d] for d in x.type.dims)
-    y_subs = "".join(dim_to_char[d] for d in y.type.dims)
-    out_subs = "".join(dim_to_char[d] for d in out.type.dims)
-    einsum_str = f"{x_subs},{y_subs}->{out_subs}"
-
-    # Perform the einsum operation
-    out_tensor = einsum(einsum_str, x_tensor, y_tensor)
-
-    # Reshape to match the output shape
     out_tensor = specify_shape(out_tensor, out.type.shape)
-
     return [xtensor_from_tensor(out_tensor, out.type.dims)]
diff --git a/tests/tensor/test_math.py b/tests/tensor/test_math.py
index 2516cb6ff4..379af56b12 100644
--- a/tests/tensor/test_math.py
+++ b/tests/tensor/test_math.py
@@ -2478,6 +2478,25 @@ def test_eager_simplification(self):
         out = tensordot(mat, mat, axes=[[-1], [-1]])
         assert equal_computations([out], [dot(mat, mat.T)])
 
+    def test_static_shape_reshape_no_shape_subtensor(self):
+        """When all relevant dims are static, tensordot's reshape arguments
+        should fold to plain int constants — no Shape / Subtensor / MakeVector
+        chain produced just to read sizes back from the operand shapes.
+        """
+        from pytensor.graph.traversal import io_toposort
+        from pytensor.tensor.shape import Shape, Shape_i
+
+        a = tensor("a", shape=(3, 4, 5))
+        b = tensor("b", shape=(5, 6, 7))
+        out = tensordot(a, b, axes=[[2], [0]])
+
+        nodes = io_toposort([], [out])
+        shape_nodes = [n for n in nodes if isinstance(n.op, Shape | Shape_i)]
+        assert shape_nodes == [], (
+            "tensordot over fully-static dims should not introduce Shape ops; "
+            f"got: {[type(n.op).__name__ for n in shape_nodes]}"
+        )
+
 
 def test_smallest():
     x = dvector()
diff --git a/tests/xtensor/test_math.py b/tests/xtensor/test_math.py
index 633d30a426..a9ab5f1293 100644
--- a/tests/xtensor/test_math.py
+++ b/tests/xtensor/test_math.py
@@ -316,6 +316,59 @@ def test_dot():
     xr_assert_allclose(z_test, expected)
 
 
+def test_dot_lowers_to_matmul():
+    """Matmul-shaped xtensor.dot should lower to a single Blockwise(Dot=Matmul).
+
+    This guards the fast path in ``lower_dot``: any contraction that shares a
+    contracted dim between operands should go through ``matmul`` rather than
+    falling back to einsum. The reverse case (pure outer product) is checked
+    by ``test_dot_outer_product_falls_back_to_einsum``.
+    """
+    from pytensor.graph.rewriting.utils import rewrite_graph
+    from pytensor.graph.traversal import io_toposort
+    from pytensor.tensor.blockwise import Blockwise
+    from pytensor.tensor.math import _dot
+
+    x = xtensor("x", dims=("batch", "a", "k"), shape=(None, 4, 5))
+    y = xtensor("y", dims=("batch", "k", "b"), shape=(None, 5, 6))
+    z = x.dot(y, dim="k")
+
+    lowered = rewrite_graph(z.values, include=("lower_xtensor",))
+    matmuls = [
+        n
+        for n in io_toposort([], [lowered])
+        if isinstance(n.op, Blockwise) and n.op.core_op == _dot
+    ]
+    assert len(matmuls) == 1, (
+        f"matmul-shaped xtensor.dot should lower to exactly one Blockwise(Dot), "
+        f"got {len(matmuls)}"
+    )
+
+
+def test_dot_outer_product_falls_back_to_einsum():
+    """Pure outer products have no shared contracted dim and must fall back
+    to einsum. After lowering there should be no Blockwise(Dot)/Matmul left."""
+    from pytensor.graph.rewriting.utils import rewrite_graph
+    from pytensor.graph.traversal import io_toposort
+    from pytensor.tensor.blockwise import Blockwise
+    from pytensor.tensor.math import _dot
+
+    x = xtensor("x", dims=("a",), shape=(4,))
+    y = xtensor("y", dims=("b",), shape=(3,))
+    z = x.dot(y, dim=())
+
+    lowered = rewrite_graph(z.values, include=("lower_xtensor",))
+    matmuls = [
+        n
+        for n in io_toposort([], [lowered])
+        if isinstance(n.op, Blockwise) and n.op.core_op == _dot
+    ]
+    assert matmuls == [], (
+        "outer-product xtensor.dot should fall back to einsum and not produce "
+        "a Blockwise(Dot)/Matmul"
+    )
+
+
 def test_dot_errors():
     # No matching dimensions
     x = xtensor("x", dims=("a", "b"), shape=(2, 3))

From 298d02a9ab31ca22ae9cf99860196131adcee93d Mon Sep 17 00:00:00 2001
From: Carlos Trujillo <59846724+cetagostini@users.noreply.github.com>
Date: Fri, 22 May 2026 17:11:29 +0900
Subject: [PATCH 2/2] small changes

---
 doc/gallery/transformers/tiny_transformer_llm.ipynb | 2 +-
 tests/xtensor/test_math.py                          | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/doc/gallery/transformers/tiny_transformer_llm.ipynb b/doc/gallery/transformers/tiny_transformer_llm.ipynb
index c1f116c9f2..5a1c3954d1 100644
--- a/doc/gallery/transformers/tiny_transformer_llm.ipynb
+++ b/doc/gallery/transformers/tiny_transformer_llm.ipynb
@@ -1084,7 +1084,7 @@
       "source": [
         "## A sample from the deeper model\n",
         "\n",
-        "On held-out text the deeper model is genuinely better — about 0.12 nats per character lower cross-entropy, or **~11 % lower perplexity** (5.69 vs 6.39). 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."
+        "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."
       ]
     },
     {
diff --git a/tests/xtensor/test_math.py b/tests/xtensor/test_math.py
index a9ab5f1293..1019fae1c5 100644
--- a/tests/xtensor/test_math.py
+++ b/tests/xtensor/test_math.py
@@ -395,7 +395,11 @@ def test_dot_errors():
     # Doesn't fail until the rewrite
     with pytest.raises(
         ValueError,
-        match=r"(Input operand 1 has a mismatch in its core dimension 0|incompatible array sizes for np.dot)",
+        match=(
+            r"Input operand 1 has a mismatch in its core dimension 0"
+            r"|incompatible array sizes for np.dot"
+            r"|Shape mismatch: x has"
+        ),
     ):
         fn(x_test, y_test)