nameGenerator2.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZVEBFB5EqY6s"
      },
      "source": [
        "### Paper referred to\n",
        "https://www.jmlr.org/papers/volume3/bengio03a/bengio03a.pdf"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "c7SEV2Bufvkz"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "import torch\n",
        "import torch.nn.functional as F\n",
        "from sklearn.model_selection import train_test_split"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "AK7P56jIf6If",
        "outputId": "144b598c-5447-4ece-b9c2-90b13a9329e5"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "  <div id=\"df-09d9121c-52d5-443d-b5f1-25358e14b4c7\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Unnamed: 0</th>\n",
              "      <th>Name</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>aabid</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>aabida</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>2</td>\n",
              "      <td>aachal</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>3</td>\n",
              "      <td>aadesh</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>4</td>\n",
              "      <td>aadil</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-09d9121c-52d5-443d-b5f1-25358e14b4c7')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-09d9121c-52d5-443d-b5f1-25358e14b4c7 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-09d9121c-52d5-443d-b5f1-25358e14b4c7');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ],
            "text/plain": [
              "   Unnamed: 0    Name\n",
              "0           0   aabid\n",
              "1           1  aabida\n",
              "2           2  aachal\n",
              "3           3  aadesh\n",
              "4           4   aadil"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "df = pd.read_csv(\"./Indian_Names.csv\")\n",
        "df.dropna(inplace=True)\n",
        "df.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "EF_TgEe8gR_J",
        "outputId": "3d2f0787-f490-45bb-ca09-b2bb98aafffe"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['aabid',\n",
              " 'aabida',\n",
              " 'aachal',\n",
              " 'aadesh',\n",
              " 'aadil',\n",
              " 'aadish',\n",
              " 'aaditya',\n",
              " 'aaenab',\n",
              " 'aafreen']"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "names = df[\"Name\"].values\n",
        "names = [i for i in names if i.isalpha()]\n",
        "names[:9]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "1sBp8zUZgVf6",
        "outputId": "2ce3aeb5-2417-4507-8b89-5859d958a78d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k', 12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u', 22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z', 0: '.'}\n"
          ]
        }
      ],
      "source": [
        "chars = sorted(list(set(\"\".join(names))))\n",
        "stoi = {s: i + 1 for i, s in enumerate(chars)}\n",
        "stoi[\".\"] = 0\n",
        "itos = {i: s for s, i in stoi.items()}\n",
        "print(itos)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "vNGfun1Thc7g"
      },
      "outputs": [],
      "source": [
        "# building the dataset for the network\n",
        "\n",
        "blockSize = 3 # the size of the context to be considered for predicting the next character\n",
        "X, y = [], []\n",
        "\n",
        "for n in names:\n",
        "    # print(n)\n",
        "    context = [0] * blockSize\n",
        "    for ch in n + \".\":\n",
        "        idx = stoi[ch]\n",
        "        X.append(context)\n",
        "        y.append(idx)\n",
        "        # print(\"\".join(itos[i] for i in context), \"-->\", itos[idx])\n",
        "        context = context[1:] + [idx]\n",
        "\n",
        "X = torch.tensor(X)\n",
        "y = torch.tensor(y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "NipQNGNux5te"
      },
      "outputs": [],
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)\n",
        "\n",
        "X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.111, random_state=42) # 0.111 x 0.9 = 0.1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "umq3Dk-ysWYw",
        "outputId": "e9c8eea8-6ee3-4dcb-bae1-a1f93f61266a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(torch.Size([38052, 3]), torch.Size([38052]))"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X_train.shape, y_train.shape # dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "6-9yeytHijXG"
      },
      "outputs": [],
      "source": [
        "C = torch.randn((27, 10), requires_grad=True) # embedding table in 10 dimensions\n",
        "emb = C[X_train]\n",
        "\n",
        "# first layer of neurons\n",
        "W1 = torch.randn((30, 200), requires_grad=True)\n",
        "b1 = torch.randn(200, requires_grad=True)\n",
        "\n",
        "# second hidden layer of neurons\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1)\n",
        "\n",
        "# third (utput) layer of neurons\n",
        "W2 = torch.randn((200, 27), requires_grad=True)\n",
        "b2 = torch.randn(27, requires_grad=True)\n",
        "\n",
        "parameters = [C, W1, b1, W2, b2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "BnWcs-ULsN66",
        "outputId": "38b35918-6747-4765-97e8-82fd786e3e0e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "11897"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "sum(p.nelement() for p in parameters) # total number of parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "KliLwrzD94VO"
      },
      "outputs": [],
      "source": [
        "steps = []\n",
        "lossesTrain = []\n",
        "lossesVal = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "V8uSpDNCtNla",
        "outputId": "53db370f-de02-47c5-ad48-c7f6a00e06a5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.0846714973449707\n"
          ]
        }
      ],
      "source": [
        "for i in range(30000):\n",
        "\n",
        "    # constructing the mini batch\n",
        "    idx = torch.randint(0, X_train.shape[0], (256, ))\n",
        "\n",
        "    # forward pass\n",
        "    emb = C[X_train[idx]]\n",
        "    h = torch.tanh(emb.view(-1, 30) @ W1 + b1)\n",
        "    logits = h @ W2 + b2\n",
        "    loss_train = F.cross_entropy(logits, y_train[idx])\n",
        "\n",
        "    emb = C[X_val]\n",
        "    h = torch.tanh(emb.view(-1, 30) @ W1 + b1)\n",
        "    logits = h @ W2 + b2\n",
        "    loss_val = F.cross_entropy(logits, y_val)\n",
        "\n",
        "    # backward pass\n",
        "    for p in parameters:\n",
        "        p.grad = None\n",
        "    loss_train.backward()\n",
        "    # update\n",
        "    lr = 0\n",
        "    if i < 10000:\n",
        "        lr = 0.1\n",
        "    elif i > 10000 and i < 20000:\n",
        "        lr = 0.01\n",
        "    else:\n",
        "        lr = 0.001\n",
        "    for p in parameters:\n",
        "        p.data += -lr * p.grad\n",
        "    \n",
        "    steps.append(i)\n",
        "    lossesTrain.append(loss_train.item())\n",
        "    lossesVal.append(loss_val.item())\n",
        "\n",
        "print(loss_train.item()) # mini batch loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "ORNxJSsAJdJo",
        "outputId": "2d217971-b97c-4290-f8b1-765acc64aba9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.0508482456207275\n"
          ]
        }
      ],
      "source": [
        "# further training by decaying lr further\n",
        "\n",
        "for i in range(10000):\n",
        "\n",
        "    # constructing the mini batch\n",
        "    idx = torch.randint(0, X_train.shape[0], (256, ))\n",
        "\n",
        "    # forward pass\n",
        "    emb = C[X_train[idx]]\n",
        "    h = torch.tanh(emb.view(-1, 30) @ W1 + b1)\n",
        "    logits = h @ W2 + b2\n",
        "    loss_train = F.cross_entropy(logits, y_train[idx])\n",
        "\n",
        "    emb = C[X_val]\n",
        "    h = torch.tanh(emb.view(-1, 30) @ W1 + b1)\n",
        "    logits = h @ W2 + b2\n",
        "    loss_val = F.cross_entropy(logits, y_val)\n",
        "\n",
        "    # backward pass\n",
        "    for p in parameters:\n",
        "        p.grad = None\n",
        "    loss_train.backward()\n",
        "    # update\n",
        "    lr = 0.0001\n",
        "    for p in parameters:\n",
        "        p.data += -lr * p.grad\n",
        "    \n",
        "    steps.append(i)\n",
        "    lossesTrain.append(loss_train.item())\n",
        "    lossesVal.append(loss_val.item())\n",
        "\n",
        "print(loss_train.item()) # mini batch loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "WkqqV-jxufvp",
        "outputId": "39148e2a-4a9b-4524-b853-7404e06ffdf2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.113219976425171\n"
          ]
        }
      ],
      "source": [
        "emb = C[X_train]\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1)\n",
        "logits = h @ W2 + b2\n",
        "loss = F.cross_entropy(logits, y_train)\n",
        "print(loss.item()) # final training loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "KTdOV84fvuh_",
        "outputId": "0a393893-787b-4ce3-de19-448731f9607a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.31799054145813\n"
          ]
        }
      ],
      "source": [
        "emb = C[X_val]\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1)\n",
        "logits = h @ W2 + b2\n",
        "loss = F.cross_entropy(logits, y_val)\n",
        "print(loss.item()) # final validation loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "l4wNRKfg0shv",
        "outputId": "b529ec0c-cf16-4735-bf36-53899c828f94"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f495a226580>"
            ]
          },
          "execution_count": 15,
          "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, lossesTrain, label=\"Training loss\")\n",
        "plt.plot(steps, lossesVal, label=\"Validation loss\")\n",
        "plt.title(\"Loss function\")\n",
        "plt.xlabel(\"Steps\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend(loc=\"center\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 522
        },
        "id": "Q9is8pfe2mj4",
        "outputId": "ccbff877-4c8b-453c-b4c2-9e4db9e4b787"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 600x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# visualize dimensions 0 and 1 of the embedding matrix C for all characters\n",
        "plt.figure(figsize=(6, 6))\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(), itos[i], ha=\"center\", va=\"center\", color=\"white\")\n",
        "plt.grid(\"minor\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "V8WGvNaR4zcv",
        "outputId": "26e55e1b-f03e-4f29-cb4b-d6b70bdd3671"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "kay.\n",
            "amar.\n",
            "miti.\n",
            "rub.\n",
            "javeeramercya.\n",
            "sir.\n",
            "imarpia.\n",
            "parveela.\n",
            "joginkki.\n",
            "asnsh.\n",
            "mimaufbari.\n",
            "shak.\n",
            "sakfarmaanta.\n",
            "neem.\n",
            "ifakji.\n",
            "shandu.\n",
            "ram.\n",
            "kin.\n",
            "pulpe.\n",
            "silcy.\n"
          ]
        }
      ],
      "source": [
        "# sample from the model\n",
        "\n",
        "for _ in range(20):\n",
        "    \n",
        "    out = []\n",
        "    context = [0] * blockSize # initialize with all ...\n",
        "    while True:\n",
        "      emb = C[torch.tensor([context])] # (1, blockSize, d)\n",
        "      h = torch.tanh(emb.view(1, -1) @ W1 + b1)\n",
        "      logits = h @ W2 + b2\n",
        "      probs = F.softmax(logits, dim=1)\n",
        "      idx = torch.multinomial(probs, num_samples=1, ).item()\n",
        "      context = context[1:] + [idx]\n",
        "      out.append(idx)\n",
        "      if idx == 0:\n",
        "        break\n",
        "    \n",
        "    print(\"\".join(itos[i] for i in out))"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}