makemore_part5_cnn1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## makemore: part 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt # for making figures\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32033\n",
      "15\n",
      "['emma', 'olivia', 'ava', 'isabella', 'sophia', 'charlotte', 'mia', 'amelia']\n"
     ]
    }
   ],
   "source": [
    "# read in all the words\n",
    "words = open('names.txt', 'r').read().splitlines()\n",
    "print(len(words))\n",
    "print(max(len(w) for w in words))\n",
    "print(words[:8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k', 12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u', 22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z', 0: '.'}\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "# build the vocabulary of characters and mappings to/from integers\n",
    "chars = sorted(list(set(''.join(words))))\n",
    "stoi = {s:i+1 for i,s in enumerate(chars)}\n",
    "stoi['.'] = 0\n",
    "itos = {i:s for s,i in stoi.items()}\n",
    "vocab_size = len(itos)\n",
    "print(itos)\n",
    "print(vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# shuffle up the words\n",
    "import random\n",
    "random.seed(42)\n",
    "random.shuffle(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([182625, 8]) torch.Size([182625])\n",
      "torch.Size([22655, 8]) torch.Size([22655])\n",
      "torch.Size([22866, 8]) torch.Size([22866])\n"
     ]
    }
   ],
   "source": [
    "# build the dataset\n",
    "block_size = 8 # context length: how many characters do we take to predict the next one?\n",
    "\n",
    "def build_dataset(words):  \n",
    "  X, Y = [], []\n",
    "  \n",
    "  for w in words:\n",
    "    context = [0] * block_size\n",
    "    for ch in w + '.':\n",
    "      ix = stoi[ch]\n",
    "      X.append(context)\n",
    "      Y.append(ix)\n",
    "      context = context[1:] + [ix] # crop and append\n",
    "\n",
    "  X = torch.tensor(X)\n",
    "  Y = torch.tensor(Y)\n",
    "  print(X.shape, Y.shape)\n",
    "  return X, Y\n",
    "\n",
    "n1 = int(0.8*len(words))\n",
    "n2 = int(0.9*len(words))\n",
    "Xtr,  Ytr  = build_dataset(words[:n1])     # 80%\n",
    "Xdev, Ydev = build_dataset(words[n1:n2])   # 10%\n",
    "Xte,  Yte  = build_dataset(words[n2:])     # 10%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "................ --> y\n",
      "...............y --> u\n",
      "..............yu --> h\n",
      ".............yuh --> e\n",
      "............yuhe --> n\n",
      "...........yuhen --> g\n",
      "..........yuheng --> .\n",
      "................ --> d\n",
      "...............d --> i\n",
      "..............di --> o\n",
      ".............dio --> n\n",
      "............dion --> d\n",
      "...........diond --> r\n",
      "..........diondr --> e\n",
      ".........diondre --> .\n",
      "................ --> x\n",
      "...............x --> a\n",
      "..............xa --> v\n",
      ".............xav --> i\n",
      "............xavi --> e\n"
     ]
    }
   ],
   "source": [
    "for x,y in zip(Xtr[:20], Ytr[:20]):\n",
    "  print(''.join(itos[ix.item()] for ix in x), '-->', itos[y.item()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Near copy paste of the layers we have developed in Part 3\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class Linear:\n",
    "  \n",
    "  def __init__(self, fan_in, fan_out, bias=True):\n",
    "    #self.weight = torch.randn((fan_in, fan_out)) / fan_in**0.5 # note: kaiming init\n",
    "    self.weight = nn.Parameter(torch.empty(fan_in, fan_out))\n",
    "    nn.init.xavier_uniform_(self.weight) # note: xavier init\n",
    "    self.bias = torch.zeros(fan_out) if bias else None\n",
    "  \n",
    "  def __call__(self, x):\n",
    "    self.out = x @ self.weight\n",
    "    if self.bias is not None:\n",
    "      self.out += self.bias\n",
    "    return self.out\n",
    "  \n",
    "  def parameters(self):\n",
    "    return [self.weight] + ([] if self.bias is None else [self.bias])\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class BatchNorm1d:\n",
    "  \n",
    "  def __init__(self, dim, eps=1e-5, momentum=0.1):\n",
    "    self.eps = eps\n",
    "    self.momentum = momentum\n",
    "    self.training = True\n",
    "    # parameters (trained with backprop)\n",
    "    self.gamma = torch.ones(dim)\n",
    "    self.beta = torch.zeros(dim)\n",
    "    # buffers (trained with a running 'momentum update')\n",
    "    self.running_mean = torch.zeros(dim)\n",
    "    self.running_var = torch.ones(dim)\n",
    "  \n",
    "  def __call__(self, x):\n",
    "    # calculate the forward pass\n",
    "    if self.training:\n",
    "      if x.ndim == 2:\n",
    "        dim = 0\n",
    "      elif x.ndim == 3:\n",
    "        dim = (0,1)\n",
    "      xmean = x.mean(dim, keepdim=True) # batch mean\n",
    "      xvar = x.var(dim, keepdim=True) # batch variance\n",
    "    else:\n",
    "      xmean = self.running_mean\n",
    "      xvar = self.running_var\n",
    "    xhat = (x - xmean) / torch.sqrt(xvar + self.eps) # normalize to unit variance\n",
    "    self.out = self.gamma * xhat + self.beta\n",
    "    # update the buffers\n",
    "    if self.training:\n",
    "      with torch.no_grad():\n",
    "        self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * xmean\n",
    "        self.running_var = (1 - self.momentum) * self.running_var + self.momentum * xvar\n",
    "    return self.out\n",
    "  \n",
    "  def parameters(self):\n",
    "    return [self.gamma, self.beta]\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class Tanh:\n",
    "  def __call__(self, x):\n",
    "    self.out = torch.tanh(x)\n",
    "    return self.out\n",
    "  def parameters(self):\n",
    "    return []\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class ReLU:\n",
    "  def __call__(self, x):\n",
    "    self.out = torch.max(torch.tensor(0.0), x)\n",
    "    return self.out\n",
    "  \n",
    "  def parameters(self):\n",
    "    return []\n",
    "  \n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class Embedding:\n",
    "  \n",
    "  def __init__(self, num_embeddings, embedding_dim):\n",
    "    #self.weight = torch.randn((num_embeddings, embedding_dim))\n",
    "    self.weight = nn.Parameter(torch.empty(num_embeddings, embedding_dim))\n",
    "    nn.init.uniform_(self.weight, -0.5, 0.5)\n",
    "    \n",
    "  def __call__(self, IX):\n",
    "    self.out = self.weight[IX]\n",
    "    return self.out\n",
    "  \n",
    "  def parameters(self):\n",
    "    return [self.weight]\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class FlattenConsecutive:\n",
    "  \n",
    "  def __init__(self, n):\n",
    "    self.n = n\n",
    "    \n",
    "  def __call__(self, x):\n",
    "    B, T, C = x.shape\n",
    "    x = x.view(B, T//self.n, C*self.n)\n",
    "    if x.shape[1] == 1:\n",
    "      x = x.squeeze(1)\n",
    "    self.out = x\n",
    "    return self.out\n",
    "  \n",
    "  def parameters(self):\n",
    "    return []\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class Sequential:\n",
    "  \n",
    "  def __init__(self, layers):\n",
    "    self.layers = layers\n",
    "  \n",
    "  def __call__(self, x):\n",
    "    for layer in self.layers:\n",
    "      x = layer(x)\n",
    "    self.out = x\n",
    "    return self.out\n",
    "  \n",
    "  def parameters(self):\n",
    "    # get parameters of all layers and stretch them out into one list\n",
    "    return [p for layer in self.layers for p in layer.parameters()]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(42); # seed rng for reproducibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "76579\n"
     ]
    }
   ],
   "source": [
    "# original network\n",
    "# n_embd = 10 # the dimensionality of the character embedding vectors\n",
    "# n_hidden = 300 # the number of neurons in the hidden layer of the MLP\n",
    "# model = Sequential([\n",
    "#   Embedding(vocab_size, n_embd),\n",
    "#   FlattenConsecutive(8), Linear(n_embd * 8, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "#   Linear(n_hidden, vocab_size),\n",
    "# ])\n",
    "\n",
    "# hierarchical network\n",
    "n_embd = 24 # the dimensionality of the character embedding vectors\n",
    "n_hidden = 128 # the number of neurons in the hidden layer of the MLP\n",
    "model = Sequential([\n",
    "  Embedding(vocab_size, n_embd),\n",
    "  FlattenConsecutive(2), Linear(n_embd * 2, n_hidden, bias=False), BatchNorm1d(n_hidden), ReLU(), #Tanh(),\n",
    "  FlattenConsecutive(2), Linear(n_hidden*2, n_hidden, bias=False), BatchNorm1d(n_hidden), ReLU(), #Tanh(),\n",
    "  FlattenConsecutive(2), Linear(n_hidden*2, n_hidden, bias=False), BatchNorm1d(n_hidden), ReLU(), #Tanh(),\n",
    "  Linear(n_hidden, vocab_size),\n",
    "])\n",
    "\n",
    "# parameter init\n",
    "with torch.no_grad():\n",
    "  model.layers[-1].weight *= 0.1 # last layer make less confident\n",
    "\n",
    "parameters = model.parameters()\n",
    "print(sum(p.nelement() for p in parameters)) # number of parameters in total\n",
    "for p in parameters:\n",
    "  p.requires_grad = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      0/ 200000: train loss 3.3199 validation loss 3.2492\n",
      "  10000/ 200000: train loss 2.5022 validation loss 2.0602\n",
      "  20000/ 200000: train loss 2.8444 validation loss 2.4205\n",
      "  30000/ 200000: train loss 2.4409 validation loss 1.9362\n",
      "  40000/ 200000: train loss 2.2395 validation loss 1.7212\n",
      "  50000/ 200000: train loss 2.1802 validation loss 1.8193\n",
      "  60000/ 200000: train loss 1.8928 validation loss 1.6548\n",
      "  70000/ 200000: train loss 2.2642 validation loss 1.8958\n",
      "  80000/ 200000: train loss 1.9565 validation loss 1.8019\n",
      "  90000/ 200000: train loss 2.2754 validation loss 2.2142\n",
      " 100000/ 200000: train loss 2.1619 validation loss 1.7331\n",
      " 110000/ 200000: train loss 2.5923 validation loss 1.7021\n",
      " 120000/ 200000: train loss 2.3472 validation loss 1.6374\n",
      " 130000/ 200000: train loss 2.1313 validation loss 2.3025\n",
      " 140000/ 200000: train loss 2.2170 validation loss 1.7265\n",
      " 150000/ 200000: train loss 2.4162 validation loss 2.2005\n",
      " 160000/ 200000: train loss 2.2756 validation loss 2.3057\n",
      " 170000/ 200000: train loss 2.1045 validation loss 1.9247\n",
      " 180000/ 200000: train loss 2.0745 validation loss 1.8714\n",
      " 190000/ 200000: train loss 2.3591 validation loss 1.9465\n"
     ]
    }
   ],
   "source": [
    "# same optimization as last time\n",
    "max_steps = 200000\n",
    "batch_size = 32\n",
    "lossi = []\n",
    "lossi_val = []\n",
    "reg = 1e-4\n",
    "m_prev = {id(p): torch.zeros_like(p) for p in parameters}  # First moment\n",
    "v_prev = {id(p): torch.zeros_like(p) for p in parameters}  # Second \n",
    "beta1 = 0.9\n",
    "beta2 = 0.999\n",
    "epsilon = 1e-8\n",
    "max_norm = 2.0\n",
    "\n",
    "for i in range(max_steps):\n",
    "  \n",
    "  # minibatch construct\n",
    "  ix = torch.randint(0, Xtr.shape[0], (batch_size,))\n",
    "  Xb, Yb = Xtr[ix], Ytr[ix] # batch X,Y\n",
    "  \n",
    "  # forward pass\n",
    "  logits = model(Xb)\n",
    "  loss = F.cross_entropy(logits, Yb) # loss function\n",
    "  \n",
    "  for layer in model.layers:\n",
    "    if(isinstance(layer, Linear)):\n",
    "      loss += reg * torch.sum(layer.weight.data ** 2)\n",
    "\n",
    "  # backward pass\n",
    "  for p in parameters:\n",
    "    p.grad = None\n",
    "  loss.backward()\n",
    "\n",
    "  with torch.no_grad():\n",
    "    vix = torch.randint(0, Xdev.shape[0], (batch_size,))\n",
    "    Xbv, Ybv = Xdev[vix], Ydev[vix]\n",
    "    logits_val = model(Xbv)\n",
    "    loss_val = F.cross_entropy(logits_val, Ybv)\n",
    "  \n",
    "  # update: simple SGD\n",
    "  #lr = 0.1 if i < 150000 else 0.01 # step learning rate decay\n",
    "  if i < 40000:\n",
    "    lr = 1e-3\n",
    "  elif i < 80000:\n",
    "    lr = 1e-4\n",
    "  else:\n",
    "    lr = 1e-5\n",
    "\n",
    "  for p in parameters:\n",
    "    #p.data += -lr * p.grad\n",
    "    # -------- adam optimizer --------\n",
    "    t = i+1\n",
    "    torch.nn.utils.clip_grad_norm_(parameters, max_norm)\n",
    "    m_next = beta1*m_prev[id(p)] + + (1-beta1)*p.grad\n",
    "    v_next = beta2*v_prev[id(p)] + + (1-beta2)*p.grad**2\n",
    "\n",
    "    # Update moments\n",
    "    m_prev[id(p)] = m_next\n",
    "    v_prev[id(p)] = v_next\n",
    "    \n",
    "    hat_m = m_next/(1-beta1**t)\n",
    "    hat_v = v_next/(1-beta2**t)\n",
    "    p.data -= lr*hat_m/(torch.sqrt(hat_v)+epsilon)\n",
    "    # -------- adam optimizer --------\n",
    "\n",
    "\n",
    "  # track stats\n",
    "  if i % 10000 == 0: # print every once in a while\n",
    "    print(f'{i:7d}/{max_steps:7d}: train loss {loss.item():.4f} validation loss {loss_val.item():.4f}')\n",
    "  lossi.append(loss.log10().item())\n",
    "  lossi_val.append(loss_val.log10().item())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 6))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(torch.tensor(lossi[:18000]).view(-1, 1000).mean(1))\n",
    "plt.title('Training Loss')\n",
    "plt.xlabel('Iterations (batches)')\n",
    "plt.ylabel('Loss')\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(torch.tensor(lossi_val[:18000]).view(-1, 1000).mean(1))\n",
    "plt.title('Validation Loss')\n",
    "plt.xlabel('Iterations (batches)')\n",
    "plt.ylabel('Loss')\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "# put layers into eval mode (needed for batchnorm especially)\n",
    "for layer in model.layers:\n",
    "  layer.training = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 1.82260262966156\n",
      "val 1.9851127862930298\n"
     ]
    }
   ],
   "source": [
    "# evaluate the loss\n",
    "@torch.no_grad() # this decorator disables gradient tracking inside pytorch\n",
    "def split_loss(split):\n",
    "  x,y = {\n",
    "    'train': (Xtr, Ytr),\n",
    "    'val': (Xdev, Ydev),\n",
    "    'test': (Xte, Yte),\n",
    "  }[split]\n",
    "  logits = model(x)\n",
    "  loss = F.cross_entropy(logits, y)\n",
    "  print(split, loss.item())\n",
    "\n",
    "split_loss('train')\n",
    "split_loss('val')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### performance log\n",
    "\n",
    "- original (3 character context + 200 hidden neurons, 12K params): train 2.058, val 2.105\n",
    "- context: 3 -> 8 (22K params): train 1.918, val 2.027\n",
    "- flat -> hierarchical (22K params): train 1.941, val 2.029\n",
    "- fix bug in batchnorm: train 1.912, val 2.022\n",
    "- scale up the network: n_embd 24, n_hidden 128 (76K params): train 1.769, val 1.993\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise:\n",
    "I beat the model with a train loss of 1.8226, val loss of 1.9851 by using xavier initialization, regularization, ReLU activation, and smaller learning rates. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kailyn.\n",
      "kody.\n",
      "kamari.\n",
      "essa.\n",
      "amiyah.\n",
      "rei.\n",
      "alysia.\n",
      "mekary.\n",
      "jacnayou.\n",
      "jayziel.\n",
      "vaiane.\n",
      "shaiden.\n",
      "rheera.\n",
      "ohia.\n",
      "iyanigh.\n",
      "keega.\n",
      "aadhah.\n",
      "bitty.\n",
      "mcclanna.\n",
      "amisora.\n"
     ]
    }
   ],
   "source": [
    "# sample from the model\n",
    "for _ in range(20):\n",
    "    \n",
    "    out = []\n",
    "    context = [0] * block_size # initialize with all ...\n",
    "    while True:\n",
    "      # forward pass the neural net\n",
    "      logits = model(torch.tensor([context]))\n",
    "      probs = F.softmax(logits, dim=1)\n",
    "      # sample from the distribution\n",
    "      ix = torch.multinomial(probs, num_samples=1).item()\n",
    "      # shift the context window and track the samples\n",
    "      context = context[1:] + [ix]\n",
    "      out.append(ix)\n",
    "      # if we sample the special '.' token, break\n",
    "      if ix == 0:\n",
    "        break\n",
    "    \n",
    "    print(''.join(itos[i] for i in out)) # decode and print the generated word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Next time:\n",
    "Why convolutions? Brief preview/hint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x,y in zip(Xtr[7:15], Ytr[7:15]):\n",
    "  print(''.join(itos[ix.item()] for ix in x), '-->', itos[y.item()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# forward a single example:\n",
    "logits = model(Xtr[[7]])\n",
    "logits.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# forward all of them\n",
    "logits = torch.zeros(8, 27)\n",
    "for i in range(8):\n",
    "  logits[i] = model(Xtr[[7+i]])\n",
    "logits.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convolution is a \"for loop\"\n",
    "# allows us to forward Linear layers efficiently over space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (myenv)",
   "language": "python",
   "name": "myenv"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}