{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "131add1a",
   "metadata": {},
   "source": [
    "# 09 - Train the GPT\n",
    "\n",
    "Everything is in place. Now we train the model from notebook 08 on Shakespeare and watch it learn. The loop is the same four lines as always (notebook 08's bigram used them too); the only difference is that the model in the middle is now a real Transformer.\n",
    "\n",
    "What to watch for: the loss falling from about 4.2 (random) towards about 1.6, and the generated text turning from noise into something resembling a play, with character names, line breaks, dialogue, and mostly real words, all from one model and a few minutes on a GPU."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "colab-setup-09",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Colab setup -- fetch the files this notebook needs.\n",
    "# (Does nothing when run locally in the course folder.)\n",
    "import os, urllib.request\n",
    "BASE = (\"https://raw.githubusercontent.com/waze\"\n",
    "        \"emlabs/llm-book-code/main/\")\n",
    "for f in ['gpt.py', 'data/input.txt']:\n",
    "    if not os.path.exists(f):\n",
    "        d = os.path.dirname(f)\n",
    "        if d: os.makedirs(d, exist_ok=True)\n",
    "        urllib.request.urlretrieve(BASE + f, f)\n",
    "        print(\"downloaded\", f)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "colab-setup-md-09",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n<ul>\n<li><code>import os, urllib.request</code>: two standard-library toolboxes: checking files on disk, and downloading from the web.</li>\n<li><code>BASE = (...)</code>: the web address of this course's folder on GitHub, split over two lines (Python glues adjacent strings together).</li>\n<li><code>for f in [...]</code>: loop over the file names this notebook needs.</li>\n<li><code>if not os.path.exists(f)</code>: only download what is missing -- running locally, everything already exists, so nothing happens.</li>\n<li><code>os.makedirs(d, exist_ok=True)</code>: create the folder for the file if it has one (<code>exist_ok</code> means don't complain if it's already there).</li>\n<li><code>urllib.request.urlretrieve(...)</code>: download the file and save it under the same name here.</li>\n</ul>\n</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f5000baa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T09:28:21.177185Z",
     "iopub.status.busy": "2026-07-01T09:28:21.176956Z",
     "iopub.status.idle": "2026-07-01T09:28:21.612631Z",
     "shell.execute_reply": "2026-07-01T09:28:21.612277Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training on: mps\n"
     ]
    }
   ],
   "source": [
    "import torch, time, math\n",
    "from pathlib import Path\n",
    "from gpt import GPT, GPTConfig\n",
    "torch.manual_seed(1337)\n",
    "device = \"mps\" if torch.backends.mps.is_available() else (\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(\"training on:\", device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4c11257",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>import torch, time, math</code>: PyTorch, plus <code>time</code> for the stopwatch and <code>math</code> for ln(65).</li>\n",
    "<li><code>from gpt import GPT, GPTConfig</code>: the model classes you toured in notebook 08.</li>\n",
    "<li><code>torch.manual_seed(1337)</code>: pin the randomness so training is reproducible.</li>\n",
    "<li>The device line picks Apple GPU &rarr; NVIDIA &rarr; CPU, as before.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e6a0cb7",
   "metadata": {},
   "source": [
    "## Data and batching\n",
    "\n",
    "Encode the text (notebook 02), hold out the last 10% as a **validation set**, and draw random `block_size` chunks for each step.\n",
    "\n",
    "Why hold out that 10%? It is the model's practice exam: text that it never trains on. We watch two losses, the **train** loss (on text it studies) and the **validation** loss (on the held-out text). If both fall together, the model is genuinely learning the language. If the train loss keeps dropping while the validation loss stalls or creeps up, the model is **memorizing** the training text instead of learning patterns that carry over. That failure is called **overfitting**, and the gap between the two numbers is how you spot it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "39ac61ea",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T09:28:21.613931Z",
     "iopub.status.busy": "2026-07-01T09:28:21.613823Z",
     "iopub.status.idle": "2026-07-01T09:28:21.666425Z",
     "shell.execute_reply": "2026-07-01T09:28:21.666018Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train tokens: 1003854 | val tokens: 111540\n"
     ]
    }
   ],
   "source": [
    "text = Path(\"data/input.txt\").read_text()\n",
    "chars = sorted(set(text)); vocab_size = len(chars)\n",
    "stoi = {c:i for i,c in enumerate(chars)}; itos = {i:c for c,i in stoi.items()}\n",
    "encode = lambda s: [stoi[c] for c in s]; decode = lambda l: \"\".join(itos[i] for i in l)\n",
    "\n",
    "data = torch.tensor(encode(text), dtype=torch.long)\n",
    "n = int(0.9*len(data)); train_data, val_data = data[:n], data[n:]\n",
    "\n",
    "block_size = 128     # context length\n",
    "batch_size = 32      # sequences per step\n",
    "def get_batch(split):\n",
    "    d = train_data if split == \"train\" else val_data\n",
    "    ix = torch.randint(len(d) - block_size, (batch_size,))\n",
    "    x = torch.stack([d[i:i+block_size] for i in ix])\n",
    "    y = torch.stack([d[i+1:i+1+block_size] for i in ix])\n",
    "    return x.to(device), y.to(device)\n",
    "print(\"train tokens:\", len(train_data), \"| val tokens:\", len(val_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5aef0b7",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li>The tokenizer and split are identical to notebook 02 (read the file, build the tables, encode, hold out the last 10%), in PyTorch tensors.</li>\n",
    "<li><code>block_size = 128</code>: the context window is now 128 characters (the bigram saw 1).</li>\n",
    "<li><code>batch_size = 32</code>: 32 sequences per training step.</li>\n",
    "<li><code>def get_batch(split):</code>: same recipe as before: 32 random 128-long chunks as context <code>x</code>, the same chunks shifted one right as targets <code>y</code>, both shipped to the GPU.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "939867ff",
   "metadata": {},
   "source": [
    "## Model, optimizer, and an honest loss estimate\n",
    "\n",
    "We build the same model of about 0.8 million numbers, now with a little **dropout** (set to 0.1). Dropout randomly switches off 10% of the signals on each training step, which stops the model from leaning too heavily on any single path. It is a bit like studying with random pages of your notes covered, so that you learn the material itself rather than memorizing one route to the answer. It is a standard guard against the overfitting just described, and it is active only during training.\n",
    "\n",
    "`estimate_loss` averages the loss over many batches (150 of them here) before printing. A single batch is a noisy reading, because some stretches of text are simply easier than others, so averaging gives an honest number that can be compared fairly from one step to the next."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "83865cd0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T09:28:21.667598Z",
     "iopub.status.busy": "2026-07-01T09:28:21.667543Z",
     "iopub.status.idle": "2026-07-01T09:28:22.047822Z",
     "shell.execute_reply": "2026-07-01T09:28:22.047335Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parameters: 824,897\n"
     ]
    }
   ],
   "source": [
    "cfg = GPTConfig(vocab_size=vocab_size, block_size=block_size,\n",
    "                n_layer=4, n_head=4, n_embd=128, dropout=0.1)\n",
    "model = GPT(cfg).to(device)\n",
    "optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)\n",
    "print(f\"parameters: {model.num_params():,}\")\n",
    "\n",
    "eval_iters = 150\n",
    "@torch.no_grad()\n",
    "def estimate_loss():\n",
    "    out = {}\n",
    "    model.eval()\n",
    "    for split in [\"train\", \"val\"]:\n",
    "        losses = torch.zeros(eval_iters)\n",
    "        for k in range(eval_iters):\n",
    "            x, y = get_batch(split)\n",
    "            _, loss = model(x, y)\n",
    "            losses[k] = loss.item()\n",
    "        out[split] = losses.mean().item()\n",
    "    model.train()\n",
    "    return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31531e7f",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>cfg = GPTConfig(..., dropout=0.1)</code>: the same model as notebook 08, now with 10% dropout switched on for training.</li>\n",
    "<li><code>model = GPT(cfg).to(device)</code> / <code>optimizer = torch.optim.AdamW(..., lr=1e-3)</code>: build it on the GPU and hand its knobs to AdamW.</li>\n",
    "<li><code>@torch.no_grad()</code>: decorator: everything inside runs without recording gradients (it's measurement, not learning).</li>\n",
    "<li><code>model.eval()</code> / <code>model.train()</code>: flip the model's mode: <code>eval</code> turns dropout <i>off</i> for an honest measurement, <code>train</code> turns it back on. Forgetting this pair is a classic bug.</li>\n",
    "<li><code>losses = torch.zeros(eval_iters)</code>: a 150-slot tensor; <code>losses[k] = loss.item()</code> fills slot k with a plain number.</li>\n",
    "<li><code>out[split] = losses.mean().item()</code>: store each split's average loss in a dictionary: <code>{\"train\": ..., \"val\": ...}</code>.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1123b69",
   "metadata": {},
   "source": [
    "## The training loop\n",
    "\n",
    "The same five moves as always: sample a batch, forward, `zero_grad`, `backward`, `step`. Every `eval_interval` steps we pause to estimate the train and validation losses and print them. Reading the output below, both numbers drop quickly at first and then slow down, and the validation loss sits a little above the train loss (which is normal: the practice exam is always a touch harder than the homework). It runs in a couple of minutes on an Apple GPU; raise `max_iters` (and the model size in `cfg`) for sharper text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a953dca5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T09:28:22.048944Z",
     "iopub.status.busy": "2026-07-01T09:28:22.048849Z",
     "iopub.status.idle": "2026-07-01T09:29:16.728112Z",
     "shell.execute_reply": "2026-07-01T09:29:16.727622Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step    0 | train 4.177 | val 4.174 |   1.4s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step  500 | train 1.971 | val 2.045 |  11.1s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 1000 | train 1.674 | val 1.830 |  19.4s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 1500 | train 1.546 | val 1.717 |  28.1s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 2000 | train 1.473 | val 1.654 |  36.9s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 2500 | train 1.421 | val 1.623 |  45.8s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 3000 | train 1.382 | val 1.593 |  54.7s\n",
      "\n",
      "done in 54.7s\n"
     ]
    }
   ],
   "source": [
    "max_iters = 3000\n",
    "eval_interval = 500\n",
    "history = []\n",
    "\n",
    "t0 = time.time()\n",
    "for it in range(max_iters + 1):\n",
    "    if it % eval_interval == 0:\n",
    "        l = estimate_loss()\n",
    "        history.append((it, l[\"train\"], l[\"val\"]))\n",
    "        print(f\"step {it:4d} | train {l['train']:.3f} | val {l['val']:.3f} | {time.time()-t0:5.1f}s\")\n",
    "    x, y = get_batch(\"train\")\n",
    "    _, loss = model(x, y)\n",
    "    optimizer.zero_grad(set_to_none=True)\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "print(f\"\\ndone in {time.time()-t0:.1f}s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59fbb88d",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>max_iters = 3000; eval_interval = 500; history = []</code>: how many steps to train, how often to measure, and a list to record the loss curve.</li>\n",
    "<li><code>t0 = time.time()</code>: start the stopwatch.</li>\n",
    "<li><code>for it in range(max_iters + 1):</code>: 3001 passes; the <code>+ 1</code> makes the final evaluation at step 3000 happen.</li>\n",
    "<li><code>if it % eval_interval == 0:</code>: every 500th step (<code>%</code> is remainder), pause and measure train/val loss properly.</li>\n",
    "<li><code>history.append((it, l[\"train\"], l[\"val\"]))</code>: record a (step, train, val) triple for the plot.</li>\n",
    "<li><code>print(f\"step {it:4d} | train {l['train']:.3f} | ...\")</code>: formatted print: <code>4d</code> pads the step number, <code>.3f</code> fixes 3 decimals.</li>\n",
    "<li><code>x, y = get_batch(\"train\")</code> &rarr; forward &rarr; <code>zero_grad</code> &rarr; <code>backward</code> &rarr; <code>step</code>: the same four-line heartbeat as every notebook. <i>Only the model in the middle changed</i> since the bigram.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3b30c293",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T09:29:16.729332Z",
     "iopub.status.busy": "2026-07-01T09:29:16.729261Z",
     "iopub.status.idle": "2026-07-01T09:29:16.903344Z",
     "shell.execute_reply": "2026-07-01T09:29:16.902904Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "steps = [h[0] for h in history]\n",
    "plt.figure(figsize=(6,4))\n",
    "plt.plot(steps, [h[1] for h in history], \"o-\", label=\"train\")\n",
    "plt.plot(steps, [h[2] for h in history], \"o-\", label=\"val\")\n",
    "plt.axhline(math.log(vocab_size), ls=\"--\", c=\"gray\", label=\"random baseline ln(vocab)\")\n",
    "plt.axhline(2.452, ls=\":\", c=\"crimson\", label=\"bigram optimum (nb 03)\")\n",
    "plt.xlabel(\"step\"); plt.ylabel(\"loss\"); plt.legend(); plt.title(\"GPT training: well below the bigram ceiling\"); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b7a105b",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>import matplotlib.pyplot as plt</code>: the plotting toolbox.</li>\n",
    "<li><code>steps = [h[0] for h in history]</code>: pull the step numbers out of the recorded triples; <code>h[1]</code> / <code>h[2]</code> pull train / val losses.</li>\n",
    "<li><code>plt.plot(steps, [h[1] for h in history], \"o-\", label=\"train\")</code>: the train-loss curve, dots joined by lines.</li>\n",
    "<li><code>plt.axhline(math.log(vocab_size), ls=\"--\", ...)</code>: a horizontal reference line at ln(65) = 4.17 (random guessing). <code>ls</code> is line style.</li>\n",
    "<li><code>plt.axhline(2.452, ls=\":\", ...)</code>: the bigram optimum from notebook 03. Watching the GPT curve dive <i>under</i> that line is the whole point of the picture.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ce86c6b",
   "metadata": {},
   "source": [
    "## What the numbers mean, and then hearing it speak\n",
    "\n",
    "A handy way to *feel* a loss value is to compute `e^loss`, a quantity called the **perplexity**. Roughly, it answers \"how many next-characters is the model still torn between?\"\n",
    "\n",
    "- random guessing: loss 4.17, so `e^4.17` is about **65 choices** (all of them, since it knows nothing),\n",
    "- the bigram ceiling: loss 2.45, so about **12 choices**,\n",
    "- our GPT: validation loss 1.59, so about **5 choices**.\n",
    "\n",
    "So training took the model from \"could be any of 65 characters\" down to \"one of about five.\" That is what breaking through the bigram ceiling looks like: attention let the model use 128 characters of context instead of just one.\n",
    "\n",
    "Now we sample from it. Compare the result with the bigram's output in notebook 03 and the untrained gibberish in notebook 08. It is the same machinery; it has simply learned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3c82d99c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T09:29:16.904586Z",
     "iopub.status.busy": "2026-07-01T09:29:16.904498Z",
     "iopub.status.idle": "2026-07-01T09:29:21.299960Z",
     "shell.execute_reply": "2026-07-01T09:29:21.299576Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "SICINGHAM:\n",
      "My lord, you shall palt breate;\n",
      "Nor be neight your cousin y soverey to\n",
      "The you often us. A say light\n",
      "Farewell your most penfitly love\n",
      "Retuor fortune with merry grued choose\n",
      "Pent his -chost nonal!\n",
      "\n",
      "Second Maken:\n",
      "I shall bous coffpent the wearty unating.\n",
      "When that wear how is that?\n",
      "\n",
      "WARD:\n",
      "I do have you, Lord Aladies, 'tis, though thinks a bree of\n",
      "sleet from of your broughins lord.\n",
      "\n",
      "PAULINA:\n",
      "Lenford, that?\n",
      "\n",
      "BRUTUS:\n",
      "Master you I do not hence,\n",
      "Justiculza me felp in thy seaths,\n",
      "I fifthes i\n"
     ]
    }
   ],
   "source": [
    "context = torch.zeros((1, 1), dtype=torch.long, device=device)\n",
    "print(decode(model.generate(context, max_new_tokens=500)[0].tolist()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a80c3b6",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>torch.zeros((1, 1), dtype=torch.long, device=device)</code>: the prompt: one sequence containing one token, id 0 (newline). A neutral start.</li>\n",
    "<li><code>model.generate(context, max_new_tokens=500)</code>: 500 dice-rolls of the trained model, each fed back in.</li>\n",
    "<li><code>[0].tolist()</code>: take the first (only) sequence and convert ids to a plain list for <code>decode</code>.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "m9c1a",
   "metadata": {},
   "source": [
    "### Look inside: what the trained heads learned\n",
    "\n",
    "Notebooks 05 and 06 drew this exact picture for *untrained*, random heads, and every head looked alike. Now the model has trained. Recompute block 0's four attention maps on a real line of text and they have clearly specialised: one head stays on the diagonal (attend to the current character), others lean to earlier characters or lock onto the line's opening. Each head has learned a different way to gather context -- and this structure is what turns the gibberish into Shakespeare."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "m9c1b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T09:29:21.301169Z",
     "iopub.status.busy": "2026-07-01T09:29:21.301100Z",
     "iopub.status.idle": "2026-07-01T09:29:21.527784Z",
     "shell.execute_reply": "2026-07-01T09:29:21.527442Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 850x800 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Recompute block 0's attention on a real snippet, one map per head. Notebooks\n",
    "# 05-06 drew this for random weights; here the weights are trained.\n",
    "model.eval()\n",
    "snippet = \"First Citizen:\\nWe are\"\n",
    "ids = torch.tensor([[stoi[c] for c in snippet]], device=device)\n",
    "Tn = len(snippet); labs = [c.replace(\"\\n\", \"\\\\n\") for c in snippet]\n",
    "\n",
    "fig, axes = plt.subplots(2, 2, figsize=(8.5, 8))\n",
    "for H, ax in enumerate(axes.flat):\n",
    "    with torch.no_grad():\n",
    "        x = model.token_embedding(ids) + model.position_embedding(torch.arange(Tn, device=device))\n",
    "        blk = model.blocks[0]; xn = blk.ln1(x); h = blk.sa.heads[H]\n",
    "        k, q = h.key(xn), h.query(xn)\n",
    "        w = (q @ k.transpose(-2, -1)) * k.shape[-1] ** -0.5\n",
    "        w = w.masked_fill(h.tril[:Tn, :Tn] == 0, float(\"-inf\"))\n",
    "        A = torch.softmax(w, dim=-1)[0].cpu().numpy()\n",
    "    ax.imshow(A, cmap=\"viridis\")\n",
    "    ax.set_xticks(range(Tn)); ax.set_xticklabels(labs, fontsize=6)\n",
    "    ax.set_yticks(range(Tn)); ax.set_yticklabels(labs, fontsize=6)\n",
    "    ax.set_title(f\"block 0, head {H}\", fontsize=10)\n",
    "fig.suptitle(\"what the trained heads attend to (row = current char, col = the char it looks at)\", fontsize=11)\n",
    "plt.tight_layout(); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "m9c1c",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>model.eval()</code>: turn off dropout so the attention we read is the clean, deterministic version.</li>\n",
    "<li>For each of block 0's four heads it recomputes the attention by hand: embed the snippet, LayerNorm it, then <code>softmax(q @ k.T / sqrt(head_size))</code> with the future masked -- exactly the formula from notebook 05.</li>\n",
    "<li>Each heatmap row is a character; the bright cells along that row are the earlier characters it attends to.</li>\n",
    "<li>Unlike the near-identical random heads in notebook 06, these have specialised: compare the four -- diagonal (the current character), one-step-back, and longer-range -- each head learned a different job.</li>\n",
    "<li>Stack four such heads across four blocks and train for 3000 steps, and this learned structure is what turns gibberish into Shakespeare.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d811fe3",
   "metadata": {},
   "source": [
    "## Save the trained model\n",
    "\n",
    "We store the weights, the config, and the tokenizer, so that notebook 10 can load this exact model and explore sampling without retraining it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3bd02fa8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T09:29:21.529014Z",
     "iopub.status.busy": "2026-07-01T09:29:21.528938Z",
     "iopub.status.idle": "2026-07-01T09:29:21.555934Z",
     "shell.execute_reply": "2026-07-01T09:29:21.555569Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saved -> checkpoints/gpt_shakespeare.pt\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.makedirs(\"checkpoints\", exist_ok=True)\n",
    "torch.save({\"model\": model.state_dict(), \"config\": cfg, \"stoi\": stoi, \"itos\": itos},\n",
    "           \"checkpoints/gpt_shakespeare.pt\")\n",
    "print(\"saved -> checkpoints/gpt_shakespeare.pt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cb3c446",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>os.makedirs(\"checkpoints\", exist_ok=True)</code>: create the folder; the flag means \"fine if it already exists.\"</li>\n",
    "<li><code>model.state_dict()</code>: every learned weight, as a dictionary of tensors. This <i>is</i> the trained model.</li>\n",
    "<li><code>torch.save({\"model\": ..., \"config\": cfg, \"stoi\": stoi, \"itos\": itos}, \"checkpoints/gpt_shakespeare.pt\")</code>: bundle weights + config + tokenizer into one file, so notebook 10 can reload exactly this model without retraining.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75aec0c4",
   "metadata": {},
   "source": [
    "## Recap\n",
    "\n",
    "You trained a GPT that you built from scratch. The loss fell from about 4.2 to well below the bigram ceiling, and the samples look like Shakespeare because predicting the next character *well* forced the model to learn spelling, character names, and the shape of dialogue. That is the course's central idea, made real.\n",
    "\n",
    "Next, notebook 10 covers how to control the way it generates (temperature, top-k, and top-p), and offers a tour of what separates this from a frontier model."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (.venv)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}