3_mlp_with_context_length.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from names_dataset import NameDataset\n",
    "import re\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn.functional as F\n",
    "import random\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "SEED = 42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "nd = NameDataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "country_codes = [\"US\", \"CA\", \"GB\", \"IN\"]            # USA, Canada, Great Britain, India"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = set()\n",
    "dataset_size = 50000\n",
    "for code in country_codes:\n",
    "    data = nd.get_top_names(n=dataset_size, country_alpha2=code)\n",
    "    dataset.update(set(data[code]['M'] + data[code]['F']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43231"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# clean and make each name 1 word\n",
    "names = list()\n",
    "for name in dataset:\n",
    "    if re.match(r\"^[A-Za-z\\s]+$\", name):            # only consider names with english alphabets\n",
    "        for i in name.split():\n",
    "            if len(i)>1: names.append(i.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "chars = sorted(list(set(''.join(names))))\n",
    "ctoi = {k:idx+1 for idx, k in enumerate(chars)}\n",
    "ctoi['.'] = 0\n",
    "itoc = {v:k for k,v in ctoi.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8, 'i': 9, 'j': 10, 'k': 11, 'l': 12, 'm': 13, 'n': 14, 'o': 15, 'p': 16, 'q': 17, 'r': 18, 's': 19, 't': 20, 'u': 21, 'v': 22, 'w': 23, 'x': 24, 'y': 25, 'z': 26, '.': 0}\n"
     ]
    }
   ],
   "source": [
    "print(ctoi)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi Layer Perceptron\n",
    "implementation of (Bengio et al. 2003 Neural Probabilistic LM paper)[https://www.jmlr.org/papers/volume3/bengio03a/bengio03a.pdf]\n",
    "\n",
    "![Neural Probabilistic LM](images/neural_prob_LM.png)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "context_length = 3  # block size\n",
    "x, y = [], []\n",
    "for name in names:\n",
    "    # print(name)\n",
    "    context = [0] * context_length\n",
    "    for c in name + '.':\n",
    "        idx = ctoi[c]\n",
    "        x.append(context)\n",
    "        y.append(idx)\n",
    "        # print(''.join([itoc[i] for i in context]), '------>', itoc[idx])\n",
    "        context = context[1:] + [idx]\n",
    "\n",
    "x = torch.tensor(x)\n",
    "y = torch.tensor(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 0,  0,  0],\n",
       "         [ 0,  0, 14],\n",
       "         [ 0, 14,  5],\n",
       "         [14,  5,  7],\n",
       "         [ 5,  7, 26]]),\n",
       " tensor([14,  5,  7, 26, 26]))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:5], y[:5]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Embedding (lookup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create a 2 dimensional lookup for the 27 chars we have\n",
    "C = torch.randn((27,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0.1850, -1.9612])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0.1850, -1.9612])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F.one_hot(torch.tensor(5), num_classes=27).float()@C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.4619, -0.7100],\n",
       "        [-1.0147,  0.2709],\n",
       "        [ 0.1850, -1.9612]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[[3,4,5]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0,  0,  0],\n",
       "        [ 0,  0, 14],\n",
       "        [ 0, 14,  5],\n",
       "        [14,  5,  7]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([4, 3])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:4].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[ 1.3335,  1.1781],\n",
       "         [ 1.3335,  1.1781],\n",
       "         [ 1.3335,  1.1781]],\n",
       "\n",
       "        [[ 1.3335,  1.1781],\n",
       "         [ 1.3335,  1.1781],\n",
       "         [ 0.7193, -0.4586]],\n",
       "\n",
       "        [[ 1.3335,  1.1781],\n",
       "         [ 0.7193, -0.4586],\n",
       "         [ 0.1850, -1.9612]],\n",
       "\n",
       "        [[ 0.7193, -0.4586],\n",
       "         [ 0.1850, -1.9612],\n",
       "         [ 0.2678, -1.6484]]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[x[:4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([4, 3, 2])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[x[:4]].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([306991, 3, 2])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emb = C[x]\n",
    "emb.shape"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## neural network"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### detail"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 3])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample = x[:5]\n",
    "sample.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 3, 2])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# input to the model will be embeddings of the input\n",
    "model_inp = C[sample]\n",
    "model_inp.shape"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the shape is ==> batch_size * context_len * embed_dim. That means, for each sample, the input shape fed to the nn is context_len * embed_dim (eg. 3*2)\n",
    "\n",
    "Let's create an input layer that has context_len * embed_dim neurons and 100 neurons in the hidden layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "W1 = torch.randn((6,100))\n",
    "b1 = torch.randn((100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "mat1 and mat2 shapes cannot be multiplied (15x2 and 6x100)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[24], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39m# we have to do Wx+b for each sample. but we can't as shown below\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m model_inp \u001b[39m@\u001b[39;49m W1 \u001b[39m+\u001b[39m b1\n",
      "\u001b[0;31mRuntimeError\u001b[0m: mat1 and mat2 shapes cannot be multiplied (15x2 and 6x100)"
     ]
    }
   ],
   "source": [
    "# we have to do Wx+b for each sample. but we can't as shown below\n",
    "model_inp @ W1 + b1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The error is because we cannot do matrix multiplication for 5x3x2 and 6x100. We have to concatenate all the dimensions for each input sample.\n",
    "\n",
    "i.e, we have to convert 5x3x2 to 5x6.\n",
    "\n",
    "There are multiple ways to do this but the most efficient(space & time) is torch has view() that doesn't create a new tensor but changes the dimension using the same memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[ 1.3335,  1.1781],\n",
       "         [ 1.3335,  1.1781],\n",
       "         [ 1.3335,  1.1781]],\n",
       "\n",
       "        [[ 1.3335,  1.1781],\n",
       "         [ 1.3335,  1.1781],\n",
       "         [ 0.7193, -0.4586]],\n",
       "\n",
       "        [[ 1.3335,  1.1781],\n",
       "         [ 0.7193, -0.4586],\n",
       "         [ 0.1850, -1.9612]],\n",
       "\n",
       "        [[ 0.7193, -0.4586],\n",
       "         [ 0.1850, -1.9612],\n",
       "         [ 0.2678, -1.6484]],\n",
       "\n",
       "        [[ 0.1850, -1.9612],\n",
       "         [ 0.2678, -1.6484],\n",
       "         [ 0.4222,  0.8013]]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_inp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.3335,  1.1781,  1.3335,  1.1781,  1.3335,  1.1781],\n",
       "        [ 1.3335,  1.1781,  1.3335,  1.1781,  0.7193, -0.4586],\n",
       "        [ 1.3335,  1.1781,  0.7193, -0.4586,  0.1850, -1.9612],\n",
       "        [ 0.7193, -0.4586,  0.1850, -1.9612,  0.2678, -1.6484],\n",
       "        [ 0.1850, -1.9612,  0.2678, -1.6484,  0.4222,  0.8013]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# one naive way -\n",
    "torch.cat([model_inp[:, 0, :], model_inp[:, 1, :], model_inp[:, 2, :]], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.3335,  1.1781,  1.3335,  1.1781,  1.3335,  1.1781],\n",
       "        [ 1.3335,  1.1781,  1.3335,  1.1781,  0.7193, -0.4586],\n",
       "        [ 1.3335,  1.1781,  0.7193, -0.4586,  0.1850, -1.9612],\n",
       "        [ 0.7193, -0.4586,  0.1850, -1.9612,  0.2678, -1.6484],\n",
       "        [ 0.1850, -1.9612,  0.2678, -1.6484,  0.4222,  0.8013]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# another way -\n",
    "torch.cat(torch.unbind(model_inp, 1), 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.3335,  1.1781,  1.3335,  1.1781,  1.3335,  1.1781],\n",
       "        [ 1.3335,  1.1781,  1.3335,  1.1781,  0.7193, -0.4586],\n",
       "        [ 1.3335,  1.1781,  0.7193, -0.4586,  0.1850, -1.9612],\n",
       "        [ 0.7193, -0.4586,  0.1850, -1.9612,  0.2678, -1.6484],\n",
       "        [ 0.1850, -1.9612,  0.2678, -1.6484,  0.4222,  0.8013]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# but the efficient way -\n",
    "model_inp.view((5,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
       "        18, 19, 20, 21, 22, 23])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## view's efficiency as long as total elements are same\n",
    "a = torch.arange(24)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0,  1],\n",
       "        [ 2,  3],\n",
       "        [ 4,  5],\n",
       "        [ 6,  7],\n",
       "        [ 8,  9],\n",
       "        [10, 11],\n",
       "        [12, 13],\n",
       "        [14, 15],\n",
       "        [16, 17],\n",
       "        [18, 19],\n",
       "        [20, 21],\n",
       "        [22, 23]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.view((12,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[ 0,  1],\n",
       "         [ 2,  3],\n",
       "         [ 4,  5]],\n",
       "\n",
       "        [[ 6,  7],\n",
       "         [ 8,  9],\n",
       "         [10, 11]],\n",
       "\n",
       "        [[12, 13],\n",
       "         [14, 15],\n",
       "         [16, 17]],\n",
       "\n",
       "        [[18, 19],\n",
       "         [20, 21],\n",
       "         [22, 23]]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.view((4,3,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[ 0,  1],\n",
       "          [ 2,  3],\n",
       "          [ 4,  5]],\n",
       "\n",
       "         [[ 6,  7],\n",
       "          [ 8,  9],\n",
       "          [10, 11]]],\n",
       "\n",
       "\n",
       "        [[[12, 13],\n",
       "          [14, 15],\n",
       "          [16, 17]],\n",
       "\n",
       "         [[18, 19],\n",
       "          [20, 21],\n",
       "          [22, 23]]]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.view((2,2,3,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/7v/p6dm1_f165zdwds1rtz7sw080000gn/T/ipykernel_10808/3775447253.py:2: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly.  To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n",
      "  a.storage()\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       " 0\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5\n",
       " 6\n",
       " 7\n",
       " 8\n",
       " 9\n",
       " 10\n",
       " 11\n",
       " 12\n",
       " 13\n",
       " 14\n",
       " 15\n",
       " 16\n",
       " 17\n",
       " 18\n",
       " 19\n",
       " 20\n",
       " 21\n",
       " 22\n",
       " 23\n",
       "[torch.storage.TypedStorage(dtype=torch.int64, device=cpu) of size 24]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# always stored as 1-d array in memory. But view gives us in the required shape by indexing\n",
    "a.storage()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now this can be input to the nn layer with 6 neurons(inputs)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 100])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# properly multiply to get hidden states\n",
    "(model_inp.view((5,6)) @ W1 + b1).shape     # (5x6) @ (6x100) -> (5x100) - 100 dim activations of our 5 examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "h1 = torch.tanh(model_inp.view((-1,6)) @ W1 + b1)       # 1)if -1, torch will infer. 2) tanh activation as used in the paper"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create output layer with 27 neurons because we have 27 characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "W2 = torch.randn((100, 27))\n",
    "b2 = torch.randn((27))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "logits = h1 @ W2 + b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 27])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits.shape        # each input sample with log counts for each character out of which one has to be predicted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "counts = logits.exp()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "probs = counts/counts.sum(dim=1, keepdim=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 27])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "probs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1.)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "probs[0].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([14,  5,  7, 26, 26])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y = y[:5]\n",
    "Y       # actual/gold output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([3.9265e-06, 1.0256e-10, 7.7295e-13, 1.2179e-05, 1.8512e-05])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pred_probs = probs[torch.arange(5), Y]\n",
    "pred_probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(17.1099)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss = -probs[torch.arange(5), Y].log().mean()      # nll loss\n",
    "loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3481"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parameters = [C, W1, b1, W2, b2]\n",
    "sum(p.nelement() for p in parameters)           # total parameters of this network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(17.1099)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts = logits.exp()\n",
    "probs = counts/counts.sum(dim=1, keepdim=True)\n",
    "loss = -probs[torch.arange(5), y[:5]].log().mean()      # nll loss\n",
    "loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(17.1099)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# torch has an efficient implementation of calculating the above classification loss - F.cross_entropy\n",
    "F.cross_entropy(logits, y[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.0064, 0.0023, 0.0470, 0.9443])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reason - 1 for effieciency -> torch calculates cross_entropy in fused kernels that makes broadcasted computation, no use of extra memory => both forward and backward passes are much more efficient\n",
    "# reason - 2 -> cross entropy is numerically well behaved , below is an example\n",
    "logits = torch.tensor([-2,-3,0,3])      # all good for normal values\n",
    "counts = logits.exp()\n",
    "probs = counts/counts.sum()\n",
    "probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.0064, 0.0000, 0.0471, 0.9465])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits = torch.tensor([-2,-300,0,3])      # all good for extreme -ve values\n",
    "counts = logits.exp()\n",
    "probs = counts/counts.sum()\n",
    "probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 0., 0., nan])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits = torch.tensor([-2,-300,0,300])      # crashes for extreme +ve values (which are not uncommon in training)\n",
    "counts = logits.exp()\n",
    "probs = counts/counts.sum()\n",
    "probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.1353, 0.0000, 1.0000,    inf])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts          # we got infinity here because of the way exp() works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 0., 0., 1.])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits = torch.tensor([-2,-300,0,300]) - 300      # subtract the max number\n",
    "counts = logits.exp()\n",
    "probs = counts/counts.sum()\n",
    "probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 0., 0., 1.])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for training (backward pass), we need gradients\n",
    "for p in parameters:\n",
    "    p.requires_grad = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# training loop\n",
    "def train(epochs, batch_size):\n",
    "    for _ in range(epochs):\n",
    "        # forward pass\n",
    "        emb = C[x[:batch_size]]\n",
    "        h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "        logits = h @ W2 + b2\n",
    "        loss = F.cross_entropy(logits, y[:batch_size])\n",
    "        print(loss.item())\n",
    "        \n",
    "        # backward pass\n",
    "        for p in parameters:\n",
    "            p.grad = None\n",
    "        loss.backward()\n",
    "        \n",
    "        # update parameters\n",
    "        lr = 0.1\n",
    "        for p in parameters:\n",
    "            p.data += -lr * p.grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.757530212402344\n",
      "12.442512512207031\n",
      "10.501753807067871\n",
      "8.920267105102539\n",
      "7.649085521697998\n",
      "6.697340488433838\n",
      "5.959523677825928\n",
      "5.341253280639648\n",
      "4.804412841796875\n",
      "4.332081317901611\n"
     ]
    }
   ],
   "source": [
    "train(10, 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# same training loop without print at each epoch but at the end\n",
    "def train(epochs, batch_size):\n",
    "    for _ in range(epochs):\n",
    "        # forward pass\n",
    "        emb = C[x[:batch_size]]\n",
    "        h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "        logits = h @ W2 + b2\n",
    "        loss = F.cross_entropy(logits, y[:batch_size])\n",
    "        \n",
    "        # backward pass\n",
    "        for p in parameters:\n",
    "            p.grad = None\n",
    "        loss.backward()\n",
    "        \n",
    "        # update parameters\n",
    "        lr = 0.1\n",
    "        for p in parameters:\n",
    "            p.data += -lr * p.grad\n",
    "    print(loss.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.17777201533317566\n"
     ]
    }
   ],
   "source": [
    "train(100, 32)      ## currently overfitting b/c we're training only for 32 (one batch) examples and have 3481 parameters. (parameters >> training samples)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### training implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([306991, 3]), torch.Size([306991]))"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape, y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of parameters 3481\n"
     ]
    }
   ],
   "source": [
    "## init model\n",
    "\n",
    "g = torch.Generator().manual_seed(SEED)\n",
    "C = torch.randn((27,2), generator=g)\n",
    "W1 = torch.randn((6, 100), generator=g)\n",
    "b1 = torch.randn(100, generator=g)\n",
    "W2 = torch.randn((100, 27), generator=g)\n",
    "b2 = torch.randn((27), generator=g)\n",
    "parameters = [C, W1, b1, W2, b2]\n",
    "\n",
    "print(f\"total number of parameters {sum(p.nelement() for p in parameters)}\")\n",
    "\n",
    "for p in parameters:\n",
    "    p.requires_grad = True  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(epochs=10):\n",
    "    for _ in range(epochs):\n",
    "        # forward pass\n",
    "        emb = C[x]\n",
    "        h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "        logits = h @ W2 + b2\n",
    "        loss = F.cross_entropy(logits, y)\n",
    "        print(loss.item())\n",
    "        \n",
    "        # backward pass\n",
    "        for p in parameters:\n",
    "            p.grad = None\n",
    "        loss.backward()\n",
    "        \n",
    "        # update parameters\n",
    "        lr = 0.1\n",
    "        for p in parameters:\n",
    "            p.data += -lr * p.grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.017581939697266\n",
      "15.313886642456055\n",
      "14.293935775756836\n",
      "13.460793495178223\n",
      "12.73753547668457\n",
      "12.160568237304688\n",
      "11.671038627624512\n",
      "11.240046501159668\n",
      "10.853802680969238\n",
      "10.510765075683594\n"
     ]
    }
   ],
   "source": [
    "train(10)       ## taking more time for each epoch since we're doing forward and backward for whole training data, so let's do batched training(minibatches)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([3, 8, 7, 1, 2, 6, 7, 4, 8, 8, 0, 6, 2, 0, 3, 8, 1, 1, 0, 7, 6, 4, 1, 5,\n",
       "        4, 6, 5, 1, 7, 3, 8, 3])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can create minibatch by selecting <batch_size> examples randomly from the training data\n",
    "batch_size = 32\n",
    "torch.randint(0, 10, (batch_size,)) # this gives 32 numbers(indices in our case) from [0, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([209112, 201644,   6384, 189524, 238167, 203028, 219821, 207094, 235797,\n",
       "         10486, 218455, 220636, 142283, 239068, 283682, 244342, 277440,  77385,\n",
       "        256171, 186102, 280516,  48286, 253093, 150152, 179557, 131852, 265752,\n",
       "         19167, 137553,  44667,  19784, 217942])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's select indices for out training dataset length so that we can index from the training data\n",
    "torch.randint(0, x.shape[0], (batch_size,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([32, 3])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[torch.randint(0, x.shape[0], (batch_size,))].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's do minibatch training\n",
    "def train(steps=10, batch_size=32):\n",
    "    for _ in range(steps):\n",
    "        # minibatch\n",
    "        ix = torch.randint(0, x.shape[0], (batch_size,))\n",
    "        # forward pass\n",
    "        emb = C[x[ix]]\n",
    "        h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "        logits = h @ W2 + b2\n",
    "        loss = F.cross_entropy(logits, y[ix])\n",
    "        # print(loss.item())\n",
    "        \n",
    "        # backward pass\n",
    "        for p in parameters:\n",
    "            p.grad = None\n",
    "        loss.backward()\n",
    "        \n",
    "        # update parameters\n",
    "        lr = 0.1\n",
    "        for p in parameters:\n",
    "            p.data += -lr * p.grad\n",
    "    print(loss.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.95998764038086\n",
      "10.172564506530762\n",
      "9.74691104888916\n",
      "9.980635643005371\n",
      "8.728821754455566\n",
      "8.889914512634277\n",
      "9.491644859313965\n",
      "10.418598175048828\n",
      "7.901980400085449\n",
      "9.502591133117676\n"
     ]
    }
   ],
   "source": [
    "train(10, 32)   # much faster, but the gradient may not be reliable because of the fluctuations. But it works over the entire training data emperically since the direction of the gradient will be to the minimum though it fluctuates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.306142807006836\n"
     ]
    }
   ],
   "source": [
    "# calculate loss for the entire training set\n",
    "emb = C[x]\n",
    "h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "logits = h @ W2 + b2\n",
    "loss = F.cross_entropy(logits, y)\n",
    "print(loss.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.7768492698669434\n"
     ]
    }
   ],
   "source": [
    "train(1000, 32)     # commented print in train for loop "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5457804203033447\n"
     ]
    }
   ],
   "source": [
    "# calculate loss for the entire training set\n",
    "emb = C[x]\n",
    "h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "logits = h @ W2 + b2\n",
    "loss = F.cross_entropy(logits, y)\n",
    "print(loss.item())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's determine the good learning rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of parameters 3481\n"
     ]
    }
   ],
   "source": [
    "# reset parameters\n",
    "\n",
    "g = torch.Generator().manual_seed(SEED)\n",
    "C = torch.randn((27,2), generator=g)\n",
    "W1 = torch.randn((6, 100), generator=g)\n",
    "b1 = torch.randn(100, generator=g)\n",
    "W2 = torch.randn((100, 27), generator=g)\n",
    "b2 = torch.randn((27), generator=g)\n",
    "parameters = [C, W1, b1, W2, b2]\n",
    "\n",
    "print(f\"total number of parameters {sum(p.nelement() for p in parameters)}\")\n",
    "\n",
    "for p in parameters:\n",
    "    p.requires_grad = True  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lre = torch.linspace(-3, 0, 1000)   # 1000 linearly spaced numbers b/w -3 and 0, these are used as exponents\n",
    "lrs = 10**lre       # we get 1000 values from 0.001 and 1 stepped exponentially  \n",
    "len(lrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "lri = []\n",
    "lossi = []\n",
    "for i in range(1000):       # same number of steps as lrs\n",
    "    # minibatch\n",
    "    ix = torch.randint(0, x.shape[0], (batch_size,))\n",
    "    # forward pass\n",
    "    emb = C[x[ix]]\n",
    "    h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "    logits = h @ W2 + b2\n",
    "    loss = F.cross_entropy(logits, y[ix])\n",
    "    # print(loss.item())\n",
    "    \n",
    "    # backward pass\n",
    "    for p in parameters:\n",
    "        p.grad = None\n",
    "    loss.backward()\n",
    "    \n",
    "    # update parameters\n",
    "    lr = lrs[i]\n",
    "    for p in parameters:\n",
    "        p.data += -lr * p.grad\n",
    "    \n",
    "    # track stats\n",
    "    lri.append(lre[i])\n",
    "    lossi.append(loss.item())\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2a1ae0fa0>]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(lri, lossi)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "from the plot, lre ~ -1 is good enough. so lr = 10**-1 = 0.1 is good, what we took initially is good :-)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of parameters 3481\n"
     ]
    }
   ],
   "source": [
    "# let's train with this learning rate\n",
    "## init model\n",
    "\n",
    "g = torch.Generator().manual_seed(SEED)\n",
    "C = torch.randn((27,2), generator=g)\n",
    "W1 = torch.randn((6, 100), generator=g)\n",
    "b1 = torch.randn(100, generator=g)\n",
    "W2 = torch.randn((100, 27), generator=g)\n",
    "b2 = torch.randn((27), generator=g)\n",
    "parameters = [C, W1, b1, W2, b2]\n",
    "\n",
    "print(f\"total number of parameters {sum(p.nelement() for p in parameters)}\")\n",
    "\n",
    "for p in parameters:\n",
    "    p.requires_grad = True  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's do minibatch training\n",
    "def train(steps=10, batch_size=32, lr=0.1):\n",
    "    for _ in range(steps):\n",
    "        # minibatch\n",
    "        ix = torch.randint(0, x.shape[0], (batch_size,))\n",
    "        # forward pass\n",
    "        emb = C[x[ix]]\n",
    "        h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "        logits = h @ W2 + b2\n",
    "        loss = F.cross_entropy(logits, y[ix])\n",
    "        # print(loss.item())\n",
    "        \n",
    "        # backward pass\n",
    "        for p in parameters:\n",
    "            p.grad = None\n",
    "        loss.backward()\n",
    "        \n",
    "        # update parameters\n",
    "        for p in parameters:\n",
    "            p.data += -lr * p.grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_overall_loss():\n",
    "    # calculate loss for the entire training set\n",
    "    emb = C[x]\n",
    "    h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "    logits = h @ W2 + b2\n",
    "    loss = F.cross_entropy(logits, y)\n",
    "    print(loss.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's train for 10,000 steps\n",
    "train(10000, 32, 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4817726612091064\n"
     ]
    }
   ],
   "source": [
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.448557138442993\n"
     ]
    }
   ],
   "source": [
    "# let's train for another 10,000 steps\n",
    "train(10000, 32, 0.1)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4298393726348877\n"
     ]
    }
   ],
   "source": [
    "# let's train for one more 10,000 steps\n",
    "train(10000, 32, 0.1)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "surpassed the performance of the bigram model in the previous notebook 🥳"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3766236305236816\n"
     ]
    }
   ],
   "source": [
    "# let's decay the learning rate by 10%. at the end of the training, we can reduce the lr to take tiny steps to minima\n",
    "# let's train for another 10,000 steps\n",
    "train(10000, 32, 0.01)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3752195835113525\n"
     ]
    }
   ],
   "source": [
    "# let's train again for another 10,000 steps\n",
    "train(10000, 32, 0.01)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3739705085754395\n"
     ]
    }
   ],
   "source": [
    "# one more\n",
    "train(10000, 32, 0.01)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we don't know whether we're actually improving or overfitting here. So let's divide the data into train, dev and test splits\n",
    "\n",
    "train set - tune model parameters\n",
    "\n",
    "dev set - tune hyperparameters\n",
    "\n",
    "test set - estimate actual perf, use very sparingly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_dataset(names):\n",
    "    context_length = 3  # block size\n",
    "    x, y = [], []\n",
    "    for name in names:\n",
    "        # print(name)\n",
    "        context = [0] * context_length\n",
    "        for c in name + '.':\n",
    "            idx = ctoi[c]\n",
    "            x.append(context)\n",
    "            y.append(idx)\n",
    "            # print(''.join([itoc[i] for i in context]), '------>', itoc[idx])\n",
    "            context = context[1:] + [idx]\n",
    "\n",
    "    x = torch.tensor(x)\n",
    "    y = torch.tensor(y)\n",
    "    return x, y\n",
    "random.seed(SEED)\n",
    "random.shuffle(names)\n",
    "n1, n2 = int(0.8*len(names)), int(0.9*len(names))\n",
    "x_tr, y_tr = build_dataset(names[: n1])\n",
    "x_dev, y_dev = build_dataset(names[n1: n2])\n",
    "x_test, y_test = build_dataset(names[n2:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(245708, 30505, 30778)"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(x_tr), len(x_dev), len(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of parameters 3481\n"
     ]
    }
   ],
   "source": [
    "# let's train with this learning rate\n",
    "## init model\n",
    "\n",
    "g = torch.Generator().manual_seed(SEED)\n",
    "C = torch.randn((27,2), generator=g)\n",
    "W1 = torch.randn((6, 100), generator=g)\n",
    "b1 = torch.randn(100, generator=g)\n",
    "W2 = torch.randn((100, 27), generator=g)\n",
    "b2 = torch.randn((27), generator=g)\n",
    "parameters = [C, W1, b1, W2, b2]\n",
    "\n",
    "print(f\"total number of parameters {sum(p.nelement() for p in parameters)}\")\n",
    "\n",
    "for p in parameters:\n",
    "    p.requires_grad = True  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's do minibatch training\n",
    "def train(steps=10, batch_size=32, lr=0.1):\n",
    "    for _ in range(steps):\n",
    "        # minibatch\n",
    "        ix = torch.randint(0, x_tr.shape[0], (batch_size,))\n",
    "        # forward pass\n",
    "        emb = C[x_tr[ix]]\n",
    "        h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "        logits = h @ W2 + b2\n",
    "        loss = F.cross_entropy(logits, y_tr[ix])\n",
    "        # print(loss.item())\n",
    "        \n",
    "        # backward pass\n",
    "        for p in parameters:\n",
    "            p.grad = None\n",
    "        loss.backward()\n",
    "        \n",
    "        # update parameters\n",
    "        for p in parameters:\n",
    "            p.data += -lr * p.grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_overall_loss(x=x_dev, y=y_dev):\n",
    "    # calculate loss for the entire training set\n",
    "    emb = C[x]\n",
    "    h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "    logits = h @ W2 + b2\n",
    "    loss = F.cross_entropy(logits, y)\n",
    "    print(loss.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4018607139587402\n"
     ]
    }
   ],
   "source": [
    "# let's train for 10,000 steps\n",
    "train(30000, 32, 0.1)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.336449384689331\n"
     ]
    }
   ],
   "source": [
    "train(10000, 32, 0.01)\n",
    "calc_overall_loss()      # good enough on dev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.327794313430786\n"
     ]
    }
   ],
   "source": [
    "calc_overall_loss(x_tr, y_tr)   # calc loss on train set"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "our train and dev are almost equal, so we're not overfitting. But we're underfitting, i.e, our nn is tiny and we can expect perf improvement by scaling up size of nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of parameters 10281\n"
     ]
    }
   ],
   "source": [
    "## init large model\n",
    "\n",
    "g = torch.Generator().manual_seed(SEED)\n",
    "C = torch.randn((27,2), generator=g)\n",
    "W1 = torch.randn((6, 300), generator=g)\n",
    "b1 = torch.randn(300, generator=g)\n",
    "W2 = torch.randn((300, 27), generator=g)\n",
    "b2 = torch.randn((27), generator=g)\n",
    "parameters = [C, W1, b1, W2, b2]\n",
    "\n",
    "print(f\"total number of parameters {sum(p.nelement() for p in parameters)}\")\n",
    "\n",
    "for p in parameters:\n",
    "    p.requires_grad = True   "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "now we have >10k parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's do minibatch training and return history/stats\n",
    "def train(steps=10, batch_size=32, lr=0.1):\n",
    "    lossi = []\n",
    "    stepsi = []\n",
    "    for i in range(steps):\n",
    "        # minibatch\n",
    "        ix = torch.randint(0, x_tr.shape[0], (batch_size,))\n",
    "        # forward pass\n",
    "        emb = C[x_tr[ix]]\n",
    "        h = torch.tanh(emb.view(-1, 6) @ W1 + b1)\n",
    "        logits = h @ W2 + b2\n",
    "        loss = F.cross_entropy(logits, y_tr[ix])\n",
    "        # print(loss.item())\n",
    "        \n",
    "        # backward pass\n",
    "        for p in parameters:\n",
    "            p.grad = None\n",
    "        loss.backward()\n",
    "        \n",
    "        # update parameters\n",
    "        for p in parameters:\n",
    "            p.data += -lr * p.grad\n",
    "        \n",
    "        # track stats\n",
    "        lossi.append(loss.item())\n",
    "        stepsi.append(i)\n",
    "    return stepsi, lossi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.593662738800049\n"
     ]
    }
   ],
   "source": [
    "steps, loss = train(30000, 32, 0.1)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2a1cc74f0>]"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(steps, loss)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the line got thicker because there are lot of fluctuations b/c of minibatches, one way to improve the gradient/model is to increase the batch size so that we get good loss without crazy fluctuations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.534715175628662\n"
     ]
    }
   ],
   "source": [
    "# let's train more\n",
    "steps, loss = train(30000, 32, 0.1)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2ac75d660>]"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# this will be meaningless as we overwritten the prev stuff\n",
    "plt.plot(steps, loss)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "maybe decreasing but not obvious"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4361770153045654\n"
     ]
    }
   ],
   "source": [
    "# let's train more\n",
    "steps, loss = train(30000, 32, 0.05) # let's half the lr\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.426591634750366\n"
     ]
    }
   ],
   "source": [
    "# let's train once more\n",
    "steps, loss = train(30000, 32, 0.05)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4180502891540527\n"
     ]
    }
   ],
   "source": [
    "# let's train once more\n",
    "steps, loss = train(30000, 32, 0.05)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4179487228393555\n"
     ]
    }
   ],
   "source": [
    "# let's train once more\n",
    "steps, loss = train(30000, 32, 0.05)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3454651832580566\n"
     ]
    }
   ],
   "source": [
    "# let's train more\n",
    "steps, loss = train(30000, 32, 0.01)        # reduce lr\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.344560146331787\n"
     ]
    }
   ],
   "source": [
    "# let's train once more\n",
    "steps, loss = train(30000, 32, 0.01)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.342893362045288\n"
     ]
    }
   ],
   "source": [
    "# let's train more\n",
    "steps, loss = train(30000, 32, 0.01)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3295812606811523\n"
     ]
    }
   ],
   "source": [
    "calc_overall_loss(x_tr, y_tr)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model is trying to overfit and not improve on dev set. This can be b/c we have lot of parameters and we're cramming all the characters to 2 dimensional and this may not be enough for the model to converge and increasing the embedding dimension may improve the performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# let's visualize the embeddings\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.scatter(C[:, 0].data, C[:, 1].data, s=200)\n",
    "for i in range(C.shape[0]):\n",
    "    plt.text(C[i,0].item(), C[i,1].item(), itoc[i], ha=\"center\", va=\"center\", color=\"white\")\n",
    "plt.grid(\"minor\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nn is trying to cluster and seperate the characters. \n",
    "\n",
    "eg. \n",
    "\n",
    "1) vowels are roughly clustered\n",
    "\n",
    "2) '.' and 'q' are outliers etc\n",
    "\n",
    "so this is definitely not random"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "since we're not improving even after increasing the model size, let's increase the embedding size and check the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of parameters 11897\n"
     ]
    }
   ],
   "source": [
    "## init large model\n",
    "\n",
    "g = torch.Generator().manual_seed(SEED)\n",
    "C = torch.randn((27,10), generator=g)       # take embed size as 10\n",
    "W1 = torch.randn((30, 200), generator=g)    # let's reduce the hidden layer \n",
    "b1 = torch.randn(200, generator=g)\n",
    "W2 = torch.randn((200, 27), generator=g)\n",
    "b2 = torch.randn((27), generator=g)\n",
    "parameters = [C, W1, b1, W2, b2]\n",
    "\n",
    "print(f\"total number of parameters {sum(p.nelement() for p in parameters)}\")\n",
    "\n",
    "for p in parameters:\n",
    "    p.requires_grad = True   "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "now we have >11k parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [],
   "source": [
    "lossi = []\n",
    "stepsi = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's do minibatch training and return history/stats\n",
    "def train(steps=10, batch_size=32, lr=0.1):\n",
    "    for i in range(steps):\n",
    "        # minibatch\n",
    "        ix = torch.randint(0, x_tr.shape[0], (batch_size,))\n",
    "        # forward pass\n",
    "        emb = C[x_tr[ix]]\n",
    "        h = torch.tanh(emb.view(-1, 30) @ W1 + b1)\n",
    "        logits = h @ W2 + b2\n",
    "        loss = F.cross_entropy(logits, y_tr[ix])\n",
    "        # print(loss.item())\n",
    "        \n",
    "        # backward pass\n",
    "        for p in parameters:\n",
    "            p.grad = None\n",
    "        loss.backward()\n",
    "        \n",
    "        # update parameters\n",
    "        for p in parameters:\n",
    "            p.data += -lr * p.grad\n",
    "        \n",
    "        # track stats\n",
    "        lossi.append(loss.log10().item())       # track log loss so that y-axis is meaningful\n",
    "        stepsi.append(i)\n",
    "    return stepsi, lossi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_overall_loss(x=x_dev, y=y_dev):\n",
    "    # calculate loss for the entire training set\n",
    "    emb = C[x]\n",
    "    h = torch.tanh(emb.view(-1, 30) @ W1 + b1)\n",
    "    logits = h @ W2 + b2\n",
    "    loss = F.cross_entropy(logits, y)\n",
    "    print(loss.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.466907024383545\n"
     ]
    }
   ],
   "source": [
    "steps, loss = train(50000, 32, 0.1)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4514503479003906\n"
     ]
    }
   ],
   "source": [
    "calc_overall_loss(x_tr, y_tr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2ab35cf70>]"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(steps, loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the line got thicker because there are lot of fluctuations b/c of minibatches, one way to improve the gradient/model is to increase the batch size so that we get good loss without crazy fluctuations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.307107925415039\n"
     ]
    }
   ],
   "source": [
    "# let's train more\n",
    "steps, loss = train(50000, 32, 0.01)    # decay lr\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.29162335395813\n"
     ]
    }
   ],
   "source": [
    "calc_overall_loss(x_tr, y_tr)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "improved from the prev model 🥳\n",
    "\n",
    "so increasing the embed dimension worked"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.306823492050171\n"
     ]
    }
   ],
   "source": [
    "# let's train more\n",
    "steps, loss = train(50000, 32, 0.01)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.289712429046631\n"
     ]
    }
   ],
   "source": [
    "calc_overall_loss(x_tr, y_tr)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can see our dev and train loss is starting to diverge a bit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3027825355529785\n"
     ]
    }
   ],
   "source": [
    "# let's train more\n",
    "steps, loss = train(50000, 32, 0.01)\n",
    "calc_overall_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.2806904315948486\n"
     ]
    }
   ],
   "source": [
    "calc_overall_loss(x_tr, y_tr)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many ways to continue improving the model - \n",
    "\n",
    "1) increase the hidden layer size\n",
    "\n",
    "2) increase the embedding dimension\n",
    "\n",
    "3) increase the context length\n",
    "\n",
    "4) increase batch size for efficient training times/gradient steps\n",
    "\n",
    "5) try more lrs and lr decays \n",
    "\n",
    "etc ...."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save({\"emb\": C, \"w1\": W1, \"b1\": b1, \"w2\": W2, \"b2\": b2}, \"mlp.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp_layers = torch.load(\"mlp.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anu.\n",
      "den.\n",
      "tis.\n",
      "maridu.\n",
      "davmubunderlayan.\n",
      "cottah.\n",
      "lavan.\n",
      "epindenden.\n",
      "diza.\n",
      "kumar.\n"
     ]
    }
   ],
   "source": [
    "g = torch.Generator().manual_seed(SEED)\n",
    "n = 10\n",
    "block_size = 3\n",
    "for _ in range(n):  # predict n words\n",
    "    out = []\n",
    "    context = [0]*block_size\n",
    "    while True:\n",
    "        emb = C[torch.tensor([context])]\n",
    "        h = torch.tanh(emb.view(1,-1) @ W1 + b1)        # create batch_size 1\n",
    "        logits = h @ W2 + b2\n",
    "        probs = F.softmax(logits, dim=1)\n",
    "        ix = torch.multinomial(probs, num_samples=1, generator=g).item()\n",
    "        context = context[1:] + [ix]\n",
    "        out.append(ix)\n",
    "        if ix == 0:\n",
    "            break\n",
    "    print(''.join(itoc[i] for i in out))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [],
   "source": [
    "c, w1, b1, w2, b2 = mlp_layers[\"emb\"], mlp_layers['w1'], mlp_layers['b1'], mlp_layers['w2'], mlp_layers['b2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anu.\n",
      "den.\n",
      "tis.\n",
      "maridu.\n",
      "davmubunderlayan.\n",
      "cottah.\n",
      "lavan.\n",
      "epindenden.\n",
      "diza.\n",
      "kumar.\n"
     ]
    }
   ],
   "source": [
    "g = torch.Generator().manual_seed(SEED)\n",
    "n = 10\n",
    "block_size = 3\n",
    "for _ in range(n):  # predict n words\n",
    "    out = []\n",
    "    context = [0]*block_size\n",
    "    while True:\n",
    "        emb = c[torch.tensor([context])]\n",
    "        h = torch.tanh(emb.view(1,-1) @ w1 + b1)        # create batch_size 1\n",
    "        logits = h @ w2 + b2\n",
    "        probs = F.softmax(logits, dim=1)\n",
    "        ix = torch.multinomial(probs, num_samples=1, generator=g).item()\n",
    "        context = context[1:] + [ix]\n",
    "        out.append(ix)\n",
    "        if ix == 0:\n",
    "            break\n",
    "    print(''.join(itoc[i] for i in out))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch-dev",
   "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.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}