makemore_wavenet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2023-11-06T08:23:03.402057Z",
     "start_time": "2023-11-06T08:23:02.829724Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "words = open(\"names.txt\", \"r\").read().splitlines()\n",
    "chars = sorted(list(set(\"\".join(words))))\n",
    "stoi = {c: i for i, c in enumerate(chars)}\n",
    "stoi['.'] = 0\n",
    "itos = {i: c for c, i in stoi.items()}\n",
    "\n",
    "\n",
    "# build the dataset\n",
    "\n",
    "def build_dataset(words, block_size=8):\n",
    "    X, Y = [], []\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]\n",
    "    return torch.tensor(X), torch.tensor(Y)\n",
    "\n",
    "\n",
    "import random\n",
    "\n",
    "random.seed(42)\n",
    "random.shuffle(words)\n",
    "n1 = int(len(words) * 0.8)\n",
    "n2 = int(len(words) * 0.9)\n",
    "\n",
    "Xtrain, Ytrain = build_dataset(words[:n1])\n",
    "Xdev, Ydev = build_dataset(words[n1:n2])\n",
    "Xtest, Ytest = build_dataset(words[n2:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "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 .\n",
      "......x. v\n",
      ".....x.v i\n",
      "....x.vi e\n"
     ]
    }
   ],
   "source": [
    "for x, y in zip(Xtrain[:20], Ytrain[:20]):\n",
    "    print(\"\".join(itos[i.item()] for i in x), itos[y.item()])"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-11-06T07:15:05.539702Z",
     "start_time": "2023-11-06T07:15:05.530716Z"
    }
   },
   "id": "e00beefc47d98f4c"
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 76579\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "g = torch.Generator().manual_seed(42)\n",
    "\n",
    "\n",
    "class Linear:\n",
    "    def __init__(self, fan_in, fan_out, bias=True):\n",
    "        self.W = torch.randn(fan_in, fan_out, generator=g) / fan_in ** 0.5\n",
    "        self.b = torch.zeros(fan_out) if bias else None\n",
    "\n",
    "    def __call__(self, x):\n",
    "        self.out = x @ self.W\n",
    "        if self.b is not None:\n",
    "            self.out += self.b\n",
    "        return self.out\n",
    "\n",
    "    def parameters(self):\n",
    "        return [self.W] + ([] if self.b is None else [self.b])\n",
    "\n",
    "\n",
    "class BatchNorm:\n",
    "    def __init__(self, n_in, eps=1e-5, momentum=0.1):\n",
    "        self.eps = eps\n",
    "        self.momentum = momentum\n",
    "        self.training = True\n",
    "        self.n_in = n_in\n",
    "        self.gamma = torch.ones(n_in)\n",
    "        self.beta = torch.zeros(n_in)\n",
    "        self.running_mean = torch.zeros(n_in)\n",
    "        self.running_var = torch.ones(n_in)\n",
    "\n",
    "    def __call__(self, x):\n",
    "        if self.training:\n",
    "            if x.ndim == 2:\n",
    "                dim = 0\n",
    "            elif x.ndim == 3:\n",
    "                dim = (0, 1)\n",
    "            else:\n",
    "                raise ValueError(\"expected 2D or 3D input (got {}D input)\".format(x.ndim))\n",
    "            xmean = x.mean(dim=dim, keepdim=True)\n",
    "            xvar = x.var(dim=dim, keepdim=True)\n",
    "        else:\n",
    "            xmean = self.running_mean\n",
    "            xvar = self.running_var\n",
    "        xhat = (x - xmean) / (xvar + self.eps) ** 0.5\n",
    "        self.out = self.gamma * xhat + self.beta\n",
    "        if self.training:\n",
    "            with torch.no_grad():\n",
    "                self.running_mean = self.momentum * xmean + (1 - self.momentum) * self.running_mean\n",
    "                self.running_var = self.momentum * xvar + (1 - self.momentum) * self.running_var\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",
    "\n",
    "    def parameters(self):\n",
    "        return []\n",
    "\n",
    "class Embedding:\n",
    "    \n",
    "    def __init__(self, num_embeddings, embedding_dim, padding_idx=None, max_norm=None,\n",
    "                 norm_type=2.0, scale_grad_by_freq=False, sparse=False, _weight=None):\n",
    "        self.weights = torch.randn(num_embeddings, embedding_dim, generator=g)\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        self.out = self.weights[x]\n",
    "        return self.out\n",
    "    \n",
    "    def parameters(self):\n",
    "        return [self.weights]\n",
    "        \n",
    "class Flatten:\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",
    "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",
    "        return x\n",
    "    \n",
    "    def parameters(self):\n",
    "        return [p for layer in self.layers for p in layer.parameters()]\n",
    "    \n",
    "n_embd = 24\n",
    "n_hidden = 128\n",
    "block_size = 8\n",
    "vocab_size = 27\n",
    "\n",
    "model = Sequential([\n",
    "    Embedding(vocab_size, n_embd),\n",
    "    Flatten(2),Linear(n_embd *2, n_hidden, bias=False), BatchNorm(n_hidden), Tanh(),\n",
    "    Flatten(2),Linear(n_hidden *2, n_hidden, bias=False), BatchNorm(n_hidden), Tanh(),\n",
    "    Flatten(2),Linear(n_hidden *2, n_hidden, bias=False), BatchNorm(n_hidden), Tanh(),\n",
    "    Linear(n_hidden, vocab_size)\n",
    "])\n",
    "\n",
    "with torch.no_grad():\n",
    "    # last layer: make less confident\n",
    "    model.layers[-1].W *= 0.1\n",
    "    for layer in model.layers[:-1]:\n",
    "        if isinstance(layer, Linear):\n",
    "            layer.W *= 5 / 3\n",
    "            if layer.b is not None:\n",
    "                layer.b.zero_()\n",
    "\n",
    "parameters = model.parameters()\n",
    "print(f\"number of parameters: {sum(p.numel() for p in parameters)}\")\n",
    "for p in parameters:\n",
    "    p.requires_grad_(True)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-11-06T08:42:41.678137Z",
     "start_time": "2023-11-06T08:42:41.668933Z"
    }
   },
   "id": "c5c0c644b7fe440d"
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 0, loss = 3.306053638458252\n",
      "step = 1000, loss = 2.105940580368042\n",
      "step = 2000, loss = 2.4838509559631348\n",
      "step = 3000, loss = 2.028949737548828\n",
      "step = 4000, loss = 1.8574471473693848\n",
      "step = 5000, loss = 2.165806531906128\n",
      "step = 6000, loss = 2.3529350757598877\n",
      "step = 7000, loss = 1.754045844078064\n",
      "step = 8000, loss = 2.1484670639038086\n",
      "step = 9000, loss = 2.4413187503814697\n",
      "step = 10000, loss = 2.1495635509490967\n",
      "step = 11000, loss = 2.4444284439086914\n",
      "step = 12000, loss = 2.2164132595062256\n",
      "step = 13000, loss = 2.120452880859375\n",
      "step = 14000, loss = 1.9721102714538574\n",
      "step = 15000, loss = 1.7776589393615723\n",
      "step = 16000, loss = 2.108551025390625\n",
      "step = 17000, loss = 1.6686543226242065\n",
      "step = 18000, loss = 2.9140734672546387\n",
      "step = 19000, loss = 1.8099478483200073\n"
     ]
    }
   ],
   "source": [
    "max_steps = 20000\n",
    "batch_size = 32\n",
    "lossi = []\n",
    "ud = []\n",
    "\n",
    "for step in range(max_steps):\n",
    "    # sample a batch\n",
    "    i = torch.randint(0, Xtrain.shape[0], (batch_size,), generator=g)\n",
    "    xb, yb = Xtrain[i], Ytrain[i]\n",
    "    \n",
    "    # forward pass\n",
    "    logits = model(xb)\n",
    "    loss = torch.nn.functional.cross_entropy(logits, yb)\n",
    "\n",
    "    # backward pass\n",
    "    for layer in model.layers:\n",
    "        layer.out.retain_grad()\n",
    "\n",
    "    for p in parameters:\n",
    "        p.grad = None\n",
    "    loss.backward()\n",
    "\n",
    "    # update \n",
    "    lr = 0.1 if step < 10000 else 0.01\n",
    "    for p in parameters:\n",
    "        p.data -= lr * p.grad\n",
    "    if step % 1000 == 0:\n",
    "        print(f\"step = {step}, loss = {loss.item()}\")\n",
    "    with torch.no_grad():\n",
    "        ud.append([(lr * p.grad.std() / p.data.std()).log10().item() for p in parameters if p.grad is not None])\n",
    "    lossi.append(loss.item())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-11-06T08:46:26.596339Z",
     "start_time": "2023-11-06T08:42:46.427673Z"
    }
   },
   "id": "9a73a816ad1ea915"
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Embedding torch.Size([32, 8, 10])\n",
      "Flatten torch.Size([32, 4, 20])\n",
      "Linear torch.Size([32, 4, 100])\n",
      "BatchNorm torch.Size([32, 4, 100])\n",
      "Tanh torch.Size([32, 4, 100])\n",
      "Flatten torch.Size([32, 2, 200])\n",
      "Linear torch.Size([32, 2, 100])\n",
      "BatchNorm torch.Size([32, 2, 100])\n",
      "Tanh torch.Size([32, 2, 100])\n",
      "Flatten torch.Size([32, 200])\n",
      "Linear torch.Size([32, 100])\n",
      "BatchNorm torch.Size([32, 100])\n",
      "Tanh torch.Size([32, 100])\n",
      "Linear torch.Size([32, 27])\n"
     ]
    }
   ],
   "source": [
    "for layer in model.layers:\n",
    "    print(layer.__class__.__name__, layer.out.shape)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-11-06T08:27:08.420604Z",
     "start_time": "2023-11-06T08:27:08.415945Z"
    }
   },
   "id": "56e2d641b4d59876"
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "outputs": [
    {
     "data": {
      "text/plain": "[<matplotlib.lines.Line2D at 0x7fdd081fc9a0>]"
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(torch.tensor(lossi).view(-1, 100).mean(dim=1))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-11-06T08:46:47.118453Z",
     "start_time": "2023-11-06T08:46:46.991860Z"
    }
   },
   "id": "264948812e1b71e6"
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [],
   "source": [
    "# put layers into eval mode\n",
    "for layer in model.layers:\n",
    "    layer.training = False"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-11-06T07:04:40.970465Z",
     "start_time": "2023-11-06T07:04:40.964798Z"
    }
   },
   "id": "e963a5aaf3f9ee1"
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 1.9949228763580322\n",
      "dev 2.032686471939087\n"
     ]
    }
   ],
   "source": [
    "# eval the loss\n",
    "\n",
    "@torch.no_grad()  # no gradient computation\n",
    "def split_loss(split):\n",
    "    x, y = {\n",
    "        'train': (Xtrain, Ytrain),\n",
    "        'dev': (Xdev, Ydev),\n",
    "        'test': (Xtest, Ytest)\n",
    "    }[split]\n",
    "    logits = model(x)\n",
    "    loss = torch.nn.functional.cross_entropy(logits, y)\n",
    "    print(split, loss.item())\n",
    "\n",
    "\n",
    "split_loss('train')\n",
    "split_loss('dev')"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-11-06T08:46:32.355583Z",
     "start_time": "2023-11-06T08:46:30.855146Z"
    }
   },
   "id": "e30f018be0f0a70a"
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len.\n",
      "joely.\n",
      "wish.\n",
      "mer.\n",
      "c.\n",
      "vri.\n",
      "zeco.\n",
      "h.\n",
      "p.\n",
      "or.\n",
      "s.\n",
      "me.\n",
      "y.\n",
      "d.\n",
      "bem.\n",
      "xeniv.\n",
      "ny.\n",
      "rjynyon.\n",
      "ri.\n",
      "jevi.\n"
     ]
    }
   ],
   "source": [
    "# sample from the model\n",
    "for _ in range(20):\n",
    "    out = []\n",
    "    context = [0] * block_size\n",
    "    while True:\n",
    "        logits = model(torch.tensor([context]))\n",
    "        p = torch.nn.functional.softmax(logits, dim=-1)\n",
    "        ix = torch.multinomial(p, 1).item()\n",
    "        context = context[1:] + [ix]\n",
    "        out.append(ix)\n",
    "        if ix == 0:\n",
    "            break\n",
    "    print(\"\".join(itos[i] for i in out))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-11-06T07:08:07.968225Z",
     "start_time": "2023-11-06T07:08:07.948941Z"
    }
   },
   "id": "ea46f532ea39255b"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}