wavenet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch \n",
    "from torch.nn import functional as F\n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "from sys import exit as e\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (8, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32033\n"
     ]
    }
   ],
   "source": [
    "words = open(\"./data/names.txt\", 'r').read().splitlines()\n",
    "print(len(words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique_char = sorted(list(set(''.join(words))))\n",
    "\n",
    "stoi = {c:i+1 for i, c in enumerate(unique_char)}\n",
    "stoi['.'] = 0\n",
    "itos = {i:s for s, i in stoi.items()}\n",
    "vocab_size = len(stoi)\n",
    "vocab_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([182625, 8]) torch.Size([22655, 8]) torch.Size([22866, 8])\n",
      "torch.Size([182625]) torch.Size([22655]) torch.Size([22866])\n"
     ]
    }
   ],
   "source": [
    "def build_dataset(words, block_size, stoi):\n",
    "  xs = []\n",
    "  ys = []\n",
    "  for word in words:\n",
    "    context = [0] * block_size\n",
    "    for ch in word + '.':\n",
    "      xs.append(context)\n",
    "      ys.append(stoi[ch])\n",
    "      # print(\"x: \", ''.join([itos[c] for c in context]))\n",
    "      # print(\"label: \", ch)\n",
    "      context = context[1:] + [stoi[ch]]\n",
    "  \n",
    "  xs = torch.tensor(xs)\n",
    "  ys = torch.tensor(ys)\n",
    "  return xs, ys\n",
    "\n",
    "import random \n",
    "random.seed(42)\n",
    "random.shuffle(words)\n",
    "\n",
    "t1 = int(0.8 * len(words))\n",
    "t2 = int(0.9 * len(words))\n",
    "\n",
    "\n",
    "\n",
    "block_size = 8\n",
    "Xtr, ytr = build_dataset(words[:t1], block_size=block_size, stoi=stoi)\n",
    "Xval, yval = build_dataset(words[t1:t2], block_size=block_size, stoi=stoi)\n",
    "Xte, yte = build_dataset(words[t2:], block_size=block_size, stoi=stoi)\n",
    "\n",
    "print(Xtr.shape, Xval.shape, Xte.shape)\n",
    "print(ytr.shape, yval.shape, yte.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Linear:\n",
    "  def __init__(self, fan_in, fan_out, bias=True) -> None:\n",
    "    self.weight = torch.randn((fan_in, fan_out)) / fan_in ** 0.5\n",
    "    self.bias = torch.randn((fan_out)) if bias else None\n",
    "    self.is_bias = bias\n",
    "  \n",
    "  def __call__(self, x):\n",
    "    self.out = x @ self.weight \n",
    "    if self.is_bias:\n",
    "      self.out += self.bias\n",
    "    \n",
    "    return self.out \n",
    "  \n",
    "  def parameters(self):\n",
    "    return [self.weight] + ([] if not self.is_bias else [self.bias])\n",
    "  \n",
    "class Tanh:\n",
    "  def __call__(self, x) -> torch.Tensor:\n",
    "    self.out = F.tanh(x)\n",
    "    return self.out \n",
    "  \n",
    "  def parameters(self):\n",
    "    return []\n",
    "\n",
    "class BatchNorm1d:\n",
    "  def __init__(self, num_features, eps=1e-5, momentum=0.1) -> None:\n",
    "    self.training = True \n",
    "    self.eps = eps \n",
    "    self.momentum = momentum\n",
    "\n",
    "    self.gamma = torch.ones(num_features)\n",
    "    self.beta = torch.zeros(num_features)\n",
    "\n",
    "    self.running_mean = torch.zeros((num_features))\n",
    "    self.running_var = torch.ones((num_features))\n",
    "\n",
    "  def __call__(self, x):\n",
    "    if self.training:\n",
    "\n",
    "      if x.ndim == 2:\n",
    "        dim = 0 \n",
    "      elif x.ndim == 3:\n",
    "        dim = (0, 1)\n",
    "      mu = x.mean(dim, keepdim=True)\n",
    "      var = x.var(dim, keepdim=True)\n",
    "    else:\n",
    "      mu = self.running_mean\n",
    "      var = self.running_var\n",
    "    \n",
    "    xhat = ((x - mu) * (var + self.eps)**-0.5) \n",
    "    self.out = xhat * self.gamma + self.beta\n",
    "    if self.training:\n",
    "      with torch.no_grad():\n",
    "        self.running_mean = (1-self.momentum) * self.running_mean + self.momentum * mu\n",
    "        self.running_var = (1-self.momentum) * self.running_var + self.momentum * var\n",
    "    return self.out\n",
    "  \n",
    "  def parameters(self):\n",
    "    return [self.beta, self.gamma]\n",
    "\n",
    "\n",
    "class Embedding:\n",
    "  def __init__(self, num_embeddings, embedding_dim) -> None:\n",
    "    self.weight = torch.randn((num_embeddings, embedding_dim))\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",
    "  def __init__(self, n) -> None:\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",
    "\n",
    "    if x.shape[1] == 1:\n",
    "      x = x.squeeze(1)\n",
    "\n",
    "    self.out = x\n",
    "    return self.out \n",
    "  \n",
    "  def parameters(self):\n",
    "    return []\n",
    "  \n",
    "class Sequential:\n",
    "  def __init__(self, layers) -> None:\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",
    "    return [p for layer in self.layers for p in layer.parameters()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f6db0fd1c10>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.manual_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "76579\n"
     ]
    }
   ],
   "source": [
    "n_embed = 24\n",
    "n_hidden = 128 \n",
    "\n",
    "layers = [\n",
    "  Embedding(vocab_size, n_embed), \n",
    "  FlattenConsecutive(2), Linear(n_embed * 2, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(), \n",
    "  FlattenConsecutive(2), Linear(n_hidden * 2, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(), \n",
    "  FlattenConsecutive(2), Linear(n_hidden * 2, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(), \n",
    "  Linear(n_hidden, vocab_size), \n",
    "]\n",
    "\n",
    "model = Sequential(layers)\n",
    "\n",
    "with torch.no_grad():\n",
    "  layers[-1].weight *= 0.1\n",
    "\n",
    "parameters = model.parameters()\n",
    "print(sum(p.nelement() for p in parameters))\n",
    "for p in parameters:\n",
    "  p.requires_grad=True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0/200000:  4.6212\n",
      "10000/200000:  2.1471\n",
      "20000/200000:  1.5086\n",
      "30000/200000:  2.1991\n",
      "40000/200000:  2.0678\n",
      "50000/200000:  1.8112\n",
      "60000/200000:  2.3209\n",
      "70000/200000:  1.9109\n",
      "80000/200000:  1.5972\n",
      "90000/200000:  1.8337\n",
      "100000/200000:  2.0202\n",
      "110000/200000:  2.2036\n",
      "120000/200000:  1.8095\n",
      "130000/200000:  2.1152\n",
      "140000/200000:  1.8250\n",
      "150000/200000:  2.0178\n",
      "160000/200000:  2.1732\n",
      "170000/200000:  1.8397\n"
     ]
    }
   ],
   "source": [
    "max_steps = 200000\n",
    "batch_size = 32 \n",
    "lossi = []\n",
    "\n",
    "for i in range(max_steps):\n",
    "  ix = torch.randint(0, Xtr.shape[0], size=(batch_size, ))\n",
    "  Xb, yb = Xtr[ix], ytr[ix]\n",
    "\n",
    "  logits = model(Xb)\n",
    "  loss = F.cross_entropy(logits, yb)\n",
    "\n",
    "  for p in parameters:\n",
    "    p.grad = None \n",
    "\n",
    "  loss.backward()\n",
    "  \n",
    "  lr = 0.1 if i < 100000 else 0.01 \n",
    "  for p in parameters:\n",
    "    p.data += -lr * p.grad\n",
    "\n",
    "  if i % 10000 == 0:\n",
    "    print(f\"{i}/{max_steps}: {loss.item(): .4f}\")\n",
    "  \n",
    "  lossi.append(loss.log10().item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Embedding: torch.Size([32, 8, 10])\n",
      "FlattenConsecutive: torch.Size([32, 4, 20])\n",
      "Linear: torch.Size([32, 4, 68])\n",
      "BatchNorm1d: torch.Size([32, 4, 68])\n",
      "BatchNorm1d: torch.Size([1, 1, 68])\n",
      "BatchNorm1d: torch.Size([1, 1, 68])\n",
      "Tanh: torch.Size([32, 4, 68])\n",
      "FlattenConsecutive: torch.Size([32, 2, 136])\n",
      "Linear: torch.Size([32, 2, 68])\n",
      "BatchNorm1d: torch.Size([32, 2, 68])\n",
      "BatchNorm1d: torch.Size([1, 1, 68])\n",
      "BatchNorm1d: torch.Size([1, 1, 68])\n",
      "Tanh: torch.Size([32, 2, 68])\n",
      "FlattenConsecutive: torch.Size([32, 136])\n",
      "Linear: torch.Size([32, 68])\n",
      "BatchNorm1d: torch.Size([32, 68])\n",
      "BatchNorm1d: torch.Size([1, 68])\n",
      "BatchNorm1d: torch.Size([1, 68])\n",
      "Tanh: torch.Size([32, 68])\n",
      "Linear: torch.Size([32, 27])\n"
     ]
    }
   ],
   "source": [
    "for layer in model.layers:\n",
    "  print(f\"{layer.__class__.__name__}: {layer.out.shape}\")\n",
    "  if isinstance(layer, BatchNorm1d):\n",
    "    print(f\"{layer.__class__.__name__}: {layer.running_mean.shape}\")\n",
    "    print(f\"{layer.__class__.__name__}: {layer.running_var.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f08b07ddd20>]"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(torch.tensor(lossi).view(-1, 1000).mean(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 1.9210453033447266\n",
      "val 2.026059627532959\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': (Xval, yval),\n",
    "    'test': (Xte, yte),\n",
    "  }[split]\n",
    "  \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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "telan.\n",
      "rivel.\n",
      "jaleix.\n",
      "zeyelle.\n",
      "isabe.\n",
      "sifran.\n",
      "azlyn.\n",
      "jkerrie.\n",
      "kiti.\n",
      "norsandra.\n",
      "aaita.\n",
      "brek.\n",
      "alliza.\n",
      "olivere.\n",
      "laikynu.\n",
      "dezi.\n",
      "brixtage.\n",
      "jaynie.\n",
      "lami.\n",
      "silor.\n"
     ]
    }
   ],
   "source": [
    "# sample from the model\n",
    "\n",
    "for _ in range(20):\n",
    "\n",
    "    out = []\n",
    "    context = [0] * block_size # initialize with all ...\n",
    "    while True:\n",
    "      # forward pass\n",
    "      logits = model(torch.tensor([context]))\n",
    "      # sample\n",
    "      probs = F.softmax(logits, dim=1)\n",
    "      ix = torch.multinomial(probs, num_samples=1).item()\n",
    "      context = context[1:] + [ix]\n",
    "      out.append(ix)\n",
    "      if ix == 0:\n",
    "        break\n",
    "\n",
    "    print(''.join(itos[i] for i in out))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}