{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "66d8312f",
   "metadata": {},
   "source": [
    "(transformers)=\n",
    "# Transformer predictive coding networks\n",
    "\n",
    "This notebook builds the **smallest possible GPT-style Transformer** in\n",
    "JAX/[Equinox](https://docs.kidger.site/equinox/) and trains it twice with ordinary backpropagation and with PyHGF using the hybrid approach described [here](deep_networks_implementation).\n",
    "\n",
    "The two learners are then put **side by side** and both generate text. The pipeline is deliberately minimal and self-contained: a **char-level\n",
    "tokenizer**, a tiny **GPT** (2 layers, 64-dim, 4 heads), short training loops, and autoregressive text generation.\n",
    "\n",
    "The PyHGF machinery assembles a **mixed pipeline**: a sequence of parts where each slot holds either a *frozen calculation* (normalisation, the attention mixing, things with nothing to learn, which only translate errors with hand-derived formulas) or a *learning PyHGF network*. Walked forward, the pipeline predicts. Walked backward, each part learns locally and hands the error at its input to the part behind it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bbdb16d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/au646069/git/pyhgf/pyhgf/__init__.py:124: RuntimeWarning: pyhgf sets --xla_cpu_use_thunk_runtime=false to avoid a large slowdown in gradients through the belief propagation scan on jaxlib 0.6.2. jax was already imported, so the flag may arrive too late to take effect. Import pyhgf before jax, or set XLA_FLAGS yourself, to be sure of it.\n",
      "  LEGACY_CPU_RUNTIME_FLAG = _use_legacy_cpu_runtime()\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "import equinox as eqx\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "import matplotlib.pyplot as plt\n",
    "import optax\n",
    "import seaborn as sns\n",
    "from jax import random\n",
    "\n",
    "from pyhgf.model import (\n",
    "    DeepNetworkAdapter,\n",
    "    FusedPipeline,\n",
    "    from_embedding,\n",
    "    from_feedforward,\n",
    "    from_linear,\n",
    "    hybrid_from_gpt,\n",
    ")\n",
    "\n",
    "plt.rcParams[\"figure.constrained_layout.use\"] = True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71a1abdd",
   "metadata": {},
   "source": [
    "## Data and tokenizer\n",
    "\n",
    "We use a **character-level tokenizer**: the vocabulary is simply the set of unique characters in the corpus. `stoi`/`itos` map characters to integer ids and back. This needs no external library and keeps the vocabulary tiny (a few dozen tokens), which is ideal for a minimal model.\n",
    "\n",
    "The corpus is a short thematic text repeated a few times so the tiny model has enough sequence windows to learn a reproducible pattern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b32fc073",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vocab_size = 27, corpus length = 4350 tokens, vocabulary: ' ,.abcdefghiklmnoprstuvwxyz'\n"
     ]
    }
   ],
   "source": [
    "corpus = (\n",
    "    \"predictive coding networks learn by minimizing prediction errors. \"\n",
    "    \"each layer predicts the activity of the next, and updates its weights locally. \"\n",
    ") * 30\n",
    "\n",
    "chars = sorted(set(corpus))\n",
    "stoi = {c: i for i, c in enumerate(chars)}\n",
    "itos = {i: c for c, i in stoi.items()}\n",
    "vocab_size = len(chars)\n",
    "\n",
    "encode = lambda s: jnp.array([stoi[c] for c in s], dtype=jnp.int32)\n",
    "decode = lambda ids: \"\".join(itos[int(i)] for i in ids)\n",
    "\n",
    "data = encode(corpus)\n",
    "print(\n",
    "    f\"vocab_size = {vocab_size}, corpus length = {len(data)} tokens, vocabulary: {''.join(chars)!r}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f6a8da5",
   "metadata": {},
   "source": [
    "### Batching\n",
    "\n",
    "Training examples are random windows of length `T` (the context length). For a window starting at `i`, the input is `data[i:i+T]` and the target is the same window shifted by one (`data[i+1:i+T+1]`),  i.e. *predict the next token at every position*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d3e59afb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: (4, 32) y: (4, 32)\n",
      "example input : orks learn by minimizing predict\n",
      "example target: rks learn by minimizing predicti\n"
     ]
    }
   ],
   "source": [
    "T = 32  # context length\n",
    "\n",
    "\n",
    "def get_batch(key, batch_size):\n",
    "    \"\"\"Draw ``batch_size`` windows of ``T`` characters and their next characters.\"\"\"\n",
    "    ix = random.randint(key, (batch_size,), 0, len(data) - T - 1)\n",
    "    windows = ix[:, None] + jnp.arange(T)  # one gather, no Python loop\n",
    "    return data[windows], data[windows + 1]\n",
    "\n",
    "\n",
    "xb, yb = get_batch(random.key(0), batch_size=4)\n",
    "print(\"x:\", xb.shape, \"y:\", yb.shape)\n",
    "print(\"example input :\", decode(xb[0]))\n",
    "print(\"example target:\", decode(yb[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11454560",
   "metadata": {},
   "source": [
    "## The architecture\n",
    "\n",
    "A GPT is a **feedforward** stack (no recurrence): token+position embeddings, then `L` identical blocks, then a final norm and an unembedding head. Each block is two sub-layers, each wrapped in **pre-norm + residual**:\n",
    "\n",
    "```\n",
    "x  ->  x + Attention(LayerNorm(x))   # mixes information ACROSS positions\n",
    "x  ->  x + FeedForward(LayerNorm(x)) # acts on each position INDEPENDENTLY\n",
    "```\n",
    "\n",
    "Following the Equinox convention, every module operates on a **single sequence** `x` of shape `(T, D)`; we `jax.vmap` over the batch only at the loss. Per-token linear layers are applied with `jax.vmap` over the `T` axis."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04b90a5f",
   "metadata": {},
   "source": [
    "### Multi-head causal self-attention\n",
    "\n",
    "The only operation that moves information *between token positions*. The `W_{Q,K,V,O}` are learnable; the mixing matrix `softmax(QKᵀ/√d)` is computed from the data (no weights). The causal mask forbids attending to future positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "34f917c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiHeadAttention(eqx.Module):\n",
    "    \"\"\"Causal multi-head self-attention over one sequence of shape ``(T, D)``.\"\"\"\n",
    "\n",
    "    wqkv: eqx.nn.Linear\n",
    "    wo: eqx.nn.Linear\n",
    "    n_heads: int = eqx.field(static=True)\n",
    "    head_dim: int = eqx.field(static=True)\n",
    "\n",
    "    def __init__(self, dim, n_heads, key):\n",
    "        k1, k2 = random.split(key)\n",
    "        # The query, key, and value projections read the same input, so they\n",
    "        # are one fused matrix: the output stacks the three streams on the\n",
    "        # feature axis, [q | k | v], computed as a single matrix product.\n",
    "        self.wqkv = eqx.nn.Linear(dim, 3 * dim, use_bias=False, key=k1)\n",
    "        self.wo = eqx.nn.Linear(dim, dim, use_bias=False, key=k2)\n",
    "        self.n_heads = n_heads\n",
    "        self.head_dim = dim // n_heads\n",
    "\n",
    "    def __call__(self, x):\n",
    "        \"\"\"Mix information across the positions of ``x`` of shape ``(T, D)``.\"\"\"\n",
    "        seq_len, dim = x.shape\n",
    "        q, k, v = jnp.split(jax.vmap(self.wqkv)(x), 3, axis=-1)\n",
    "        # (T, D) -> (n_heads, T, head_dim)\n",
    "        split = lambda a: a.reshape(seq_len, self.n_heads, self.head_dim).transpose(\n",
    "            1, 0, 2\n",
    "        )\n",
    "        q, k, v = split(q), split(k), split(v)\n",
    "        scores = q @ k.transpose(0, 2, 1) / jnp.sqrt(self.head_dim)  # (H, T, T)\n",
    "        mask = jnp.tril(jnp.ones((seq_len, seq_len)))\n",
    "        scores = jnp.where(mask[None] == 0, -jnp.inf, scores)\n",
    "        attn = jax.nn.softmax(scores, axis=-1)\n",
    "        out = (attn @ v).transpose(1, 0, 2).reshape(seq_len, dim)  # back to (T, D)\n",
    "        return jax.vmap(self.wo)(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f06cf6d",
   "metadata": {},
   "source": [
    "### Feed-forward (per-position MLP)\n",
    "\n",
    "`Linear(D -> 4D) -> GELU -> Linear(4D -> D)`, applied identically and independently to every position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "54d61244",
   "metadata": {},
   "outputs": [],
   "source": [
    "class FeedForward(eqx.Module):\n",
    "    \"\"\"Per-position MLP: ``Linear(dim, hidden)``, GELU, ``Linear(hidden, dim)``.\"\"\"\n",
    "\n",
    "    fc1: eqx.nn.Linear\n",
    "    fc2: eqx.nn.Linear\n",
    "\n",
    "    def __init__(self, dim, hidden, key):\n",
    "        k1, k2 = random.split(key)\n",
    "        self.fc1 = eqx.nn.Linear(dim, hidden, key=k1)\n",
    "        self.fc2 = eqx.nn.Linear(hidden, dim, key=k2)\n",
    "\n",
    "    def __call__(self, x):\n",
    "        \"\"\"Apply the MLP to every position of ``x`` of shape ``(T, D)``.\"\"\"\n",
    "        return jax.vmap(self.fc2)(jax.nn.gelu(jax.vmap(self.fc1)(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48dc226d",
   "metadata": {},
   "source": [
    "### Transformer block and full GPT\n",
    "\n",
    "Pre-norm + residual around each sub-layer, then stack `L` blocks between the embeddings and the unembedding head."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ac82faf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Block(eqx.Module):\n",
    "    \"\"\"One Transformer block: pre-norm attention and feed-forward sub-layers.\"\"\"\n",
    "\n",
    "    attn: MultiHeadAttention\n",
    "    ff: FeedForward\n",
    "    n1: eqx.nn.LayerNorm\n",
    "    n2: eqx.nn.LayerNorm\n",
    "\n",
    "    def __init__(self, dim, n_heads, hidden, key):\n",
    "        k1, k2 = random.split(key)\n",
    "        self.attn = MultiHeadAttention(dim, n_heads, k1)\n",
    "        self.ff = FeedForward(dim, hidden, k2)\n",
    "        self.n1 = eqx.nn.LayerNorm(dim)\n",
    "        self.n2 = eqx.nn.LayerNorm(dim)\n",
    "\n",
    "    def __call__(self, x):\n",
    "        \"\"\"Run both sub-layers on ``x`` of shape ``(T, D)`` through their residuals.\"\"\"\n",
    "        x = x + self.attn(jax.vmap(self.n1)(x))\n",
    "        x = x + self.ff(jax.vmap(self.n2)(x))\n",
    "        return x\n",
    "\n",
    "\n",
    "class GPT(eqx.Module):\n",
    "    \"\"\"Decoder-only Transformer mapping token ids to logits over the vocabulary.\"\"\"\n",
    "\n",
    "    tok_emb: eqx.nn.Embedding\n",
    "    pos_emb: eqx.nn.Embedding\n",
    "    blocks: list\n",
    "    norm_f: eqx.nn.LayerNorm\n",
    "    head: eqx.nn.Linear\n",
    "    context_length: int = eqx.field(static=True)\n",
    "\n",
    "    def __init__(self, vocab_size, dim, n_heads, hidden, n_layers, context_length, key):\n",
    "        keys = random.split(key, n_layers + 3)\n",
    "        self.tok_emb = eqx.nn.Embedding(vocab_size, dim, key=keys[0])\n",
    "        self.pos_emb = eqx.nn.Embedding(context_length, dim, key=keys[1])\n",
    "        self.blocks = [\n",
    "            Block(dim, n_heads, hidden, keys[2 + i]) for i in range(n_layers)\n",
    "        ]\n",
    "        self.norm_f = eqx.nn.LayerNorm(dim)\n",
    "        self.head = eqx.nn.Linear(dim, vocab_size, use_bias=False, key=keys[-1])\n",
    "        self.context_length = context_length\n",
    "\n",
    "    def __call__(self, idx):\n",
    "        \"\"\"Map token ids ``(T,)`` to logits of shape ``(T, vocab_size)``.\"\"\"\n",
    "        seq_len = idx.shape[0]\n",
    "        x = jax.vmap(self.tok_emb)(idx) + jax.vmap(self.pos_emb)(jnp.arange(seq_len))\n",
    "        for block in self.blocks:\n",
    "            x = block(x)\n",
    "        return jax.vmap(self.head)(jax.vmap(self.norm_f)(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "284cfe2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 72,064\n",
      "logits shape: (32, 27) (T, vocab_size)\n"
     ]
    }
   ],
   "source": [
    "DIM, HEADS, HIDDEN, LAYERS, BATCH = 64, 4, 128, 2, 16\n",
    "\n",
    "reference = GPT(vocab_size, DIM, HEADS, HIDDEN, LAYERS, T, key=random.key(0))\n",
    "\n",
    "n_params = sum(\n",
    "    x.size for x in jax.tree_util.tree_leaves(eqx.filter(reference, eqx.is_array))\n",
    ")\n",
    "print(f\"number of parameters: {n_params:,}\")\n",
    "\n",
    "# sanity check: forward pass shape\n",
    "logits = reference(data[:T])\n",
    "print(\"logits shape:\", logits.shape, \"(T, vocab_size)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d13cf200",
   "metadata": {},
   "source": [
    "## Training with backpropagation\n",
    "\n",
    "Next-token prediction with cross-entropy loss and Adam. `eqx.filter_value_and_grad` differentiates only the array leaves (the weights), leaving the static config untouched. This `loss.backward()`-style global gradient (one backward sweep threading information from the loss through every layer) is precisely what the PyHGF port replaces with a local, layer-wise prediction-error rule."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c9abadd2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step    0  |  loss 3.4361\n",
      "step  100  |  loss 0.3172\n",
      "step  200  |  loss 0.1258\n",
      "step  300  |  loss 0.0915\n",
      "step  399  |  loss 0.0804\n",
      "backpropagation: 400 steps in 3 s\n"
     ]
    }
   ],
   "source": [
    "def ce_loss(model, x, y):\n",
    "    \"\"\"Mean cross-entropy of the model on a batch ``x`` with targets ``y``.\"\"\"\n",
    "    logits = jax.vmap(model)(x)  # (B, T, vocab_size)\n",
    "    return optax.softmax_cross_entropy_with_integer_labels(logits, y).mean()\n",
    "\n",
    "\n",
    "optimiser = optax.adam(3e-3)\n",
    "opt_state = optimiser.init(eqx.filter(reference, eqx.is_array))\n",
    "\n",
    "\n",
    "@eqx.filter_jit\n",
    "def backprop_step(model, opt_state, x, y):\n",
    "    \"\"\"Take one Adam step and return the updated model, optimiser state and loss.\"\"\"\n",
    "    loss, grads = eqx.filter_value_and_grad(ce_loss)(model, x, y)\n",
    "    updates, opt_state = optimiser.update(grads, opt_state)\n",
    "    return eqx.apply_updates(model, updates), opt_state, loss\n",
    "\n",
    "\n",
    "N_STEPS = 400\n",
    "\n",
    "key = random.key(1)\n",
    "reference_losses = []\n",
    "t0 = time.perf_counter()\n",
    "for it in range(N_STEPS):\n",
    "    key, bk = random.split(key)\n",
    "    x, y = get_batch(bk, BATCH)\n",
    "    reference, opt_state, loss = backprop_step(reference, opt_state, x, y)\n",
    "    reference_losses.append(float(loss))\n",
    "    if it % 100 == 0 or it == N_STEPS - 1:\n",
    "        print(f\"step {it:4d}  |  loss {float(loss):.4f}\")\n",
    "backprop_seconds = time.perf_counter() - t0\n",
    "print(f\"backpropagation: {N_STEPS} steps in {backprop_seconds:.0f} s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48120d6b",
   "metadata": {},
   "source": [
    "## The same Transformer, learning through PyHGF\n",
    "\n",
    "Now every weight in the model learns through PyHGF: the four attention\n",
    "tables of each block, the feed-forwards, both embedding tables, and the output\n",
    "head. Only the weightless calculations stay frozen: normalisations, the\n",
    "attention mixing, and the shortcut junctions, which translate errors with\n",
    "hand-derived formulas."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f84b2893",
   "metadata": {},
   "source": [
    "### The pinned-confidence configuration\n",
    "\n",
    "Every learning part keeps the same **pinned-confidence configuration**:\n",
    "volatility levels frozen and high prior confidence (precision, a belief's\n",
    "inverse variance) on the hidden and input layers, so their beliefs barely move\n",
    "during the update sweep (a *silent interior*; see the\n",
    "[theory page](./0.5-Deep_networks_theory.ipynb)), with unit precision on the\n",
    "observed output layer.\n",
    "\n",
    "### The learning rule\n",
    "\n",
    "The weights learn here in the exact **backprop-parity** mode\n",
    "(`learning_kind=\"precision_weighted\"`, the adapter's default): the hidden\n",
    "layer's belief shift is its routed error *divided by* its posterior\n",
    "confidence, and the confidence-weighted update multiplies that same\n",
    "confidence back in. The two cancel exactly, so each local update coincides\n",
    "with the backpropagated gradient (the correspondence is derived in the\n",
    "[theory page](./0.5-Deep_networks_theory.ipynb)). This makes the comparison with\n",
    "the baseline as direct as possible: the two learners apply the same weight\n",
    "updates and differ only in how they reach them, local message passing\n",
    "against a global backward sweep.\n",
    "\n",
    "### The categorical head\n",
    "\n",
    "The head is a **categorical belief layer**: its nodes jointly represent\n",
    "one softmax choice over the characters, so the model optimises exactly the\n",
    "same cross-entropy objective as the baseline. Training clamps the truth\n",
    "\"the next character is this one\", a one-hot pattern, directly onto those\n",
    "beliefs, and the classification error arises from PyHGF's own\n",
    "prediction-error rule.\n",
    "The head's own update is the plain cross-entropy gradient (the `one_hot − softmax` \n",
    "error times the activity), exactly the backprop head's. The head's forward output is\n",
    "already a probability distribution over the characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ba17dfae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PyHGF: 400 steps in 3 s\n",
      "step    0  |  next-character accuracy 0.06\n",
      "step  100  |  next-character accuracy 0.91\n",
      "step  200  |  next-character accuracy 0.96\n",
      "step  300  |  next-character accuracy 0.98\n",
      "step  399  |  next-character accuracy 0.97\n"
     ]
    }
   ],
   "source": [
    "PARITY = dict(\n",
    "    volatility_parent=False,\n",
    "    precision=1e4,\n",
    "    expected_precision=1e4,\n",
    ")\n",
    "PARITY_LEAF = dict(volatility_parent=False)\n",
    "\n",
    "scratch = GPT(vocab_size, DIM, HEADS, HIDDEN, LAYERS, T, key=random.key(0))\n",
    "\n",
    "\n",
    "def pyhgf_part(net):\n",
    "    \"\"\"Wrap a deep network as a pipeline part that learns through PyHGF.\"\"\"\n",
    "    # \"precision_weighted\" is the exact backprop-parity mode: each local update\n",
    "    # coincides with the backpropagated gradient.\n",
    "    return DeepNetworkAdapter(\n",
    "        net, optimiser=optax.adam(3e-3), learning_kind=\"precision_weighted\"\n",
    "    )\n",
    "\n",
    "\n",
    "pc_gpt = hybrid_from_gpt(\n",
    "    scratch,\n",
    "    attention_parts=[\n",
    "        {\n",
    "            name: pyhgf_part(\n",
    "                from_linear(\n",
    "                    getattr(b.attn, name), leaf_kwargs=PARITY_LEAF, layer_kwargs=PARITY\n",
    "                )\n",
    "            )\n",
    "            for name in (\"wqkv\", \"wo\")\n",
    "        }\n",
    "        for b in scratch.blocks\n",
    "    ],\n",
    "    ff_parts=[\n",
    "        pyhgf_part(\n",
    "            from_feedforward(\n",
    "                b.ff.fc1, b.ff.fc2, leaf_kwargs=PARITY_LEAF, layer_kwargs=PARITY\n",
    "            )\n",
    "        )\n",
    "        for b in scratch.blocks\n",
    "    ],\n",
    "    head_part=pyhgf_part(\n",
    "        from_linear(\n",
    "            scratch.head,\n",
    "            leaf_kwargs=dict(kind=\"categorical\", **PARITY_LEAF),\n",
    "            layer_kwargs=PARITY,\n",
    "        )\n",
    "    ),\n",
    "    token_part=pyhgf_part(\n",
    "        from_embedding(scratch.tok_emb, leaf_kwargs=PARITY_LEAF, layer_kwargs=PARITY)\n",
    "    ),\n",
    "    position_part=pyhgf_part(\n",
    "        from_embedding(scratch.pos_emb, leaf_kwargs=PARITY_LEAF, layer_kwargs=PARITY)\n",
    "    ),\n",
    ")\n",
    "\n",
    "pc_pipeline = FusedPipeline(\n",
    "    pc_gpt,\n",
    "    # The cross-entropy error at the head, formed inside the compiled step:\n",
    "    # feeding probs - one_hot through the correct-and-clamp entry clamps\n",
    "    # exactly the one-hot truth on the beliefs.\n",
    "    error_fn=lambda probs, y: probs - jax.nn.one_hot(y, vocab_size),\n",
    ")\n",
    "\n",
    "# The timed loop does the same work as the backpropagation loop (draw a\n",
    "# batch, take one step) and only stores each step's output; every metric\n",
    "# is computed after the fact, below.\n",
    "all_probs, all_targets = [], []\n",
    "key = random.key(4)\n",
    "t0 = time.perf_counter()\n",
    "for it in range(N_STEPS):\n",
    "    key, bk = random.split(key)\n",
    "    x, y = get_batch(bk, BATCH)\n",
    "    probs, _ = pc_pipeline.step(x, y)  # (B, T, vocab): one softmax per position\n",
    "    all_probs.append(probs)\n",
    "    all_targets.append(y)\n",
    "probs.block_until_ready()  # flush the queued steps before stopping the clock\n",
    "pyhgf_seconds = time.perf_counter() - t0\n",
    "print(f\"PyHGF: {N_STEPS} steps in {pyhgf_seconds:.0f} s\")\n",
    "\n",
    "# Metrics, after the fact. The head's output is a probability distribution,\n",
    "# so its cross-entropy is directly comparable with the reference's.\n",
    "all_probs, all_targets = jnp.stack(all_probs), jnp.stack(all_targets)\n",
    "p_target = jnp.take_along_axis(all_probs, all_targets[..., None], axis=-1)\n",
    "pc_losses = -jnp.log(jnp.clip(p_target, 1e-9, None)).mean(axis=(1, 2, 3))\n",
    "accuracies = (all_probs.argmax(-1) == all_targets).mean(axis=(1, 2))\n",
    "for it in (0, 100, 200, 300, N_STEPS - 1):\n",
    "    print(f\"step {it:4d}  |  next-character accuracy {float(accuracies[it]):.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "93252d48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(7, 4))\n",
    "ax.plot(accuracies, color=\"#4c72b0\", linewidth=1.5)\n",
    "ax.set(\n",
    "    xlabel=\"training step\",\n",
    "    ylabel=\"next-character accuracy\",\n",
    "    title=\"Every weight learning through PyHGF, no backpropagation anywhere\",\n",
    ")\n",
    "ax.grid(linestyle=\"--\")\n",
    "sns.despine()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8eadaef",
   "metadata": {},
   "source": [
    "## Accuracy and execution time\n",
    "\n",
    "Both models are trained for the same number of steps on batches drawn in the same\n",
    "way, and both run as one compiled program per step, so their training\n",
    "curves and wall-clock times can be put side by side. With the categorical\n",
    "head, both learners optimise the *same* softmax cross-entropy, so the\n",
    "curves are directly comparable — and in the backprop-parity mode used here\n",
    "each local update coincides with the backpropagated gradient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "25774ad2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time per step: backprop 8.3 ms, PyHGF 8.1 ms (1.0x)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(\n",
    "    1, 2, figsize=(10, 4), gridspec_kw={\"width_ratios\": [2.2, 1]}\n",
    ")\n",
    "\n",
    "ax1.plot(\n",
    "    reference_losses, label=\"Backpropagation (Equinox)\", color=\"grey\", linewidth=1.5\n",
    ")\n",
    "ax1.plot(pc_losses, label=\"Predictive coding (PyHGF)\", color=\"#4c72b0\", linewidth=1.5)\n",
    "ax1.set(\n",
    "    xlabel=\"Training step\",\n",
    "    ylabel=\"Training cross-entropy\",\n",
    "    title=\"Training loss per step\",\n",
    ")\n",
    "ax1.grid(linestyle=\"--\")\n",
    "ax1.legend()\n",
    "\n",
    "bars = ax2.bar(\n",
    "    [\"Backpropagation \\n (Equinox)\", \"Predictive coding \\n (PyHGF)\"],\n",
    "    [backprop_seconds, pyhgf_seconds],\n",
    "    color=[\"grey\", \"#4c72b0\"],\n",
    ")\n",
    "\n",
    "ax2.set(ylabel=f\"Training time, {N_STEPS} steps (s)\", title=\"Wall-clock cost\")\n",
    "ax2.grid(axis=\"y\", linestyle=\"--\")\n",
    "\n",
    "sns.despine()\n",
    "\n",
    "ms_backprop = backprop_seconds / N_STEPS * 1e3\n",
    "ms_pyhgf = pyhgf_seconds / N_STEPS * 1e3\n",
    "print(\n",
    "    f\"time per step: backprop {ms_backprop:.1f} ms, \"\n",
    "    f\"PyHGF {ms_pyhgf:.1f} ms ({ms_pyhgf / ms_backprop:.1f}x)\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a10e8f99",
   "metadata": {},
   "source": [
    "In terms of *learning per step*, the two are close: both collapse the loss\n",
    "within the first few hundred steps and flatten near the same floor. In\n",
    "terms of *wall-clock*, the predictive-coding learner stays within a small\n",
    "factor of backpropagation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dd01a0a",
   "metadata": {},
   "source": [
    "## Generating text\n",
    "\n",
    "Autoregressive generation is an **inference-time loop** around the\n",
    "feedforward model: feed the current context (cropped to the context length),\n",
    "take the prediction at the last position, sample the next token, append, and\n",
    "repeat. This outer loop is *not* recurrence in the architecture; the model\n",
    "itself remains feedforward. Both learners generate the same way; the only\n",
    "difference is where the next-character distribution comes from. The backprop\n",
    "model outputs logits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5fbf0a14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predictive coding networks learn by minimizing prediction errors. each layer predicts the activity of the next, and updates its we\n"
     ]
    }
   ],
   "source": [
    "def generate_backprop(model, idx, n_new, key):\n",
    "    \"\"\"Sample ``n_new`` characters from the backpropagation-trained model.\"\"\"\n",
    "    for _ in range(n_new):\n",
    "        logits = model(idx[-model.context_length :])[-1]  # last-position logits\n",
    "        key, sub = random.split(key)\n",
    "        next_id = random.categorical(sub, logits).astype(jnp.int32)\n",
    "        idx = jnp.concatenate([idx, next_id[None]])\n",
    "    return idx\n",
    "\n",
    "\n",
    "out = generate_backprop(reference, encode(\"predictive\"), n_new=120, key=random.key(2))\n",
    "print(decode(out))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33d792f0",
   "metadata": {},
   "source": [
    "The PyHGF model's forward pass already ends in a probability distribution\n",
    "over the characters (its categorical head), which is sampled from directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9f834121",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predictive coding networks learn by minimizing prediction errors. each layer predicts the activity of the next, and updates its we\n"
     ]
    }
   ],
   "source": [
    "def generate_pyhgf(pipeline, idx, n_new, key):\n",
    "    \"\"\"Sample ``n_new`` characters from the categorical head of the pipeline.\"\"\"\n",
    "    for _ in range(n_new):\n",
    "        window = idx[-T:]\n",
    "        probs = pipeline.predict(window[None])[0]  # forward pass only\n",
    "        p = probs[window.shape[0] - 1]\n",
    "        key, sub = random.split(key)\n",
    "        next_id = random.categorical(sub, jnp.log(p)).astype(jnp.int32)\n",
    "        idx = jnp.concatenate([idx, next_id[None]])\n",
    "    return idx\n",
    "\n",
    "\n",
    "out = generate_pyhgf(pc_pipeline, encode(\"predictive\"), n_new=120, key=random.key(5))\n",
    "print(decode(out))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3fc9d65-e189-4535-b122-ac628ca06937",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# System configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b8345ee7-ff4d-46c9-bf2e-c457b2649624",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last updated: Tue, 01 Sep 2026\n",
      "\n",
      "Python implementation: CPython\n",
      "Python version       : 3.12.13\n",
      "IPython version      : 9.16.1\n",
      "\n",
      "pyhgf : 0.3.0\n",
      "jax   : 0.6.2\n",
      "jaxlib: 0.6.2\n",
      "\n",
      "equinox   : 0.13.8\n",
      "jax       : 0.6.2\n",
      "matplotlib: 3.11.1\n",
      "optax     : 0.2.8\n",
      "platform  : 1.0.8\n",
      "pyhgf     : 0.3.0\n",
      "seaborn   : 0.13.2\n",
      "\n",
      "Watermark: 2.6.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -n -u -v -iv -w -p pyhgf,jax,jaxlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b1ea292-74b1-415e-a4ca-4bfd6d3cebfa",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}