{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dbbf515d",
   "metadata": {},
   "source": [
    "# 5. Self-Attention and a Tiny GPT\n",
    "\n",
    "Behind the Secrets of LLMs, crash course part 2\n",
    "\n",
    "The bigram model from notebook 4 only looked at one previous character and got stuck at a validation loss of about 2.5. In this notebook every position gets to look at all earlier positions through self-attention. We stack that into a Transformer and train a small GPT on Shakespeare.\n",
    "\n",
    "We go step by step:\n",
    "\n",
    "1. what the training data of a language model looks like (a context and the next token)\n",
    "2. averaging over the past, written as a matrix multiplication\n",
    "3. scaled dot-product self-attention with a causal mask, and why we divide by $\\sqrt{d}$\n",
    "4. multi-head attention, MLP, residual connections and LayerNorm, which together make a Transformer block\n",
    "5. training TinyGPT, generating text, and looking at its attention maps\n",
    "\n",
    "Time: about 60 minutes. It runs on a CPU with small settings (about 3 minutes of training). On a Colab GPU it is faster: Runtime > Change runtime type > T4 GPU, and the notebook picks bigger settings by itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d9f363f0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:23:11.210220Z",
     "iopub.status.busy": "2026-10-10T20:23:11.209982Z",
     "iopub.status.idle": "2026-10-10T20:23:13.478690Z",
     "shell.execute_reply": "2026-10-10T20:23:13.477453Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch 2.14.1+cu130 | device: cpu\n",
      "1,115,394 characters, vocabulary |V| = 65\n"
     ]
    }
   ],
   "source": [
    "import math, os, time, urllib.request\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "torch.manual_seed(1337)\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "print(\"torch\", torch.__version__, \"| device:\", device)\n",
    "\n",
    "URL = \"https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt\"\n",
    "if not os.path.exists(\"input.txt\"):\n",
    "    urllib.request.urlretrieve(URL, \"input.txt\")\n",
    "text = open(\"input.txt\", encoding=\"utf-8\").read()\n",
    "\n",
    "chars = sorted(set(text)); V = 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]\n",
    "decode = lambda ids: \"\".join(itos[i] for i in ids)\n",
    "\n",
    "data = torch.tensor(encode(text), dtype=torch.long)\n",
    "n = int(0.9 * len(data))\n",
    "train_data, val_data = data[:n], data[n:]\n",
    "print(f\"{len(text):,} characters, vocabulary |V| = {V}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bfdc0e0",
   "metadata": {},
   "source": [
    "## 1. What does a language model train on?\n",
    "\n",
    "We cut random windows of `block_size` characters out of the text. The target is the same window moved one character to the right. So one window of length $T$ already holds $T$ training examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b0109507",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:23:13.481322Z",
     "iopub.status.busy": "2026-10-10T20:23:13.480485Z",
     "iopub.status.idle": "2026-10-10T20:23:13.486772Z",
     "shell.execute_reply": "2026-10-10T20:23:13.485668Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "context            'F'  ->  next 'i'\n",
      "context           'Fi'  ->  next 'r'\n",
      "context          'Fir'  ->  next 's'\n",
      "context         'Firs'  ->  next 't'\n",
      "context        'First'  ->  next ' '\n",
      "context       'First '  ->  next 'C'\n",
      "context      'First C'  ->  next 'i'\n",
      "context     'First Ci'  ->  next 't'\n"
     ]
    }
   ],
   "source": [
    "block_size = 8\n",
    "x = train_data[:block_size]\n",
    "y = train_data[1:block_size + 1]\n",
    "for t in range(block_size):\n",
    "    print(f\"context {decode(x[:t + 1].tolist())!r:>14}  ->  next {decode([y[t].item()])!r}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7ee6cf48",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:23:13.488455Z",
     "iopub.status.busy": "2026-10-10T20:23:13.488282Z",
     "iopub.status.idle": "2026-10-10T20:23:13.497492Z",
     "shell.execute_reply": "2026-10-10T20:23:13.496573Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inputs  x: torch.Size([4, 8]) \n",
      " tensor([[53, 59,  6,  1, 58, 56, 47, 40],\n",
      "        [49, 43, 43, 54,  1, 47, 58,  1],\n",
      "        [13, 52, 45, 43, 50, 53,  8,  0],\n",
      "        [ 1, 39,  1, 46, 53, 59, 57, 43]])\n",
      "targets y: torch.Size([4, 8]) \n",
      " tensor([[59,  6,  1, 58, 56, 47, 40, 59],\n",
      "        [43, 43, 54,  1, 47, 58,  1, 58],\n",
      "        [52, 45, 43, 50, 53,  8,  0, 26],\n",
      "        [39,  1, 46, 53, 59, 57, 43,  0]])\n"
     ]
    }
   ],
   "source": [
    "def get_batch(split, batch_size, block_size):\n",
    "    d = train_data if split == \"train\" else val_data\n",
    "    ix = torch.randint(len(d) - block_size - 1, (batch_size,))\n",
    "    x = torch.stack([d[i:i + block_size] for i in ix])\n",
    "    y = torch.stack([d[i + 1:i + block_size + 1] for i in ix])\n",
    "    return x.to(device), y.to(device)\n",
    "\n",
    "xb, yb = get_batch(\"train\", 4, 8)\n",
    "print(\"inputs  x:\", xb.shape, \"\\n\", xb.cpu())\n",
    "print(\"targets y:\", yb.shape, \"\\n\", yb.cpu())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "906e82b4",
   "metadata": {},
   "source": [
    "## 2. Letting tokens talk to each other: averaging the past\n",
    "\n",
    "The simplest way for token $t$ to use its context is to average the vectors of all tokens up to $t$. It must not see the future, because the future is what it has to predict:\n",
    "\n",
    "$$\\bar{x}_t = \\frac{1}{t}\\sum_{s \\le t} x_s$$\n",
    "\n",
    "Written with a lower-triangular weight matrix $W$, this is just $\\bar{X} = W X$. The same $W$ also comes out of a softmax over a masked score matrix: scores of $-\\infty$ in the future turn into a weight of 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7de5e094",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:23:13.499345Z",
     "iopub.status.busy": "2026-10-10T20:23:13.499014Z",
     "iopub.status.idle": "2026-10-10T20:23:13.532542Z",
     "shell.execute_reply": "2026-10-10T20:23:13.532143Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1.0000, 0.0000, 0.0000, 0.0000, 0.0000],\n",
      "        [0.5000, 0.5000, 0.0000, 0.0000, 0.0000],\n",
      "        [0.3333, 0.3333, 0.3333, 0.0000, 0.0000],\n",
      "        [0.2500, 0.2500, 0.2500, 0.2500, 0.0000],\n",
      "        [0.2000, 0.2000, 0.2000, 0.2000, 0.2000]])\n",
      "loop == matmul == softmax: True True\n"
     ]
    }
   ],
   "source": [
    "B, T, C = 1, 5, 2\n",
    "x = torch.randn(B, T, C)\n",
    "\n",
    "# version 1: python loop\n",
    "xbow1 = torch.zeros_like(x)\n",
    "for t in range(T):\n",
    "    xbow1[:, t] = x[:, :t + 1].mean(dim=1)\n",
    "\n",
    "# version 2: matrix multiplication with a row-normalised lower-triangular matrix\n",
    "W = torch.tril(torch.ones(T, T))\n",
    "W = W / W.sum(dim=1, keepdim=True)\n",
    "xbow2 = W @ x\n",
    "\n",
    "# version 3: softmax over masked scores (all scores 0 here -> uniform weights)\n",
    "scores = torch.zeros(T, T).masked_fill(torch.tril(torch.ones(T, T)) == 0, float(\"-inf\"))\n",
    "W3 = F.softmax(scores, dim=-1)\n",
    "xbow3 = W3 @ x\n",
    "\n",
    "print(W3)\n",
    "print(\"loop == matmul == softmax:\", torch.allclose(xbow1, xbow2), torch.allclose(xbow2, xbow3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb5344ec",
   "metadata": {},
   "source": [
    "Plain averaging treats every earlier token as equally important. Self-attention lets the weights depend on the data.\n",
    "\n",
    "## 3. Scaled dot-product self-attention\n",
    "\n",
    "Every token makes three vectors from its embedding $x$, each with its own learned linear map:\n",
    "\n",
    "* a **query** $q = xW_Q$: what am I looking for?\n",
    "* a **key** $k = xW_K$: what do I have to offer?\n",
    "* a **value** $v = xW_V$: what do I pass on if someone attends to me?\n",
    "\n",
    "$$\\text{Attention}(Q,K,V) = \\text{softmax}\\!\\left(\\frac{QK^\\top}{\\sqrt{d_k}} + M\\right)V, \\qquad M_{ts} = \\begin{cases}0 & s \\le t\\\\ -\\infty & s > t\\end{cases}$$\n",
    "\n",
    "The score $q_t \\cdot k_s$ is large when what token $t$ is looking for matches what token $s$ has. $M$ is the causal mask."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "511cf064",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:23:13.536579Z",
     "iopub.status.busy": "2026-10-10T20:23:13.536411Z",
     "iopub.status.idle": "2026-10-10T20:23:13.744211Z",
     "shell.execute_reply": "2026-10-10T20:23:13.743183Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfkAAAHOCAYAAACbyXDxAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAX8NJREFUeJzt3XdYFFfbBvB7aUsvAooUQbAgNuxir9ijUWPvRk3UqNHEqK+KSYzGlhijqWpMTIw9+TTGTjRiiQY7WFEEREE6SN893x++zOsKKLALy+7ev1xzXdkzM2eeGcBnT5kZmRBCgIiIiPSOkbYDICIiovLBJE9ERKSnmOSJiIj0FJM8ERGRnmKSJyIi0lNM8kRERHqKSZ6IiEhPMckTERHpKSZ5IiIiPcUkT0REpKeY5ImIiPQUkzwV6dSpU0hKStJ2GBqRlpaGkydPQpde05CUlITXXnsNwcHB2g6F1HTp0iVERUVpNYZ9+/Zh4MCByMzM1GocVPGY5CsJhUKBuLg45OTkSGVKpRJxcXHIzs4ut+Pm5eUhLi4OeXl5UtmVK1fQoUMHvPfee+V23IoUFBSETp064dSpU6Xa7/bt27CxscEff/zx0u2EEIiLi9PoP6Cff/45Dh06hMaNG2usTnV06dIFw4cP13YY5S4lJUWjX26zsrLQunVrDB48WGN1lkR8fDxsbGzwyy+/AAAaNWqE33//Hd98802FxkHaxyRfSURGRsLFxUUloTx58gQuLi7YsWNHuR33/PnzcHFxwfnz56UyPz8/rFixAjNmzCi341akyZMnY9myZWjRokWp9hNCICMjAwqF4qXbZWZmwsXFBT/88IM6YUoUCgW+++479O3bF46OjhqpU11ZWVnl+mWzshg9ejT69++vsfosLCywfv16LF26VGN1lkTB725+fj4AwMvLCx06dMBXX31VoXGQ9ploOwBDk5eXB1NTU43Vp1AoYGxs/MrtlEoljIxK9p3O1NQUc+fO1UhdpdlWXcVdi3r16qFevXrF7lcR51PSnxPwbKgkPj4eY8aMKXab7OxsyOVyyGQylfL8/HyYmLz6z7ok51HSmIUQheIoTmZmJiwtLV9ZVt7U+b3MysqCubm5yjkLIaBQKIq89pMmTVI7Fk38nY8ZMwYTJ07EpUuX0KRJk1fWRfqBLfkKkJubi4ULF8Ld3R1mZmaws7PDpEmTkJWVBQBYvny51MocP348nJ2d8cEHH8DPzw8AMH36dDg7O+PMmTNSnVu2bIG/vz/Mzc3h5uaGefPmqXQX79+/H87Ozrh+/ToGDRqEKlWqwMHBAdOmTZNaZO+++y769OkDAOjTpw+cnZ3x6NEj5OTkwNnZGd9++63KeezatQvNmjWDubk5atSogbfffhvp6ekq2zg7O2PTpk1YvHgxfHx8YGFhgU6dOuHWrVvFXp+0tDS4uLhg5cqVKuWdOnWCu7u7yhDGrl27pPMqsG7dOjRo0AByuRw1atTAJ598gtzcXGn9jz/+CGdnZ6SlpUlliYmJGDlyJJycnGBlZYXBgwfj6tWrcHZ2LjQO/vTpU0yZMgUuLi6wsbHBoEGDEBcXBwDYtGkTPD09AQAffPABnJ2dceTIEQDA48ePMWrUKDg4OMDMzAz169fH77//Xux1KHDkyBFYWFhIPxsA+Pbbb+Hi4oKrV6+iVatWsLS0xNWrVwEA4eHh6NOnDywsLGBmZoZ69eoV6v3p1q0bZs2ahS1btqBJkyZSPMePHy90/G+//Rb16tWDmZkZfH19i50XcPXqVXTr1g12dnaoUqUK+vbti7t376psM2DAAIwfPx47d+6Et7e3dK2FENi6dSsaNGgAKysr1KlTByEhIa+8Ni+aPHkyOnfuXKg8ICAAb7/9donPPykpCc7Ozjh8+DDOnTsHZ2dnaf9Vq1ahbt26OHfuHJo2bQpLS0tpjP3ixYvo3r07zM3NYWZmhkaNGmH//v0qsbRs2RLvvvuu9Ll9+/b44IMP8P3336Nx48aQy+Vo3Lgx/v7770LnUfA3Z2FhARcXF8yaNUvl9xhQ/f20sLBAjx49pN/P5w0aNAhGRkbS7ycZCEHlbtSoUcLIyEhMnTpV7Nq1SyxYsEBYWVmJiRMnCiGEuH79uvjyyy8FADFnzhyxe/du8c8//4jvv/9eABDTpk0Tu3fvFk+ePBFCCLFixQphZGQk3nnnHbF3717xySefCGtrazFkyBDpmLt37xYARIsWLcTChQvF7t27xeTJkwUAERQUJIQQ4t9//xUff/yxACA+/vhjsXv3bpGZmSmys7MFALF27Vqpvq+++koAECNHjhQ7d+4Uq1atElWqVBGNGjUSeXl50nYARIMGDcTrr78utm/fLlavXi3s7OxEo0aNhEKhKPYadejQQbRt21b6HB8fL2QymTAxMRF//fWXVD5mzBjh5uYmfX7//feFqamp+OCDD8Rvv/0mFi1aJORyuZg6daq0zTfffCMAiJSUFCGEELm5uaJu3bqiSpUqYvXq1WLnzp1i6NChwt/fXwAQhw4dEkIIcfPmTQFA1K5dW7z11lti165dYuHChcLU1FQMGDBACCHE3bt3xdatWwUAMXHiRLF7927x6NEjIYQQAQEBombNmuKrr74S+/fvF4MGDRLGxsbiwoULL/196d69uwgICFApW7t2rZDJZKJ+/fpi7ty5YtOmTeLJkyciJiZG2NnZiVq1aokVK1aIbdu2iV69egljY2Nx7tw5af/mzZuL+vXrixYtWoiffvpJbNq0Sfj4+AhbW1sRFxcnbbdmzRoBQIwaNUrs2rVLrFixQnh4eAg3NzfpnIUQ4uLFi8Lc3FwEBASILVu2iO+++040btxY2NjYiLt370rbderUSdSvX18MHDhQ/Pbbb2LBggXCwsJCTJ48WTRp0kRs375drF+/Xnh7ewtXV1eRnZ390mvzomHDhgl/f/9C5b6+vmLUqFElPv+cnByxe/du0axZM+Hr6yt2794tzp8/L4QQYsmSJcLCwkL4+vqKhQsXik2bNom0tDRx+/ZtYWFhIfz8/MSaNWvE1q1bRefOnYWZmZkICwuTjl2rVi3x5ptvSp8bNGggGjRoIAICAsTWrVvF999/Lzw9PUWVKlVEYmKitN0333wjZDKZmDRpktizZ49YtWqVcHBwEIGBgSrn2qFDB2FhYSH9DU+aNEnUr19fABBbtmxR2bZu3bpi8ODBpbrGpNuY5CvAn3/+KXbu3KlSNmHCBFG9enXp8927dwUAsXv3bqns8ePHhf5Qnzx5IqytrcWyZctU6tu+fbsAIP3DXpDkV69erbJdly5dRKNGjaTPISEhAoAICQmRyl5M8ikpKcLBwUGMHj1apa4LFy4IAGL9+vVSGQAREBAglEqlVFbwBeH27dvFXqPVq1cLY2NjkZycLIQQ4ueffxaenp6ie/fuYsGCBUIIIZRKpahWrZp4++23hRBC3Lt3T5iamorvvvtOpa7169cLmUwmHe/FJF8Qz5kzZ1T269+/f5FJfty4cSrbzZgxQ5iYmIjc3FwhhBAZGRmFrkNSUpIAINasWSOV5eXliR9++EE8fPiw2OsghBDu7u5i0qRJKmVr164VAMSePXtUyhMSEsSXX34pIiMjpbLU1FRhbm4uPvzwQ6msefPmwtHRUboGQghx/vx5AUBs27ZNCCFEWlqasLe3FyNGjFA5xoEDBwQAlSTfpUsXUbt2bZGVlSWVpaWlCVdXV5Uk0qlTJ1GtWjWV7WbMmCEAqCTC33//XQAQly5deum1eVFpkvyrzl8IIfr27SvatWunUteSJUsEAHH8+HGV8sePH4u1a9eKx48fS2WxsbHC2NhYfPHFF1JZUUnexcVFZGRkSGV///23ACD27t0rhBAiPT1dODk5iblz56oc89ChQyq/o/v37xcACv37MmnSpCKT/ODBg0X9+vULXS/SX+yurwC9evXCG2+8AaVSiaioKJw8eRKPHj3Co0eP8PTp01LVdebMGWRkZKBz58548OCBtDRp0gQmJia4ePGiyvbdu3dX+dy8eXNERkaW6pihoaFITk5W6f4sqKtVq1Y4duyYSnm3bt1UxiubN28OAC897muvvQaFQiHVdeTIEXTt2hWdO3eWyi5fvoy4uDi89tprAIC//voLCoUC7dq1U7kWrVu3hhACly9fLvJYp06dQv369REQEKBSPn78+CK3L+oa5ufn4+HDh8Wej52dHapXr44NGzZg165dePr0KUxMTDBu3Di4uroWux/wbCihatWqJYrF0dER06dPh6enJzIzMxEeHo5Dhw7B1NQUd+7cUdm2ZcuWsLOzkz43bdoURkZG0s/l2rVrSElJwZtvvqmyX+/evVXiyc3NxcmTJzF+/HiYm5tL5TY2Nhg9ejSOHj2qsn+DBg1Utis4/+fnSRQMeRTVzawprzr/lzExMUGnTp1UyqpVq4aZM2eiWrVqyMjIwPXr1xEcHAxjY+NC1/5FAQEBsLKykj6/+Ddy8eJFJCQkoGvXriq/23Xq1IGNjY30d/7333/D3t4egwYNUqm/uN9lZ2dnJCQkvPJ8SX9w4l0FuHz5MhYtWoTg4GBkZmbCxsYG1apVK1NdERERAFAoQRV48R+X5/8hAQAzMzMolcoyHbNmzZqF1vn4+ODKlSuvPCaAlx63du3a8PX1xdGjRzF48GAcPXoUq1atgo+PDxYuXIiUlBQcPXoU1tbW0hhsREQElEqlNHfhRcX9QxsZGQkPD49C5W5ubkVuX9z5vGzWvZGREfbt24cpU6ZgyJAhMDExQZs2bTB9+nS88cYbxe4HADk5OZDL5UWuKzj287788kt8/fXXuHnzJoQQ8Pb2LnIi3IvnYWxsDCMjI+nnUpBgatSoUWjf56/XgwcPoFAoiv19SE1NRUJCApycnACg2Immz8dY0ol76njV+b+MiYlJoQltQgisXLkSmzZtkuYi1K5du0QT5F71N1LwN9ejR48i9y/43Y6MjIS7u3uh2Ir6/QYAc3NzaS4QGQYm+XKWkZGBTp06oVatWti0aRM6duyI6tWrY/369XjnnXdKXZ+zszOAZ63rom6vsrGxUTvmFxW04pKTk+Hi4qKyLikpqcxfWF702muvYc+ePbhx4wYeP36Mrl27wtnZGba2tjh58iSOHTuGHj16SAnQ2dkZJiYmCA8PLzL52dvbF3kcNze3QhPEAM23Ips3b47Q0FDcu3cPJ0+exMaNGzFkyBBs3boVo0aNKnY/BwcHJCYmlugY33//PWbMmIF33nkHGzduROPGjWFlZYUGDRqUOt6Cn3NiYiJ8fHxU1iUmJkqJ4/nfhxclJSXB1NS02GtfHopK0s8/96G8rF69GgsWLMCcOXPwxhtvoEGDBrCwsIC7u7vadRf8nf/1119Ffpkq+JJQtWrVIicsFvf7k5SUVGluy6SKwe76cnbp0iWkpqZi7dq1GDZsGKpXrw6g+FZmUf9gPV9W8HCU27dvw9PTU1qqVq2KpKQkODg4lCnOl7VmGjduDJlMVuihMCkpKQgJCdHY7Tj9+vVDREQEdu7ciaZNm8LFxQXGxsYIDAzEyZMncfbsWfTr108lrvz8fDx48EDlWtjZ2SEjI0Ola/Z5LVu2xJUrVwp15xc8OKSsnr+G2dnZOHHiBDIzM+Ht7Y3x48fjxIkTqFKlyitnN/v4+ODGjRslOuaJEydQv359rFu3Dm3atIGVlRVycnLK9IQ1Pz8/GBkZ4c8//1Qpv3nzJh48eCB9trOzg5eXV5EPCdq/fz8aNWpUotv4NMHFxQXR0dHS/eDAsy8fz8dbWiXt6Tpx4gQCAgKwcuVKtGjRAhYWFkhLS9PIl8WGDRtCJpPh5s2bKr/brq6uiI+PR5UqVQA8Gwp59OgRLl26pLL/4cOHi6w3LCwMtWvXVjs+0h1M8uWsoOt0165dSE5OhkKhwO7du7Fx40aV7apVqwaZTIZjx44hJSUFCoUCVapUgZmZGYKDg5GcnIz8/Hw0bNgQr7/+OmbNmoUjR44gPz8f0dHRGDt2LJo2bYrQ0NBSxVfQMj98+DBSU1OLfPSrl5cXxo4di48//hj79u1DXl4eHjx4gKFDhwIA5syZU8aroyogIABOTk5Yv349evfuLZX37t0bP/30EzIzM1VuK+vcuTPat2+PSZMmISQkBEqlEvfv38fQoUPRuHFjqcvzRdOmTYO7uzsCAwPx2WefYefOnRg9erR0S1ppWVlZwcbGBidOnEBSUhJyc3Nx48YNdO7cGbNmzUJSUhLS09Oxc+dOpKamvvIpdq1bt8Y///yjkriKU6tWLdy/f1+an5CYmIgJEyaUeq4H8GysfOTIkVi9ejX27t2LvLw8REREYOzYsbC2tlbZdsmSJfjzzz+xbNkypKenIzk5GfPnz8fp06exZMmSUh+7KD///PMrHyLTvn17JCcnY+bMmXj06BFu3bqF0aNHF/sF71VcXFwQFhaGe/fuvfIa1qpVC+Hh4Thz5oz0dMrRo0eXejisKJ6enhg3bhwWLFiA//u//0NeXh4ePXqEt956Cy1btsRff/0F4NnDe1xcXDB27FjcuHEDCoUCBw8exIYNGwrV+fTpU1y5cqXYoT7SU9qd92cYli9fLoyNjYWRkZGQy+WiZs2a0ozd52fYzp07VwAQAMSBAweEEEJ8+OGHQiaTCQBix44dQgghEhMTxYABAwQAYWJiIgAIKysr8fXXX0t1Fcyuf/52JiGEWLhwobC2tlYpGzt2rHTc0NDQIm+hS01NFUOGDFE5ppubmzhx4oRKXQDEp59+qlJ2+fJllRnBL1MQy9mzZ6Wyx48fC5lMVmjWsxBCPHz4UHTt2lUlLnt7e5UZ0y/Ori/Yb9CgQaJKlSrC0tJSDB48WLrT4MXZ9b///rvKMQvuZHj+2q5evVoYGRkJAGLTpk1CCCE++eQTYWpqKt0KCEAMGzZMmpVfnODg4ELXq2B2/Yu3mKWkpIimTZsKAMLCwkLIZDLxzjvviGbNmhWaXV7UrVMmJiZi6dKl0ufExEQRGBiocj0XL14sunXrpjK7XqlUik8++USYmJgIIyMjIZPJhLm5ucodBkI8m13fs2dPlbJPP/1UvPhPT1G/I40bNxbdunV76bUSQog333xT+v01MzMTK1euFK1bty7T+V+9elU4OTkJAKJ79+5CiGez683NzQvtGxcXJ+rVqycACEtLSyGTycSiRYtErVq1xPTp06Xtippd/3xsQgiRn59f6G6Y1NRUMXLkSJWfhbm5uVi5cqXKvmfPnhVubm7SdlZWVuLgwYOFZtdv27ZNyGQycevWrVdeU9IfMiF06K0dOiwiIgKhoaHw9vZG06ZNkZqaitjYWNSrV09l0kxERAQePnyIhg0bSl3vkZGRiIqKgp+fnzSZCQDu3buHq1evwtzcHK1bt1YZB01LS0N0dDRq166tMl4dHx+PxMTEQk+Au3nzJp48eQJ/f39YW1sjPDwcLi4uhcbvIiIicPXqVbi6uqJx48Yqs6aBZ92B1apVU4kzOzsbERER8PT0LNQifFFiYiIeP35c6LrcvHlTmrH+IiEE7ty5g2vXrsHW1hYBAQEqx0lOTi7yWj+/v0wmw+nTp9GuXTucPHkSHTp0QG5uLu7cuYMaNWqozHVITU1FTExMoWsbHR2N+/fvw9fXVxq3fvToES5cuACFQoGGDRuiVq1aLz1/4Fl3sbe3N9q2bSsNIRRcFz8/v0KT1JRKJU6dOoUnT56gbdu2qF69OiIiIiCXy6Xx4YiICJiZmRWakBUWFoaqVatKY8AF1yMsLAw3b95EvXr1UL9+fURGRsLIyKjQpLwnT57g33//hampKZo1a1ZouCgyMhIymUyaPQ8ACQkJiIuLQ/369aWyF39HlEolrK2t8eGHH+L9999/5TWLiorCw4cP4e/vDwsLC9y7dw9mZmZlOv/09HRcvXoVDg4O8PPzw5MnT/DkyZMiJ3jm5+fj5MmTSE1NRfv27eHs7Iw7d+7A2tpaZWjOyspKuqvg7t27MDc3LzR2HxYWVuTf3IMHD3DlyhWYmJigZcuWKn9bBbKyshAaGoqEhAS0adMGTk5OuHHjBtzc3KR/F3r37g0jI6NXvouB9AuTPBmcuLg4zJ07F3PnzlVJNLNnz8batWuRlJRUoRPHivLtt9/inXfeQWRk5CtvudNHkZGRqFmzJi5fvlxpXtKjy27duoV69erhyJEj6Natm7bDoQrE2fVkcIyMjHDmzBm0bt0ar7/+OqpWrYrQ0FCcOHECixYt0nqCB4AJEyYgJycHiYmJBpnkb968iWrVqqFRo0baDkUvpKenY/369UzwBogteTJIaWlp2LhxI0JCQpCeng4PDw8MHz680MNmSDuys7ORmZkpzSInorJhkiciItJTvIWOiIionIWFhSEgIAA1a9Ys8kFSBbZv345mzZqhSpUq6NWrF+7du6fWcZnkiYiIytH27dvRunVr1KhRA5GRkcU+S2Hfvn0YN24c3n77bQQHB8PFxQVt2rQp9Hrh0mB3PRERUTl66623MHjwYDg7O8Pf3x8JCQlFPl64bdu26Ny5s/QQKKVSCV9fX0ybNg0zZ84s07H1JskrlUrExsbCxsamQl52QUREmiWEQHp6OlxdXYt8poUmZGdnIzc3VyN1FTxj43lyubzQC6YUCgWMjY1x5cqVYpN8VlYWLC0tcfHiRZVHhc+dOxc3btzA/v37yxSj3txCFxsbW+ybl4iISHdER0dr5EU/L8rOzkZNT2s8ji/+DZKlYW1tjYyMDJWyoKCgQo92LsmbCQteXf3iA6dq1KhR6PXNpaE3Sb7giWQPLnrB1lq3phq8XqehtkMgItK6fOQhBH+Wy9s0ASA3NxeP4xW4H+oJWxv18kRauhI1mz1AdHQ0bG1tpfLiXhP9KpmZmQBQ6Cmi5ubmZXoXRQG9SfIFXSa21kZq//Aqmoms6PdtExEZlP8OHpf3kKuV9bNFHYr/xmpra6uS5Muq4KFX8fHxKq8Xjo+PV6tXQ7eyIRERkR5ycnJC1apVcfLkSZXykydPFvnehJJikiciIoOihNDIoq4HDx7g+++/l17xPXnyZHz66adISkoCABw5cgTHjx/H5MmTy3wMJnkiIjIoSg39p67Nmzdj8uTJePDgAQBg3rx5qFmzJmrUqIGGDRuid+/eWLNmjVrvcNCbMXkiIqLKrFatWggJCYGdnR2AZ7fH9enTB15eXgAAKysrHDhwANeuXUNkZCSaN28ONzc3tY7JJE9ERAZFIQQUaj4ipiz7W1lZoW3btiqfW7ZsqbKNkZERGjdurLFXLDPJExGRQdHEmLomxuQrAsfkiYiI9BRb8kREZFCUEFAYSEueSZ6IiAwKu+uJiIhI57ElT0REBkVbs+u1gUmeiIgMivK/i7p16AImeSIiMigKDUy8U3f/isIxeSIiIj3FljwRERkUhfjfq2LVqUMXMMkTEZFBMaQx+UrTXa9UKrF06VK0atUKHTt2xIYNG7QdEhERkU6rNC35yZMn48SJE1i6dCmysrIwd+5cJCQkICgoSNuhERGRHlFCBgVkatehCypFko+MjMSWLVtw8eJF6b25jo6OGDVqFGbPng0bGxstR0hERPpCKZ4t6tahCypFd/3Bgwfh6+srJXgA6N27N4yMjHDy5Mki98nJyUFaWprKQkRERP9TKZJ8TEwMfHx8VMpMTExQo0YNxMTEFLnP8uXLYWdnJy0eHh4VESoREek4xX+769VddEGlSPKpqamwsrIqVG5lZYXU1NQi95k/fz5SU1OlJTo6urzDJCIiPWBISb5SjMlXr14dt2/fLlT+5MkTuLq6FrmPXC6HXC4v79CIiEjPKIUMSqHmxDs1968olaIlX6dOHYSGhiIvL08qi4uLQ2RkJGrXrq3FyIiIiHRXpUjyr732GoyMjLB+/XqpbNmyZfD19UXr1q21GBkREekbdtdXMLlcjs2bN2PYsGHYu3cvsrKycP/+fRw4cEDboRERkZ5RwAgKNdu4Cg3FUt4qRZIHgH79+iEsLAzBwcGQy+Xo2rUrXFxctB0WERGRzqo0SR4AvLy8MGHCBG2HQUREekxoYOKd0JGJd5UqyRMREZU3TYyp68qYfKWYeEdERESax5Y8EREZFIUwgkKoOfFOR55dzyRPREQGRQkZlGp2ZCuhG1me3fVERER6ii15IiIyKIY08Y5JnoiIDIpmxuR1o7ueSZ6IiAzKszF5NV9QoyMteY7JExER6Sm25ImIyKAoNfDsel2ZXc8kT0REBsWQxuTZXU9ERKSn2JInIiKDooSRwTwMh0meiIgMikLIoFDzLXLq7l9R2F1PRESkp/SuJT/3UVOYpZtqO4xSyenlr+0QykR+8IK2QyAiKjWFBmbXK9hdT0REVPkohRGUas6uV3J2PREREWkTW/JERGRQ2F1PRESkp5RQf3a8UjOhlDsmeSIiMiiauU9eN0a7dSNKIiIiKjW25ImIyKBo5tn1utFGZpInIiKDwvfJExERkc5jS56IiAwKu+uJiIj0lGbuk9eNJK8bURIREVGpsSVPREQGRSlkUKr7MBwdedUskzwRERkUpQa66/kwHCIiItIqtuSJiMigaOZVs7rRRmaSJyIig6KADAo1H2aj7v4VhUmeiIgMiiG15CtllHl5eVi5ciXeffddpKenazscIiIinVTpWvKRkZEYOnQoYmNjERMTg3nz5sHGxkbbYRERkZ5QQP3udoVmQil3la4lP3fuXDRv3hy///67tkMhIiI9VNBdr+6iCypdS3758uXw8fFBWFjYS7fLyclBTk6O9DktLa28QyMiItIple6riI+PT4m2W758Oezs7KTFw8OjnCMjIiJ9UPCCGnWXslAqlVAoSt7Zr1AokJeXV6ZjAZUwyZfU/PnzkZqaKi3R0dHaDomIiHSA+O/75NVZRCnH9LOzszF+/Hg4ODjA3t4eQ4cOfenE8ocPH6J///6wtLSElZUVAgMDce/evVKfq84meblcDltbW5WFiIioMpo4cSIuXbqEU6dO4fz584iJicGQIUOK3X7UqFHIzMzE33//jfPnz8PS0hKvv/56qY9b6cbkiYiIypMm3yf/4nwwuVwOuVyuUhYTE4MdO3bg33//RaNGjQAAv/zyC7y9vXH9+nU0aNBAtW6FAqdOncJff/2FVq1aAQCWLVuG+vXrIzExEY6OjiWOU2db8kRERGVR8BY6dRcA8PDwUJkftnz58kLHO336NNzc3ODv7y+VeXl5oUGDBjh16lSh7Y2NjdG0aVOEhoZKZaGhofDx8SlVggfYkiciIiqz6OholeHiF1vxwLOWvLu7e6Fyd3d3xMTEFFnvTz/9hDfeeAPbt2+HXC5HTEwMdu3aVer4Km1L3tHREe+99x4sLS21HQoREekRxX9fNavuAqDQ3LCiknxubi5MTAq3qU1NTVVuBX/e1q1bER8fj+bNm6Np06bIysrCxo0bS32ulbYl7+LiglWrVmk7DCIi0jPPd7erU0dJubm5IS4urlD548eP0blz50Ll//77L1asWIGwsDDUrVsXADBnzhzUrVsXffv2Re/evUt87ErbkiciIioPShhpZCmpxo0b4/bt2yq3eiclJeHSpUvSRLznhYWFoVq1alKCB5517fv4+OD69eulOlcmeSIionLUuHFjtG7dGrNmzUJubi7y8/Px3nvvwcfHR2rJHzx4EL/88gsAoEWLFoiLi8MPP/yA7Oxs5OXlYdeuXbhx4wYCAgJKdexK211PRERUHhRCBoWa3fWl3f/XX39Fjx494OjoCCMjI9jb2+PQoUOQyZ7Vs2rVKkRGRmLkyJHw8/PDN998g1mzZmH69OkwMTFBfn4+li9fjvbt25fquEzyRERkUCp6TB4APD09ER4ejrCwMCgUCjRs2BDGxsbS+r1796pMwnvzzTcxbNgwafv69evDzs6u1HEyyRMREVUAIyMjNGzYsMh19vb2hcqsra2lh+GUFZM8EREZFKGBV8UKvmqWiIio8lFABkUpXzBTVB26QDe+ihAREVGpsSVPREQGRSlKP3GuqDp0AZM8EREZFKUGxuTV3b+i6EaUREREVGpsyRMRkUFRQgalmhPn1N2/ojDJExGRQdHGE++0hUmeiIgMCsfkiYiISOfpXUv+8Bl/GJmbazuMUvHKzdN2CGWSOqq1tkMoM7ufz2k7BCLSEiU08Ox6jskTERFVPkIDE++EjiR5dtcTERHpKbbkiYjIoGjjVbPawiRPREQGhbPriYiISOexJU9ERAaF3fVERER6ypAea8vueiIiIj3FljwRERkUdtcTERHpKSZ5IiIiPWVISZ5j8kRERHqKLXkiIjIohtSSZ5InIiKDIqD+LXBCM6GUO3bXExER6Sm25ImIyKCwu56IiEhPGVKSZ3c9ERGRnqpULfno6GgcOnQIOTk56NKlC/z8/LQdEhER6Rm25LXg8OHDqFevHnbv3o0dO3bA398f3333nbbDIiIiPVOQ5NVddEGlSfLvvPMOFi1ahMOHD+PUqVP49ddfMWvWLOTm5mo7NCIiIp1UKbrrlUolRo4ciVGjRkllTZo0QVZWFmJjY+Hl5VVon5ycHOTk5Eif09LSKiJUIiLScULIINRsiau7f0WpFC15IyMjBAUFwc3NTSrbtWsXPD094eHhUeQ+y5cvh52dnbQUtx0REdHzCt4nr+6iCypFkn/RuXPnsGTJEqxfvx7GxsZFbjN//nykpqZKS3R0dAVHSUREusiQxuQrRXf98+7evYsBAwZg4cKF6Nu3b7HbyeVyyOXyCoyMiIhIt1SqJP/o0SMEBgZi8ODB+M9//qPtcIiISA8Z0ph8pUnyKSkp6NGjB9q1a4cvv/xS2+EQEZGeMqT75CtFks/Ly0Pfvn3x6NEjTJ06FZs3b5bWde7cGd7e3lqMjoiISDdViiSfkZEBCwsL+Pv7Y8+ePSrrfHx8mOSJiEhj2F1fwRwcHHD06FFth0FERAZAaKC7XleSfKW8hY6IiIjUVyla8kRERBVFABBC/Tp0AZM8EREZFCVkkKn5xDo+8Y6IiIi0ii15IiIyKJxdT0REpKeUQgYZH4ZDRESkf4TQwMQ7HZl5xzF5IiIiPcWWPBERGRSOyRMREekpQ0ryanXXZ2Rk4Mcffyxy3fHjx/HXX3+pUz0RERGpQa0kn5iYiPfee6/IdT/99BNOnjypTvVEREQaV/CqWXUXXVDm7vqWLVsiKSkJycnJqFevnsq6zMxMxMbG4tSpU2oHSEREpEmGNLu+zEn+3XffRWxsLJYsWYJ58+aprDM2NkaLFi1Qt25dtQMkIiKisilzkh8+fDhSUlKQm5uLsWPHajImIiKicvOsJa/uxDsNBVPO1Jpdb29vj/nz52sqFo2o/WMyTIzl2g6jVCKGO2o7hDLx3pGs7RDKLHlka22HUCZ2v5zTdghEOo+z64mIiEjn8T55IiIyKALqvw9eR3rrmeSJiMiwGFJ3vUaS/PXr1xEWFobs7GyV8ubNm6N+/fqaOAQREZFmGFBTXu0kP2vWLHzxxRdwdHSEs7Ozyrq5c+cyyRMREf1XRkYGlEolbG1tS7R9Xl4eEhISUL169TIdT62Jd48ePcIXX3yBb7/9FnFxcbhx44bKMn78eHWqJyIi0rz/dters6CU3fVpaWno168fHBwc4OjoiK5duyIhIaHY7ZVKJWbMmAF7e3u4urqiZs2aCA4OLvWpqpXks7KyYGtrizfffBPGxsbqVEVERFQhCp54p+5SGqNHj0ZycjIiIyMRExMDU1NTvP7668Vuv2DBApw4cQIXLlxAfHw8BgwYgNdff/2lXwyKolZ3vbe3N+rWrYvbt2/D19dXnaqIiIh0TlpamspnuVwOuVz1WS337t3DH3/8gbCwMLi5uQEANm/eDA8PD4SGhqJZs2Yq2z99+hTffPMNjh8/Dj8/PwDAypUrYW9vj/j4eDg5OZU4PrWSfGpqKrp06YJu3bqhT58+qFKlisr63r17o3379uocgoiISKM0Obvew8NDpTwoKAhLlixRKfvnn3/g5eWl0hh2dXVF48aNce7cuUJJ/p9//oGNjQ38/PywZ88e3LlzB23btkVQUFCp41Qryefm5uLWrVto0aIF4uPjER8fr7K+dWvdfKoYERHpsTKMqRdZB4Do6GiVSXQvtuIBICYmBq6uroXKXV1dER0dXeT2VlZW6Nq1K+RyORwdHbFkyRLMnDkTK1asKFWYaiV5Z2dn/Pbbb+pUQUREpLNsbW1fOVNeqVRCJiv8pUImk0GpVBYqT05Oxq1bt7BmzRrMnj0bABASEoJOnTph+PDh8Pf3L3F8GrlP/unTpzhw4ADu3LkDZ2dndOjQgWP0RERUKVX0q2bd3Nzw+PHjQuWPHj1C9+7dC5V7eHjAxMQE06dPl8ratWsHX19fnDlzplRJXu1n11+4cAF16tTBzJkzERwcjK+++goNGzYsNCZBRERUKQgNLSXUrFkz3L17FxEREVJZfHw8Ll++XGg8HgDq1q2L/Px8pKSkSGVKpRKJiYmws7MrxYlqIMkPHz4cY8eORXR0NI4fP47Lly/j7NmzWLduHU6cOKFu9URERDqtXr166NKlC9566y0kJycjPT0db731Fho1aoS2bdsCALZv347169cDAOrXr4/u3btj8uTJSE5ORnZ2Nt5//33k5uYiMDCwVMdWK8nfv38fjx49wkcffQQTk//1/Ddv3hyjRo3C0aNH1ameiIhI49R9EE5ZZudv27YNT58+hbOzM6pUqYJ79+7h999/l9b/8MMPUpIHgI0bN+LJkydwcnKCra0tdu/ejb179xZ6suyrqDUmb2Zmhvz8fOTn56skeQDIzs4u1b18REREFaaCnz1ftWpVnDlzBo8ePYJCoYC7u7vK+v379yMvL0/6XKNGDZw+fRrR0dHIzc2Ft7d3kZP3XkWtlrybmxsaNmyICRMmSE/hUSqV2L59O7Zt24Y+ffqoUz0REZHGaaMlX6B69eqFEjzwrNFsZWVVqNzDwwM+Pj5lSvCABmbXb9++HUOHDoWLiwtcXFyQkpICY2NjrFu3rsgJBURERFQx1E7ytWrVwoULF3Dx4kXcvXsXTk5OaNasGRwcHEpdV05ODq5fv47c3Fw0atSoyG81REREauGrZl/uxTF4IyMjNG/eHM2bNy9zIH///TdGjhyJ5ORkmJqawsTEBNu2bSvyHkIiIqKyk/13UbeOyq9MY/KNGjXCsmXLEBsbi3r16hW7/PDDDyWqT6FQYPDgwZg4cSISExMRFxeHIUOGYNSoURDqPrGAiIjIQJWpJT9z5kw0b94cdnZ2mDdvXrHblbRln5mZiVWrVuGNN96Qnvs7YcIEfPXVV0hOTi704hvgWdd+Tk6O9PnFNwEREREVid31LzdlyhQAgBACr7/+epHP7U1LS0NWVlaJ6rOxscHYsWOlz5mZmfjll1/QqlWrIhM8ACxfvhwffvhhGaInIiKDZkBJXq1b6KKiouDj41Pkunnz5uGrr74qdZ2dO3eGs7Mzzp49iwMHDhS73fz585GamiotRb3Jh4iIyJCVeXb9ihUr8PjxY2RmZhZqUWdmZmLv3r1YtWpVqet977338PDhQ2zevBlTp07Fjz/+CHNz80LbyeXyIl/pR0RE9FIafNVsZVfmJH/hwgUkJCQgLy8P586dU1lnbGyMd955ByNGjCh1vQUP0Bk1ahQ8PT2xc+dOjBkzpqxhEhERqajot9BpU5mT/O7du/Hw4UO8/vrrOHjwoFpBXLx4Ed999x02bNgAY2NjAIClpSWqVKmC9PR0teomIiIyVGVK8ikpKbCxsYGbmxvOnz+vdhCurq7YsWMH8vLy8NZbb0Emk2HLli2IjY1F79691a6fiIhIwol3L9ekSRMsWbIE0dHRcHBwKHZ5/o06L+Pi4oLDhw/j1q1baNOmDQICAvDvv//i0KFDqFmzZllCJCIiKlrBmLy6iw4oU0t+zZo1aNCgAZydnbF9+/Zit6tbt26J62zZsiVCQkKQn58PpVIJMzOzsoRGRET0UjLxbFG3Dl1QpiQ/cOBA6f979OihsWAAFHplLREREZWNWvfJA0BMTAw+++wzAM/G6nv06AEPDw98/PHHagdHRESkcUJDiw5QK8nn5+ejXbt2ePz4MQDg008/xYMHDzBz5kysWbMGx48f10iQREREGsMx+ZK5ffs20tPTsXz5cgDAvn37sHDhQowaNQq3b9/GsWPH0LVrV40ESkRERKWjVpKXy+XIzc2FQqFAVFQUbt26hS5dugAAzM3NkZubq5EgiYiINMaAbqFTK8l7e3vDx8cHgYGBSEtLQ8eOHeHq6oojR47gl19+webNmzUVJxERkWYYUJJXa0xeJpNh//79qFOnDpo0aYKffvoJAHD9+nVMnToV/fv310iQREREVHpq36/m4eGB7777TqVs9uzZ6lZLRERUPgyoJa+Rm9ITEhKwc+dO3LlzB87OzujcuTMCAgI0UTUREZFmGdBb6NS+T/6vv/5C7dq1sX79esTGxiI4OBgdO3bE9OnTNREfERERlZFaLXkhBEaPHo3//Oc/eO+996Tyu3fvol27dujbty969uypdpBERESaYkiPtVWrJX/37l2kpqbi3XffVSmvVasWRowYgRMnTqhTPRERkebxiXclY2tri+zsbGRmZhZal5iYCFtbW3WqJyIiIjWoleSrVauGNm3aYNiwYbh79y4A4OnTp1i/fj12797NW+iIiIi0SO3Z9du2bcO4ceNQu3ZtyOVy5OTkwMXFBVu3bkX9+vU1ESMREZHGyKCBMXmNRFL+1E7ybm5uOHr0KCIjI3H37l04OTmhXr16kMvlmoiv1DJq2cHE1Fwrxy4r7z2p2g6hTLI8bLQdQpnZRRQeYtIFuT2aazuEMjE7/K+2QyD6H95CV3qmpqaQy+UwNzeHkZHGqiUiIqIyUjsb379/H126dIG7uzu6dOmCevXqwdPTE7/++qsm4iMiItIszq4vuUGDBsHKygq3bt1Cbm4ukpOT8f7772PcuHG4cOGCJmIkIiLSHANK8mqNyUdGRuL69es4deoUrKysAAD29vZ49913cfXqVfzf//0fWrRooZFAiYiIqHTUnngnl8thYWFRqNze3p5j80REVOnwiXcl5OXlhcGDB2Px4sXIy8uTyk+fPo0TJ05g0qRJagdIRESkUQbUXa9Wko+Li0N0dDQ+/fRTuLi4oEWLFvDx8UG7du3w9OlTDBkyBAEBAQgICMC5c+c0FTMRERGVgFrd9ZaWlujXrx/69ev3ym2rV6+uzqGIiIg0g++TLxkbGxvMnDlTU7EQERGVO0Mak1d74h0REZFO4RPviIiISNexJU9ERIaFY/Ilk5eXB6VSqbWX0RAREZWWIY3Jq9VdHxsbi+rVq+Odd97BxYsXNRUTERERaYBaSd7NzQ3r16/H3bt30bJlS/j7+2PdunVITEzUVHxERESaxYfhlIyJiQlGjBiBgwcP4uHDhxg3bhx++eUXuLu7Y8iQITh06BCUSqWmYiUiIlKf+F+XfVkXg0jyz6tWrRpmzZqFXbt2Yc6cOdi3bx969eqF2rVrIzg4WFOHISIiohLSSJJPTEzEN998g3bt2sHb2xv//PMPfvjhByQnJ+M///kP+vbtyy58IiKqHNhdXzKpqakYMGAAqlevjpUrVyIwMBD37t3D0aNHMXz4cNjb22PChAmoUaMGzpw5o6mYiYiIys6Akrxat9BlZGTAxsYGhw8fRqdOnSCTFf0EoFOnTsHMzKzE9Q4YMACHDx/GlStXUKdOHXVCJCIiMlhqJXlbW1u89dZbaNu27Uu3c3Z2LnGdu3btwsmTJ5GdnQ0hdOSrEhER6QzeJ19C9+/fR5cuXVTeJa+OlJQUzJgxA2vWrHnltjk5OUhLS1NZiIiI6H/USvINGzaEt7c3/vjjD40E88EHH6BVq1YYOHDgK7ddvnw57OzspMXDw0MjMRARkZ7jmHzJpKSkoGXLlhgzZgz69OkDGxsblfVvvPEGAgMDS1RXSEgIduzYgbCwsGLH9p83f/58zJ49W/qclpbGRE9ERPQctZK8UqmEmZkZhg0bplYQubm5mDx5MpYtWwY3Nzekpqa+ch+5XM5n5hMRUakZ0pi8Wkne0dER33//vdpBfPrpp7CwsMCoUaPw9OlTZGRkAACePn2K3NzcUs3MJyIieiUdSdLq0sjDcMLCwrBy5UpMnDgRGRkZuH79OqKjo0u8/65du3Dx4kXY2dnB2toa7u7uAIBmzZohKChIEyESEREZHLWT/I8//ogmTZrgl19+wU8//YScnBzs2rULrVq1QkJCQonqOHXqFBISEqTl1q1bAICzZ89i0aJF6oZIRET0PwY08U6tJJ+VlYWZM2di165duHLlCszNzQEAixYtgpeXF7Zu3Vqieuzt7eHo6KiyAICDgwMsLS3VCZGIiEiFui+n0cSYfkVRa0z+3r17kMvl6N+/v2qlJibo1KkTIiMjy1Svg4MD7t69ixo1aqgTHhERkUFTqyXv4eGB5ORkxMXFFVp38eLFMj+S1sjICD4+PjA1NVUnPCIiosLYXV8ytra2GDNmDHr16oU//vgDCoUCZ86cwZQpU3D16lUMHTpUU3ESERFphCF116s98W79+vUYMGAA3nrrLWRlZWH48OF4+PAhgoOD4eTkpIkYiYiI9EJMTAwePHhQ6v0SEhLw+PHjUu+ndpI3NzfH4sWLERMTg8zMTKSnp+OPP/6Ar6+vulUTERFpnha66+Pj4xEQEAAfHx/4+vqicePGiIqKKtG+9+/fh6enJ9q3b1+6g0LNiXf5+fkv/Ubi6OgIe3t7dQ5BRESkWZoYUy/l/iNGjIC9vT0SExNhZGSECRMmYMCAAbh48eIr93377bdRpUqVMoWpVpJ/+PAhatWqVez61atXY86cOeocgoiISKM0+VjbF9+AWtQj12/evIng4GDcvXsX1tbWAIAvv/wSrq6uOHPmDNq0aVPscbZt24bw8HAsWLAAn332WanjVCvJe3h4FHrgTXZ2Ng4dOoTQ0FBMnz5dneqJiIgqtRdfjBYUFIQlS5aolIWGhqJWrVrw9vaWypydneHv749///232CSflJSEd999Fxs3bizz69TVSvJGRkbSg2ueN3HiRBw/fhx//PEHBg0apM4hiIiINEuD3fXR0dGwtbWViot6cVpMTAxcXFwKlbu4uLz0EfDvv/8+OnbsiH79+uGXX34pU5hqJfmXiY2NRVhYGJM8ERFVLhpM8ra2tipJvihGRkYQovABlUoljI2Ni9zn5MmT+O233xAeHq5WmGol+aysLAQHB6uUFXTXnzx5EgsXLlQrOCIiIl3n5uaGhw8fFiqPjY1Fr169CpUXvH597NixiIuLQ1xcHB48eICcnBxcuXIFtWrVgpWVVYmOrVaST0hIwLhx41TKZDIZPDw88O2336Jbt27qVE9ERKRxFf0++VatWiEyMhLh4eHw8/MD8KwL/8qVK2jdunWh7ePi4hAfH48tW7Zgy5YtAJ4l/uzsbHTq1AkHDx4scr+iqD3x7smTJ+pUQUREVLEq+BY6Hx8f9OvXDxMmTMCvv/4KExMTjB8/Hm3btkXz5s0BAN9++y3i4uKwePFi6ZHxz/vxxx+xdOlS3Llzp1RhauR98kRERFS8rVu3omrVqqhTpw5q1qwJAPjtt9+k9YcOHcLvv/+u8eOq1ZKPjo5Go0aNSrTt7t270bVrV3UOR0REpLaK7q4Hnk3Q27dvHzIzM6FUKqX75Qvs3bsXCoWi2P3Hjh2LsWPHljpOtZJ81apVsXjxYqxduxZTp05F3bp1kZiYiG3btsHExATvvvsuZDIZAKBx48bqHIqIiEgztPDEuwKWlpZFlstkMpiYaP6GN7VqVCgUWLZsGc6cOYPatWtL5RMmTEDnzp2RmprKN9ERERFpiVpJ/t69e1AoFCoJHnj2jaR169Y4d+5chSd5qwcZMDHOq9BjqkuYldvjCsqVxcN0bYdQZnlViv42Xdnl2RR9T21lZ1HHR9shlInidoS2Q6DyoMWWfEVTa+Kdt7c30tPTcfz4cZXyp0+f4sCBA6hTp45awREREWmaTEOLLlCrCWlpaYmPP/4Yffr0weDBg+Hr64ukpCTs2bMH9vb2ZZokQEREVK7Yki+5efPm4c8//4SJiQmOHj2KyMhIzJo1C+fOnSt2ggERERGVP40MBnfp0gVdunTRRFVERETlShu30GmLbs74IiIiKit21xMREZGuY0ueiIgMj460xNXFJE9ERAbFkMbk2V1PRESkp9iSJyIiw2JAE++Y5ImIyKCwu56IiIh0HlvyRERkWNhdT0REpJ8MqbueSZ6IiAyLAbXkOSZPRESkp9iSJyIiw2JALXkmeSIiMigck9eCEydOYNGiRYXKjx8/DjMzMy1EREREpNsqTZK/evUq4uPjsWDBApVyE5NKEyIREekDdtdXvKioKPj7+2Ps2LHaDoWIiPSYTAjIhHpZWt39K0qlSfIPHjyAl5cXHjx4gPj4eNSvXx+WlpbFbp+Tk4OcnBzpc1paWkWESUREpDMqzS10UVFR+PXXX9GoUSN0794d1atXx+7du4vdfvny5bCzs5MWDw+PCoyWiIh0ltDQogMqTZJfvnw5Nm/ejJSUFCQnJ+ODDz7AmDFjEBUVVeT28+fPR2pqqrRER0dXcMRERKSLCmbXq7vogkqT5Lt06YLAwEDIZDLIZDIsWLAAVatWxbFjx4rcXi6Xw9bWVmUhIiJ6JbbkK15oaCjS09NVyuzs7JCZmamliIiIiHRbpUnyI0aMwJw5c6TPJ0+eRHh4ODp06KDFqIiISN8YUnd9pZld/+WXX2LgwIE4fvw4vL29cerUKSxZsgSNGjXSdmhERKRPeJ98xQsMDMSdO3dw8OBBZGdn4/PPP0eDBg20HRYREZHOqjRJHgCqV6+OCRMmaDsMIiLSY3x2PRERkb4yoO76SjPxjoiIiDSLLXkiIjI4utLdri4meSIiMixCPFvUrUMHsLueiIhIT7ElT0REBoWz64mIiPSVAc2uZ5InIiKDIlM+W9StQxdwTJ6IiEhPsSVPRESGhd31RERE+smQJt6xu56IiEhPsSVPRESGxYAehsMkT0REBoXd9URERKTz9K4lL8vMgcxY21GUjixPoe0QyuSpj722Qygzq1uJ2g6hTMxidOTm3BcIS7m2QygT0dZf2yGUiez0ZW2HULlxdj0REZF+Ync9ERER6Ty25ImIyLBwdj0REZF+MqTueiZ5IiIyLAY08Y5j8kRERHqKLXkiIjIo7K4nIiLSV0rxbFG3Dh3A7noiIiI9xZY8EREZFgOaeMckT0REBkUGDYzJaySS8sfueiIiIj3FljwRERkWPvGOiIhIP2nrFjqlUolr164hPz8fjRs3honJy1OwEAJhYWGIj49Ho0aN4OTkVOpjMskTERGVs8jISPTs2RNxcXEwMTGBpaUlDh06hHr16hW5fUpKCvr164fr16/D0tISSUlJWLNmDaZOnVqq43JMnoiIDIvQ0FIKI0aMQOPGjZGQkIC4uDj07NkTAwcOhCim23/hwoUQQiAmJgYxMTHYuXMnZs6ciYiIiFIdl0meiIgMikwIjSwAkJaWprLk5OQUOt7Vq1dx7tw5rFmzBsbGxjAyMsKKFStw7949nDhxosgYLSwsMH/+fFhZWUEmk6Ffv36oUqUKLl26VKpzZZInIiLDotTQAsDDwwN2dnbSsnz58kKHu3LlCurWrQt3d3epzN7eHv7+/rhy5UqRIa5atQp9+vSRPl+/fh3x8fHw8/Mr1alWqjH5mzdv4tdff0VkZCRat26NiRMnwszMTNthERERFSk6Ohq2trbSZ7lcXmibmJgYVKtWrVC5i4sLYmJiXnmMrKwsjB8/HmPGjCl1kq80Lfl//vkHbdq0QUREBKpWrYply5ahX79+UCqV2g6NiIj0iCa7621tbVWWopK8mZkZ8vLyCpXn5eUVuf3zlEolxowZA6VSiQ0bNpT6XCtNkp8zZw7mzp2Ln3/+GatWrUJwcDBOnTqFv//+W9uhERGRPqngiXdubm6Ijo4uVB4dHQ03N7eX7jtt2jRcunQJBw4cgLW1dckP+l+Vorv+1q1bCA0NxaFDhwAA+fn5qF27NjIzM4vdJycnR2WCQ1paWrnHSUREVFpt27ZFbGwsLl68iKZNmwIAIiIiEBYWhvbt2xe736JFi7B//36EhITAxcWlTMeuFC3527dvw8vLCwcOHECdOnVgbm6ONm3a4OrVq8Xus3z5cpXJDh4eHhUYMRER6ayCJ96pu5SQh4cHhg4dijFjxuDChQu4fPkyhg8fjsDAQDRs2BAAsGLFCsycOVPaZ926dfj000+xfPlyJCYmIjQ0FKGhoSUaw39epUjyMTExePjwIVatWoWffvoJN2/eRK1atdCzZ0+kpKQUuc/8+fORmpoqLUV1hRAREb2o4Il36i6lsWnTJrRs2RKBgYHo0KEDvL29sWvXLmn9jRs3VBq2GzduhL29PWbPno2ePXtKy/fff1+q41aK7norKyukp6fj559/hq+vL4BnF8TDwwMHDx7E8OHDC+0jl8tfOWGBiIioMjA3N8fmzZuxadMmCCFgZKTaxt6yZYvK55f1ZJdGpUjyPj4+MDIyQq1ataQyU1NTuLq64vHjx1qMjIiI9I4WX1Ajk8kgk1Xci2orRXd948aN4ejoiD179khlN2/exPXr19GsWTMtRkZERPpGptTMogsqRUve2toaK1euxLhx4/DXX3/B1tYWmzdvxqBBg9ChQwdth0dERKSTKkVLHgDGjRuHI0eOwNjYGElJSVi7di22bdum7bCIiEjfVPDsem2qFC35Au3bt3/pPYNERERqK8Nb5IqsQwdUqiRPRERU3p5/LK06deiCStNdT0RERJrFljwRERkWLd5CV9GY5ImIyLAISO+DV6sOHcDueiIiIj3FljwRERkUQ5p4xyRPRESGRUADY/IaiaTcsbueiIhIT7ElT0REhoWz64mIiPSUEoC6L4LTkRfUsLueiIhIT7ElT0REBoWz64mIiPQVx+SJiIj0lAEleY7JExER6Sm9a8krrS2gNJZrO4xSkSkU2g6hTKxuJ2k7hDJTWplrO4QyMU7J0HYIZZOVq+0IysRER+MW/n7aDqFMjBQ5wNX/K/8DGVBLXu+SPBER0UvxFjoiIiLSdWzJExGRQeEtdERERPrKgMbk2V1PRESkp9iSJyIiw6IUgEzNlrhSN1ryTPJERGRY2F1PREREuo4teSIiMjAaaMlDN1ryTPJERGRYDKi7nkmeiIgMi1JA7Za4jky845g8ERGRnmJLnoiIDItQPlvUrUMHMMkTEZFhMaAxeXbXExER6Sm25ImIyLAY0MQ7JnkiIjIs7K4nIiIiXVdpWvJ79+5Fenp6oXJPT0906tSp4gMiIiL9JKCBlrxGIil3lSbJ79y5Ew8fPlQpCwsLQ7du3ZjkiYhIcwyou77SJPnt27erfE5KSoKXlxeGDBmipYiIiIh0W6VJ8i9avXo1vLy8MGjQoCLX5+TkICcnR/qclpZWUaEREZEuUyoBqPkwG6VuPAynUk68S0xMxJdffomgoCDIZLIit1m+fDns7OykxcPDo4KjJCIinVTQXa/uogMqZZJftWoVvL29MXDgwGK3mT9/PlJTU6UlOjq6AiMkIiKdZUBJvtJ11z958gTr16/H1q1bi23FA4BcLodcLq/AyIiIiHRLpUvyq1atQu3atTFgwABth0JERPqIT7zTjvj4eGzYsAHbtm17aSueiIiorIRQQqj5Fjl1968olWpMfsWKFfD19UX//v21HQoREZHOqzQt+ZycHNy5cweffvqptkMhIiJ9JoT63e2ceFc6crkc+/bt03YYRESk74QGxuR1JMlXqu56IiIi0pxK05InIiKqEEolIFNz4pyOTLxjkiciIsPC7noiIiLSdWzJExGRQRFKJYSa3fW6cp88kzwRERkWA+quZ5InIiLDohSAzDCSPMfkiYiI9BRb8kREZFiEAKDuLXS60ZJnkiciIoMilAJCze56oSNJnt31REREeooteSIiMixCCfW760u//9OnT3Hu3Dnk5+cjICAAtra2L90+KysL//zzD7KystCmTRvY2dmV+phM8kREZFC00V0fFhaGHj16wMzMDKampkhKSsKBAwfQsmXLIre/e/cuAgMDoVAoYGlpicePH2Pfvn1o3759qY7L7noiIqJyNnr0aPTu3Rv37t3DrVu3MGHCBAwbNgxKZdE9AhMmTEBAQAAiIyNx48YNzJ49G0OGDEFeXl6pjqs3LfmCb1X5ihwtR1J6MoVC2yGUiUyRr+0Qykypm5ccQql7v98AIBTG2g7BoAiFTNshlEnBv9/lPaktX+So/YKZfDxLtmlpaSrlcrkccrlcpezChQu4evUqDh06JJUtWrQIX375JY4ePYoePXqobH/jxg2EhITg3r17kMme/Sznzp2LNWvWYN++fRg0aFCJ49SbJJ+eng4AOHX9cy1HQkRE6khPTy/T+POrmJmZwcXFBSGP/9RIfdbW1vDw8FApCwoKwpIlS1TKwsPDUbduXVStWlVlX39/f6kb/8XtPTw84OXlJZXJ5XK0bNkSYWFhhpnkXV1dER0dDRsbG+mbj6akpaXBw8MD0dHRr5woUZnoatyA7sbOuCsW46545Rm7EALp6elwdXXVaL0FzM3Ncf/+feTm5mqkPiFEoXzzYiseAB4+fKiS4AtUrVoVMTExam//MnqT5I2MjODu7l6ux7C1tdW5P0hAd+MGdDd2xl2xGHfFK6/Yy6MF/zxzc3OYm5uX6zFeZGFhgezs7ELl2dnZsLKyKtX2zs7OpTo2J94RERGVI3d3d0RFRRUqf/DgAdzc3IrcPiYmptCkvOK2fxkmeSIionLUvn17JCQk4PTp01JZWFgYbt26ha5duxbaPiAgAHl5eTh69KhUFhkZidDQUHTr1q1Ux2aSLwG5XI6goKAix1oqM12NG9Dd2Bl3xWLcFU+XY9cWFxcXjB8/HqNHj8bBgwdx7NgxDBkyBIMHD0bt2rUBAPPmzcOoUaMAAPb29njrrbcwceJE7N+/H8HBwRg4cCB69uwJf3//Uh1bJnTlAbxEREQ6SqFQYP78+dizZw8UCgX69u2LNWvWSF+W3n33XURHR2P37t0AAKVSiaCgIOzYsQNZWVno1asX1q5dC0tLy1Idl0meiIhIT7G7noiISE8xyRMREekpJnkiIiI9xSRPRESkp5jkiYiI9BST/Ct8/fXXaN26NerWrYt33nkHWVlZ2g6pxEJDQ9G+fXt06NBB26GUWEhICLp27Qp3d3d07NhR5WEQlVl4eDgGDx4MT09P+Pv7Y/Xq1cW+QrKyWrNmDZo0aYJ//vlH26G80pkzZ9CkSZNCS0pKirZDe6Vbt25h0KBB8PT0RNu2bfHHH39oO6RXmjFjRpHXe/DgwdoOjV5Bb55dXx4+//xzfPTRR1i3bh2qVq2KRYsWoV+/fjh27Ji2Q3ulb775BnPmzEHbtm1x4cIFbYdTIuHh4ejevTsWLVqEDz/8EAcPHkS/fv0QEhKC5s2bazu8Yj169AgdO3ZEnz598P333+POnTtYtGgRlEol5s6dq+3wSuTWrVsICgpCVlYWMjIytB3OK924cQOpqalYtWqVSnlp7yGuaFFRUWjfvj1GjhyJadOm4dixYxgwYACOHTuGTp06aTu8Yg0dOhQdO3ZUKVuzZg1SU1O1FBGVmKAi5eTkCBcXF7F161ap7NGjR8LExEScPXtWi5GVTK9evURISIjYvXu3sLe313Y4JRIUFCS6du2qUjZgwADx3nvvaSmikjl8+LAYPny4Stns2bNFixYttBRR6SiVStGhQwcxb948YW1tLY4dO6btkF5p0aJFok+fPtoOo9Tee+89MXLkSJWyDz74QKxcuVJLEZVNdHS0kMvl4ujRo9oOhV6B3fXFuHTpEhITEzFw4ECpzMXFBe3bt8eff2rmXcTl6bfffkPbtm21HUapfPDBB9i3b59KWUxMDMzMzLQUUckEBgZi27ZtKmUZGRnw8/PTUkSls3nzZjx8+BCLFy/WdiglFhUVhRo1auDWrVsIDg5GYmKitkMqkR07dmDMmDF4+vQp/v77b0RERODTTz/F+++/r+3QSmXZsmVo0aJFqZ+jThWP3fXFiImJQdWqVQt1/9WsWRMPHz7UUlQlp4vPlbawsFD5fPDgQVy/fr1QAq2sHj9+jJ9++glHjx5FcnKyTsQdFxeHuXPnYufOnYWuf2UWFRWF69evY8+ePTA1NUVCQgK++OILTJkyRduhFUuhUCA2NhZhYWEYPHgwnJycEBUVhREjRuCHH36AsbGxtkMskaioKGzatAkHDx7UdihUAmzJFyMjI6PI8T1LS0ukpaVpISLDcuPGDQwfPhxr1qyRXuBQ2aWnp+Ps2bN4/PgxqlWrBoVCoe2QXmnWrFno169fkW/CqsxWrlyJPXv2IC4uDjExMdiwYQOmT5+O8PBwbYdWrCdPnkChUGD9+vW4cuUK7t27h+vXr+PgwYPYsGGDtsMrsU8++QStW7dGly5dtB0KlQCTfDGqV6+O+Pj4QuXx8fGlfp8vlU50dDR69OiBN998E1OnTtV2OCVWu3Zt/Pbbb7h27Ro6deqE9u3bIzMzU9thFevgwYM4fvw41qxZo+1QSq158+Zo37699HnixInw8/PD4cOHtRjVyzk6OsLY2BgffPABatasCQDw9fXFpEmTcODAAS1HVzIPHjzADz/8gA8//FDboVAJMckXo27dukhLS1NpGQghcPbsWdStW1eLkem3xMREBAYGolu3boVmTldWN27cKNSCHDlyJBITE3H//n0tRfVq69evR0ZGBvz9/eHh4QEPDw88ffoUw4YNw4wZM7Qd3kuFhIQgISFBpczS0hJ5eXlaiujVTE1N4eHhAXNzc5VyY2Nj5Ofnaymq0lm6dCnatGlTqe8EoBdoe+ZfZRYYGCgGDRoklEqlEEKIb7/9VlhZWYnk5GTtBlYKujS7Pj09XbRs2VIMHjxY5OfnazucEvvkk0+Eu7u7iI2NFUIIoVAoxIoVK4SNjY3Izs7WcnTFu379uggJCVFZzMzMxOeffy5u3bql7fBeqmXLlmLgwIHS78mJEyeEiYmJ+Pfff7Uc2cstXrxYNGnSRKSkpAghns1Sd3V1FZ9++qmWI3u1e/fuCVNTU3HixAlth0KlwCT/Enfu3BFeXl7C29tbtGjRQpibm4udO3dqO6xS0aUkP336dAFA1K5dWzRo0EBahg4dqu3QXurp06eiS5cuwtjYWLRo0UI4OTkJW1tb8fvvv2s7tFIzNzfXiVvozp8/L5ycnISzs7No06aNkMvlYunSpdoO65UyMjJEhw4dhJOTk+jQoYOwsbERvXv3Fjk5OdoO7ZUmTJggOnfurO0wqJT4PvlXSE9Px6lTp5Camop27drBw8ND2yGVyuPHj3HlyhX06NFD26G80uXLl4u8c8HOzg7t2rXTQkSlc/bsWYSFhcHBwQGdOnWCo6OjtkMqtYMHD6JFixZwcnLSdiivlJKSgmPHjuHp06cICAhAnTp1tB1SiSiVSgQHB+PBgwfw8/NDQECAtkMqkcOHD8PX1xeenp7aDoVKgUmeiIhIT3HiHRERkZ5ikiciItJTTPJERER6ikmeiIhITzHJExER6SkmeSIiIj3FJE9ERKSnmOSJiIj0FJM8ERGRnmKSJ9ITSqUSqamp2g5Dp+Tl5SE9PV3bYRCVGyZ50piYmBisXbtW22FoxKVLlzB48OBiE8CJEycwYsSISvWK0G+++QZt2rTRdhgvde3aNWzZskWtOn7++WdcvnxZI/Hcvn0bTk5OiImJ0Uh9RJUNkzxpTEREBObPn6/tMDQiNzcX6enpUhL/6KOP8N1330nrs7OzkZ6eDqVSqa0QVQghsGrVKowdO7ZE21+/fl3lpUV5eXno3r07IiIiyitEAMD58+exZs0ater44osvcPr06SLXnTp1CsOHDy9xXfXr10eDBg3wxRdfqBUTUWXFJE9UhFatWuHw4cNwcHAA8KwFeufOHWl9z549sX//fpiZmWkrRBX//PMPoqKiMGrUqBJtn5qaiuDgYOmzUqnEsWPHkJGRUV4hVoj4+HiEhISUap+xY8di586d4Lu6SB8xyVO5uX37NurUqYONGzcCAHJycjB79my4u7vDzs4Ob7zxhvRq2cmTJ2PcuHEq+585cwYuLi5ISEgoVPfPP/+Mnj17YtOmTahWrRqqVKmCcePGIS0tTdomLy8PCxcuhJeXF+zs7NCnTx/cu3dPWp+bm4tp06bByckJlpaW6N27N1JSUgA8S5ouLi4AgM6dO2Pfvn3YsGEDnJ2d8ejRI+zfvx+NGjWS6srKysKsWbPg7u6OKlWqYNCgQYiNjZXWv/322/joo48we/ZsODs7w9XVFV9//XWx1y4vLw8zZ86Es7MzLC0tERgYWOR1KPD333+jZcuWcHV1lco2b96MNm3awMLCAp6enti8eTMAYPv27ejTpw/y8/Ph7OyMadOmwc3NDQDQqVMnDBgwAMCzxL906VJ4e3vD2toavXr1wq1bt6T6Bw0ahA0bNmDChAlwcHCAl5cXduzYoRLXtm3b4OvrCwsLC/Tt27fQ8EdGRgYmTZok/QzHjx+PpKQkaX16ejomTJgAR0dHVK1aFd9++22x12DdunUYP348YmNj4ezsjK+++goAkJCQgJEjR8LJyQnVq1fHlClTVOLo378/oqKiEBkZWWzdRDpLmy+zJ/1y4sQJYW5uLoQQIiIiQri7u4ulS5dK6ydOnChat24tQkNDxZ07d0T//v1F69athUKhEH/++acwNzcXqamp0vZTpkwRffv2LfJYGzduFLa2tqJPnz7i2rVr4p9//hFNmzYVAwcOlLaZMWOG8PHxEcHBwSI8PFy8+eabonr16iI9PV0IIcTHH38sPD09xcWLF8W9e/dEv379xKxZs4QQQoSEhAgTExMhhBCxsbGiV69eYtKkSSIyMlLk5+eL3bt3C3d3d+lYI0aMEI0aNRKnT58W165dE0OGDBF16tQRubm5QgghRo0aJdzc3MSmTZvEzZs3xXvvvSeMjIzEzZs3izy/VatWCVdXV3HhwgVx//59MWjQIPHWW28Ve+0nTZokxo4dK30+e/asMDMzE19//bW4f/+++O6774RMJhM3b94UGRkZYteuXcLY2FhERkaKuLg4cevWLQFA/Pnnn+Lx48dCCCGCgoKEr6+vOHXqlLh375548803Ra1atURmZqYQQohu3boJb29vsXPnThEWFiYmTpwoLCwsRFxcnBBCiOPHjwszMzPxzTffiIiICLFhwwbh6OgoGjRoIMXZp08f0aNHD3H9+nURFhYmOnToIF577TVp/RtvvCH8/f3F2bNnxbVr10S/fv2EtbW1WL9+faFrkJqaKr766ivh4uIiIiMjRWpqqlAqlaJFixaiZ8+e4tKlS+L8+fOiTZs2olevXtJ+SqVSmJubi6NHjxZ7fYl0FZM8aUxBkn/w4IHw9PQUS5YskdbFxcUJIyMjERERIZXdvXtXyGQycfHiRZGfny/c3NzE5s2bhRBC5OTkCAcHB7F3794ij7Vx40ZhamoqJRQhhLh69aoAIKKjo0VaWpowMTERx44dk9YrFArh4+MjNmzYIIR49qWjQ4cOIicnRwghRF5enrTt80leCCEGDx4s3nvvPenz80k+KipKyGQycfnyZWl9VlaWcHZ2Fjt27BBCPEvy/fv3l9bn5uaKKlWqiB9//LHI85s2bZpo1aqVyMrKKhRbUTp37iw+/vhjlbKCLzNCPLuejo6OYsuWLUWeX3Z2tgAgnUN+fr6wtrYWJ0+elLZJSUkRFhYWYt++fUKIZ0l+ypQp0vrk5GRhZmYmDh8+LIQQ4rXXXhOTJk1SiWnEiBFSkr9+/bowMzMTycnJ0vozZ84IACI2NlY8fPhQABChoaHS+idPnggzM7Mik7wQotCXr6NHjwoLCwuRlJQklUVFRQljY2Nx5coVqczPz0989dVXRdZJpMtMtNqNQHonLy8PnTp1gkKhwLx586TyGzduAAAmTpyosr2pqSnCw8PRpEkTjBkzBj///DPGjx+PAwcOwNjYGH379i32WJ6enqhatar0uWHDhrCyssLNmzfh4OCA/Px8tG3bVlpvZGSEtm3b4tq1awCAGTNmoGfPnvDw8ED37t3Rt29fDBkyBEZGpRvFCg8Ph6WlJRo3biyVmZubo0WLFrh27RqGDBkCAHB3d1c5b29v72Jn70+bNg2BgYHw8PBAYGAgevfujaFDh8LEpOg/2ZiYGKnLvcC///6LQ4cO4ezZs7h9+zZSU1NLPOYeGRmJjIwMLFiwAKamplK5iYkJwsPD0a9fv0LnZG9vj6pVq0rndPPmTbz22msq9bZo0QJXr14F8Gzyn5GREV5//XVpvRACMpkM4eHhMDIygpmZGZo0aSKtd3JyQs2aNUt0DgAQFhYGPz8/aW4FAHh4eMDT0xPXrl2Thlzc3d0RHR1d4nqJdAWTPGmUUqnEnDlz8Nlnn2HatGnSeLyZmRmMjIzw/vvvw9jYWGUfPz8/AMD48eOxYsUKxMbG4pdffsHo0aNVEsyLcnNzCx07NzcX5ubmkMvl0jbm5uYq+1SpUgUA0KhRI9y/fx/Hjx9HcHAwpk2bhn379mHbtm2lOme5XI78/HwpQT1/rOeP/fy6V6lXrx4iIiIQHByM4OBgzJo1C3v27MHevXuL3N7V1VVlDsCWLVswefJkzJs3D0FBQahXrx569epV4uMXTCicNm2adL0KeHt7l+iczM3NkZOTo1L2/GczMzNYWVmpfBkEgPnz56Nhw4aIiIhAfn4+8vPzVX4PXqzzZeRyOfLy8gqVv/iziY2NRf/+/UtcL5GuYJInjZLL5Zg2bRratm2LNm3aoGXLlpg8eTL8/PxgamoKKysrdOzYEcCzyWqHDh2Ck5MTAKB27dpo06YNdu3aJbVAXyY6Ohrh4eHSl4Rjx45BJpPBz88PVlZWsLOzw59//olhw4ZJxzt+/Lh0L/9ff/0FZ2dn9O7dG71794avry9mz55d7PGKuye+YcOGAIDjx4+jW7duAIDExEScPXsW77//fgmvnKq///4bdnZ26NmzJ3r27IlGjRph4sSJhb5IFKhTpw5u374tfT569CgGDBiAjz76SDr3Bw8eqOyjVCqhVCpVei4KztHd3R3VqlWDUqmUbrVTKpX4/fffVXpPXsbf3x8HDx7E1KlTpbIjR45I/9+kSROkpKTA09MTvr6+AICkpCScPn0aDg4O8PX1hampKY4cOYI+ffoAAG7dulXoPF70/M+pefPmCA8PR2RkJLy8vAAAly9fxqNHj9C0aVMAz3oPIiIiUKdOnRKdF5EuYZKncuHv74+vv/4akydPRqNGjdC6dWssWrQIw4YNw8KFC+Hk5ITNmzcjPDxc6soHgAkTJmDu3Lnw8/OTkmdxnJycMH78eEyfPh2ZmZlYvHgxZsyYIbU8ly5diilTpuDx48dwcXHBhg0b4OXlhaFDhwJ4Nsv82LFjWLx4MRQKBT777DOVe8efV7duXezcuRMNGzaUut8LODo6Yt68eRgxYgQ+/PBD2NraYs2aNWjbti0CAwPLdP327NmD33//HUFBQTAyMsJnn32GwMDAYlvODRs2VJmt36pVKwQFBeGbb75B1apV8f3336skc29vbxgZGWHJkiXo27cvWrZsCU9PT3z++ecYNWoUevbsiZUrV2L69OmIjY2Ft7c3du7cicOHDyMsLAx2dnavPId58+ahadOmmDJlCnr06IE//vgD8fHx0novLy9MmzYNvXv3xoIFC2BhYYENGzYgPT0dvXr1goODA2bNmoVx48bh448/hrW1NdatW6cyRPCiOnXqIC4uDmvWrEH37t3RvHlzDBo0CL169cK8efOQl5eHjz76CNOmTZO6/W/cuIHs7GzpyyKRXtHulADSJ+Hh4WL06NEqZcuWLRNz5swRSqVSCCHEjh07xKBBg0SbNm3E1KlTRVRUlMr26enpwsTERHz99dcvPdbGjRtFgwYNxJkzZ0Tv3r1Ft27dxLp166TjFNizZ48YOHCg6Ny5s1i4cKF4+vSptC47O1t8+OGHomPHjqJz587iww8/FBkZGUIIIW7evClGjBghbZuWlibeffdd0atXL3Hz5k1x7tw5MXXqVJVj/fTTT+K1114TXbt2FZ988ok0oU8IIdavXy9NKiywYMECaZLai3Jzc8Unn3wiOnbsKDp16iQWL14s0tLSir0eCQkJwsLCQpw5c0YI8WyS4fLly0WbNm3EkCFDxJEjR8TChQtVjrd3717Rr18/sWrVKiGEEP/++6944403xJtvviltc/jwYTFs2DAREBAgxo8fL27cuCGtW7p0aaGJkVOnThXnzp2TPl+6dEmMGDFCtGvXTnz00Ufi77//VpnAKMSzn2X//v1F27ZtxZw5c8STJ0+kdUqlUnz55Zeie/fuonfv3iIkJEQEBQUVe92EEOKHH34Qffr0ERs3bhRCPJtEuHr1ahEYGCj69Okjvv32W5Xtg4KCir2Lg0jXyYTgEyCo8jh9+jQCAwPx8OFD2NvbF7vdpk2bsHbtWmkSHQFTpkxBbm4ufvjhB22HojPy8vJQs2ZNbNmyRRpqIdInfBgOVQp5eXkYM2YMhg8fjmXLlr00wVPR3n//fXh4eGg7DJ0SFRWFiRMnMsGT3mJLniqFhIQErFu3Dm3atEGPHj1eORP98uXLOH/+PCZPnlxBERIR6R4meSIiIj3F7noiIiI9xSRPRESkp5jkiYiI9BSTPBERkZ5ikiciItJTTPJERER6ikmeiIhITzHJExER6SkmeSIiIj31/8wsN4Wyip4nAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output shape: torch.Size([1, 8, 16])\n"
     ]
    }
   ],
   "source": [
    "torch.manual_seed(0)\n",
    "B, T, C, head_size = 1, 8, 32, 16\n",
    "x = torch.randn(B, T, C)\n",
    "\n",
    "key   = nn.Linear(C, head_size, bias=False)\n",
    "query = nn.Linear(C, head_size, bias=False)\n",
    "value = nn.Linear(C, head_size, bias=False)\n",
    "k, q, v = key(x), query(x), value(x)                     # (B, T, head_size)\n",
    "\n",
    "att = q @ k.transpose(-2, -1) / math.sqrt(head_size)     # (B, T, T) similarity scores\n",
    "att = att.masked_fill(torch.tril(torch.ones(T, T)) == 0, float(\"-inf\"))\n",
    "att = F.softmax(att, dim=-1)                             # each row sums to 1\n",
    "out = att @ v                                            # (B, T, head_size)\n",
    "\n",
    "plt.imshow(att[0].detach(), cmap=\"viridis\")\n",
    "plt.xlabel(\"key position s (attended to)\"); plt.ylabel(\"query position t\")\n",
    "plt.title(\"attention weights (random, untrained)\"); plt.colorbar(); plt.show()\n",
    "print(\"output shape:\", out.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd450364",
   "metadata": {},
   "source": [
    "### Why divide by $\\sqrt{d_k}$?\n",
    "\n",
    "If the entries of $q$ and $k$ have mean 0 and variance 1, then $q\\cdot k = \\sum_{i=1}^{d_k} q_i k_i$ has variance $d_k$. Large scores push the softmax towards a one-hot vector, so every token would only look at one other token and the gradients would vanish. Dividing by $\\sqrt{d_k}$ brings the variance back to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0dff06fc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:23:13.746265Z",
     "iopub.status.busy": "2026-10-10T20:23:13.745660Z",
     "iopub.status.idle": "2026-10-10T20:23:13.766798Z",
     "shell.execute_reply": "2026-10-10T20:23:13.765883Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var(q.k)          =  65.40   (~ d = 64)\n",
      "var(q.k / sqrt d) =   1.02   (~ 1)\n",
      "softmax without scaling: [0. 0. 1. 0. 0. 0. 0. 0.]\n",
      "softmax with scaling   : [0.108 0.034 0.549 0.077 0.039 0.036 0.012 0.147]\n"
     ]
    }
   ],
   "source": [
    "d = 64\n",
    "q, k = torch.randn(1000, d), torch.randn(1000, d)\n",
    "raw = (q * k).sum(dim=1)\n",
    "print(f\"var(q.k)          = {raw.var():6.2f}   (~ d = {d})\")\n",
    "print(f\"var(q.k / sqrt d) = {(raw / math.sqrt(d)).var():6.2f}   (~ 1)\")\n",
    "\n",
    "row = torch.randn(8, d) @ torch.randn(d)                 # 8 scores for one query\n",
    "print(\"softmax without scaling:\", F.softmax(row, dim=0).numpy().round(3))\n",
    "print(\"softmax with scaling   :\", F.softmax(row / math.sqrt(d), dim=0).numpy().round(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2ab0550",
   "metadata": {},
   "source": [
    "## 4. From one head to a Transformer block\n",
    "\n",
    "* **Multi-head attention.** We run $h$ heads with $d_k = d_{model}/h$ side by side. Each head can look for something different, for example the previous vowel or the start of the line. Their outputs are glued together and projected.\n",
    "* **Feed-forward MLP.** After the tokens have talked to each other, each token thinks on its own: $\\text{MLP}(x) = W_2\\,\\text{GELU}(W_1 x)$.\n",
    "* **Residual connections and LayerNorm** keep a deep stack trainable:\n",
    "\n",
    "$$x \\leftarrow x + \\text{MHA}(\\text{LN}(x)), \\qquad x \\leftarrow x + \\text{MLP}(\\text{LN}(x))$$\n",
    "\n",
    "* **Position embeddings.** Attention on its own does not know the order of the tokens, so we add a learned vector for every position.\n",
    "\n",
    "The whole model is: token embedding plus position embedding, then $N$ blocks, a final LayerNorm, and a linear layer that gives $|\\mathcal{V}|$ logits. The loss is the cross-entropy, exactly as in notebook 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "85c0d2fa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:23:13.770818Z",
     "iopub.status.busy": "2026-10-10T20:23:13.770629Z",
     "iopub.status.idle": "2026-10-10T20:23:13.787235Z",
     "shell.execute_reply": "2026-10-10T20:23:13.786188Z"
    }
   },
   "outputs": [],
   "source": [
    "class Head(nn.Module):\n",
    "    # one head of causal self-attention\n",
    "    def __init__(self, n_embd, head_size, block_size, dropout):\n",
    "        super().__init__()\n",
    "        self.key = nn.Linear(n_embd, head_size, bias=False)\n",
    "        self.query = nn.Linear(n_embd, head_size, bias=False)\n",
    "        self.value = nn.Linear(n_embd, head_size, bias=False)\n",
    "        self.register_buffer(\"tril\", torch.tril(torch.ones(block_size, block_size)))\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        self.last_att = None                                  # kept for visualisation\n",
    "\n",
    "    def forward(self, x):\n",
    "        B, T, C = x.shape\n",
    "        k, q, v = self.key(x), self.query(x), self.value(x)\n",
    "        att = q @ k.transpose(-2, -1) / math.sqrt(k.shape[-1])\n",
    "        att = att.masked_fill(self.tril[:T, :T] == 0, float(\"-inf\"))\n",
    "        att = F.softmax(att, dim=-1)\n",
    "        self.last_att = att.detach()\n",
    "        return self.dropout(att) @ v\n",
    "\n",
    "\n",
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self, n_embd, n_head, block_size, dropout):\n",
    "        super().__init__()\n",
    "        self.heads = nn.ModuleList([Head(n_embd, n_embd // n_head, block_size, dropout) for _ in range(n_head)])\n",
    "        self.proj = nn.Linear(n_embd, n_embd)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = torch.cat([h(x) for h in self.heads], dim=-1)   # concatenate the heads\n",
    "        return self.dropout(self.proj(out))\n",
    "\n",
    "\n",
    "class FeedForward(nn.Module):\n",
    "    def __init__(self, n_embd, dropout):\n",
    "        super().__init__()\n",
    "        self.net = nn.Sequential(nn.Linear(n_embd, 4 * n_embd), nn.GELU(),\n",
    "                                 nn.Linear(4 * n_embd, n_embd), nn.Dropout(dropout))\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.net(x)\n",
    "\n",
    "\n",
    "class Block(nn.Module):\n",
    "    def __init__(self, n_embd, n_head, block_size, dropout):\n",
    "        super().__init__()\n",
    "        self.ln1, self.ln2 = nn.LayerNorm(n_embd), nn.LayerNorm(n_embd)\n",
    "        self.sa = MultiHeadAttention(n_embd, n_head, block_size, dropout)\n",
    "        self.ffwd = FeedForward(n_embd, dropout)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x + self.sa(self.ln1(x))      # communicate\n",
    "        x = x + self.ffwd(self.ln2(x))    # compute\n",
    "        return x\n",
    "\n",
    "\n",
    "class TinyGPT(nn.Module):\n",
    "    def __init__(self, V, block_size, n_embd, n_head, n_layer, dropout):\n",
    "        super().__init__()\n",
    "        self.block_size = block_size\n",
    "        self.tok_emb = nn.Embedding(V, n_embd)\n",
    "        self.pos_emb = nn.Embedding(block_size, n_embd)\n",
    "        self.blocks = nn.Sequential(*[Block(n_embd, n_head, block_size, dropout) for _ in range(n_layer)])\n",
    "        self.ln_f = nn.LayerNorm(n_embd)\n",
    "        self.lm_head = nn.Linear(n_embd, V)\n",
    "\n",
    "    def forward(self, idx, targets=None):\n",
    "        B, T = idx.shape\n",
    "        x = self.tok_emb(idx) + self.pos_emb(torch.arange(T, device=idx.device))\n",
    "        logits = self.lm_head(self.ln_f(self.blocks(x)))          # (B, T, V)\n",
    "        loss = None\n",
    "        if targets is not None:\n",
    "            loss = F.cross_entropy(logits.view(B * T, -1), targets.view(B * T))\n",
    "        return logits, loss\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def generate(self, idx, max_new_tokens, temperature=1.0):\n",
    "        for _ in range(max_new_tokens):\n",
    "            logits, _ = self(idx[:, -self.block_size:])           # never more than block_size\n",
    "            probs = F.softmax(logits[:, -1, :] / temperature, dim=-1)\n",
    "            idx = torch.cat([idx, torch.multinomial(probs, 1)], dim=1)\n",
    "        return idx"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4cc1658",
   "metadata": {},
   "source": [
    "### Settings and a quick check\n",
    "\n",
    "Before training, the model knows nothing, so its loss should be close to $\\log|\\mathcal{V}| = \\log 65 \\approx 4.17$, the same as uniform guessing in notebook 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "98f4f6a7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:23:13.788947Z",
     "iopub.status.busy": "2026-10-10T20:23:13.788781Z",
     "iopub.status.idle": "2026-10-10T20:23:14.819889Z",
     "shell.execute_reply": "2026-10-10T20:23:14.818788Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.16 M parameters\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss at init 4.371   vs   log|V| = 4.174\n"
     ]
    }
   ],
   "source": [
    "if device == \"cuda\":      # Colab T4 / any GPU: ~2-3 minutes\n",
    "    cfg = dict(block_size=128, n_embd=192, n_head=6, n_layer=4, dropout=0.1,\n",
    "               batch_size=64, steps=3000, lr=1e-3, eval_interval=300)\n",
    "else:                     # CPU: ~3 minutes, smaller model and context\n",
    "    cfg = dict(block_size=64, n_embd=64, n_head=4, n_layer=3, dropout=0.0,\n",
    "               batch_size=32, steps=2500, lr=2e-3, eval_interval=250)\n",
    "\n",
    "model = TinyGPT(V, cfg[\"block_size\"], cfg[\"n_embd\"], cfg[\"n_head\"], cfg[\"n_layer\"], cfg[\"dropout\"]).to(device)\n",
    "print(f\"{sum(p.numel() for p in model.parameters()) / 1e6:.2f} M parameters\")\n",
    "\n",
    "xb, yb = get_batch(\"train\", cfg[\"batch_size\"], cfg[\"block_size\"])\n",
    "_, loss = model(xb, yb)\n",
    "print(f\"loss at init {loss.item():.3f}   vs   log|V| = {math.log(V):.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7c43b72",
   "metadata": {},
   "source": [
    "## 5. Training, with the same loop as for MNIST\n",
    "\n",
    "Forward pass, loss, `zero_grad`, `backward`, `step`. Every few hundred steps we also estimate the train and validation loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0399776b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:23:14.822445Z",
     "iopub.status.busy": "2026-10-10T20:23:14.821682Z",
     "iopub.status.idle": "2026-10-10T20:25:23.309890Z",
     "shell.execute_reply": "2026-10-10T20:25:23.309132Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step     1 | train 4.119 | val 4.121 |     1s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step   250 | train 2.314 | val 2.327 |    11s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step   500 | train 2.057 | val 2.111 |    41s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step   750 | train 1.901 | val 1.986 |    52s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step  1000 | train 1.780 | val 1.898 |    64s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step  1250 | train 1.716 | val 1.863 |    74s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step  1500 | train 1.661 | val 1.820 |    84s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step  1750 | train 1.599 | val 1.795 |    95s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step  2000 | train 1.607 | val 1.758 |   106s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step  2250 | train 1.582 | val 1.756 |   117s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step  2500 | train 1.562 | val 1.746 |   127s\n"
     ]
    }
   ],
   "source": [
    "@torch.no_grad()\n",
    "def estimate_loss(iters=30):\n",
    "    model.eval()\n",
    "    out = {}\n",
    "    for split in [\"train\", \"val\"]:\n",
    "        losses = [model(*get_batch(split, cfg[\"batch_size\"], cfg[\"block_size\"]))[1].item() for _ in range(iters)]\n",
    "        out[split] = sum(losses) / len(losses)\n",
    "    model.train()\n",
    "    return out\n",
    "\n",
    "opt = torch.optim.AdamW(model.parameters(), lr=cfg[\"lr\"])\n",
    "log = {\"step\": [], \"train\": [], \"val\": []}\n",
    "t0 = time.time()\n",
    "for step in range(1, cfg[\"steps\"] + 1):\n",
    "    xb, yb = get_batch(\"train\", cfg[\"batch_size\"], cfg[\"block_size\"])\n",
    "    _, loss = model(xb, yb)\n",
    "    opt.zero_grad(set_to_none=True)\n",
    "    loss.backward()\n",
    "    opt.step()\n",
    "    if step % cfg[\"eval_interval\"] == 0 or step == 1:\n",
    "        l = estimate_loss()\n",
    "        log[\"step\"].append(step); log[\"train\"].append(l[\"train\"]); log[\"val\"].append(l[\"val\"])\n",
    "        print(f\"step {step:5d} | train {l['train']:.3f} | val {l['val']:.3f} | {time.time() - t0:5.0f}s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7c752317",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:25:23.312420Z",
     "iopub.status.busy": "2026-10-10T20:25:23.311828Z",
     "iopub.status.idle": "2026-10-10T20:25:23.431225Z",
     "shell.execute_reply": "2026-10-10T20:25:23.429646Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(log[\"step\"], log[\"train\"], \"o-\", label=\"TinyGPT train\")\n",
    "plt.plot(log[\"step\"], log[\"val\"], \"o-\", label=\"TinyGPT val\")\n",
    "plt.axhline(2.48, color=\"r\", ls=\"--\", label=\"bigram model (notebook 4)\")\n",
    "plt.axhline(math.log(V), color=\"gray\", ls=\":\", label=\"uniform  log|V|\")\n",
    "plt.xlabel(\"step\"); plt.ylabel(\"cross-entropy loss\"); plt.legend(); plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f631c1ea",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:25:23.433853Z",
     "iopub.status.busy": "2026-10-10T20:25:23.433612Z",
     "iopub.status.idle": "2026-10-10T20:25:25.258684Z",
     "shell.execute_reply": "2026-10-10T20:25:25.257572Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================================================\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "BUCKINGHAM:\n",
      "Thou trop'reach a advised to house keep,\n",
      "In thou confess and all desire, end them lady\n",
      "The liek wele the done: I have how, was if age;\n",
      "I will have I though wert as though the many master?\n",
      "\n",
      "Sritherd:\n",
      "What it doth the prince, who being to comport\n",
      "With his him, Good hear? what you see, my man,\n",
      "The dight is, pitition to the death: but the power as my son the chard,\n",
      "Should be so, thou disc\n",
      "============================================================\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROMEO:\n",
      "Why, and I see that, I do thy revemal'd thus the preseiveded dive but and I\n",
      "am thee countronoud it telless people;\n",
      "And your word, for your seave breep we lord,\n",
      "With tumple to braw his purike an your honour,\n",
      "Phonest to corn the for in this all death,\n",
      "The soffeics over the bord and green\n",
      "To place,---no long'd which seap, I to Rome\n",
      "to deather thuman to Ere forgny I the cafford words.\n",
      "\n",
      "FLORD OF YORK:\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "for prompt in [\"\\n\", \"ROMEO:\\n\"]:\n",
    "    idx = torch.tensor([encode(prompt)], device=device)\n",
    "    print(\"=\" * 60)\n",
    "    print(decode(model.generate(idx, 400, temperature=0.8)[0].tolist()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b0f8ddf",
   "metadata": {},
   "source": [
    "Words, line breaks, speaker names and punctuation, all learned from raw characters with nothing but next-token prediction.\n",
    "\n",
    "## 6. Looking inside: what do the heads attend to?\n",
    "\n",
    "Each head in the first layer produces a $T \\times T$ attention matrix. Every row is a query position, and the columns show where it looks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9cf8194b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-10T20:25:25.261253Z",
     "iopub.status.busy": "2026-10-10T20:25:25.260766Z",
     "iopub.status.idle": "2026-10-10T20:25:26.351431Z",
     "shell.execute_reply": "2026-10-10T20:25:26.350515Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1680x450 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"KING RICHARD:\\nNow is the winter of our\"\n",
    "idx = torch.tensor([encode(prompt)], device=device)\n",
    "with torch.no_grad():\n",
    "    model(idx)\n",
    "\n",
    "layer = 0\n",
    "heads = model.blocks[layer].sa.heads\n",
    "fig, axes = plt.subplots(1, len(heads), figsize=(4.2 * len(heads), 4.5))\n",
    "labels = [c if c != \"\\n\" else \"\\\\n\" for c in prompt]\n",
    "for h, ax in enumerate(axes):\n",
    "    ax.imshow(heads[h].last_att[0].cpu(), cmap=\"viridis\")\n",
    "    ax.set_xticks(range(len(prompt))); ax.set_xticklabels(labels, fontsize=7)\n",
    "    ax.set_yticks(range(len(prompt))); ax.set_yticklabels(labels, fontsize=7)\n",
    "    ax.set_title(f\"layer {layer}, head {h}\")\n",
    "plt.tight_layout(); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f546989a",
   "metadata": {},
   "source": [
    "You will usually see a head that looks at the current or the previous character (a sharp diagonal), and heads that spread their attention over the last few characters or back to the start of the word. Your maps will look a bit different every run. Nobody programmed these patterns. The model learned them because they lower the loss.\n",
    "\n",
    "---\n",
    "\n",
    "### Exercises\n",
    "\n",
    "1. **Remove the mask.** Delete the `masked_fill` line in `Head` and train for 300 steps. The training loss drops a lot. Why is this cheating, and what happens when you generate text?\n",
    "2. **No positions.** Remove `self.pos_emb(...)` from `forward`. How much worse is the validation loss? Why can't attention tell positions apart by itself?\n",
    "3. **Bigger.** Double `n_embd` and `n_layer`. Count the parameters, time one step, and compare the final validation loss. This is where the cluster helps, see below.\n",
    "4. **Context length.** Train with `block_size=16` and with `block_size=128`. What can a model with a short context never learn?\n",
    "5. **One head or many.** Use `n_head=1` with the same `n_embd`. Compare the loss and the attention maps.\n",
    "\n",
    "### Running it on the cluster\n",
    "\n",
    "The same model is in `hpc_lab/04_tinygpt/train_tinygpt.py`. On an A100 or H100 you can train a model ten times bigger in the same time:\n",
    "\n",
    "```bash\n",
    "cd hpc_lab/04_tinygpt && mkdir -p logs\n",
    "sbatch train.sbatch --n-layer 6 --n-head 6 --n-embd 384 --block-size 256\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}