ENG_Pet_Names.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import torch # to import the PyTorch library\n",
        "import torch.nn.functional as F # to import the functional interface of PyTorch's neural network library\n",
        "import matplotlib.pyplot as plt # module for creating plots\n",
        "%matplotlib inline"
      ],
      "metadata": {
        "id": "KRTVsd3ku77n"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to read the text file, words = open('pet_names.txt', 'r').read().replace(' ', '').splitlines()\n",
        "words = open('pet_names.txt', 'r').read().replace(' ', '').splitlines()\n",
        "\n",
        "# print out first 10 words\n",
        "words[:10]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yDmljlZj1ciU",
        "outputId": "811e2b2c-6588-4705-b33d-259d1561a443"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Abbey',\n",
              " 'Abby',\n",
              " 'Abi',\n",
              " 'Addie',\n",
              " 'Aggie',\n",
              " 'Ahanu',\n",
              " 'Al',\n",
              " 'Alex',\n",
              " 'Alfie',\n",
              " 'AlfieDude']"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# the total number of words in dataset\n",
        "len(words)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MxxjatM31gsF",
        "outputId": "729713ae-e1f5-4857-c1e9-539b8ee17f7d"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1354"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to build the vocabulary of characters, uppercase and lowercase, as string to integers and viceversa:\n",
        "# to combine all words into a single string, removes duplicates, sorts the characters, and stores them in the chars variable\n",
        "chars = sorted(list(set(''.join(words))))\n",
        "# to create a dictionary mapping characters to integer indices\n",
        "stoi = {s:i+1 for i,s in enumerate(chars)}\n",
        "# to add the 'dot' character as index 0 in the dictionary\n",
        "stoi['.'] = 0\n",
        "# to create a dictionary mapping integer indices back to characters\n",
        "itos = {i:s for s,i in stoi.items()}\n",
        "\n",
        "# to print the total number of the characters in vocalubary\n",
        "len(itos)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JiNl8q-t1uyh",
        "outputId": "7295ea37-d75a-446c-d7d2-3d180e2a0bd3"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "55"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to build the dataset:\n",
        "\n",
        "# to define the context window: the number of characters to take to predict the next character\n",
        "block_size = 3\n",
        "\n",
        "# to define a function 'build_dataset' that takes a list of words as input\n",
        "def build_dataset(words):\n",
        "\n",
        "  # to start empty lists 'X' and 'Y' to store INPUT pairs\n",
        "  # 'X' is the INPUT into neural network, 'Y' is Label for each 'X'\n",
        "  X, Y = [], []\n",
        "\n",
        "  # to iterate through each word in the INPUT list words\n",
        "  for w in words:\n",
        "    # to start a padded context of 0 tokens with length equal to the block_size\n",
        "    context = [0] * block_size\n",
        "\n",
        "    # to iterate through each character in the word concatenated with a period (.) indicating the end of the word\n",
        "    for ch in w + '.': # iterate over all the characters\n",
        "\n",
        "      # to retrieves the index of the current character 'ch' from a dictionary 'stoi' that maps characters to their corresponding indices\n",
        "      # to get the characters in a sequence\n",
        "      ix = stoi[ch]\n",
        "\n",
        "      # to append the current context to the input list X\n",
        "      X.append(context)\n",
        "      # to append the index of the next character to the label list Y\n",
        "      Y.append(ix)\n",
        "      # to update the context by removing the first element and adding the index of the current character to the end,\n",
        "      # to create a rolling window of contexts\n",
        "      context = context[1:] + [ix]\n",
        "\n",
        "  # to convert the input list X into a PyTorch tensor\n",
        "  X = torch.tensor(X)\n",
        "  # to converts the input list Y into a PyTorch tensor\n",
        "  Y = torch.tensor(Y)\n",
        "\n",
        "  # to prints the shapes of X and Y tensors\n",
        "  print(X.shape, Y.shape)\n",
        "  # to return X and Y tensor as the output of the 'build_dataset' function\n",
        "  return X, Y\n",
        "\n",
        "# to import the 'random' module\n",
        "import random\n",
        "# to set the random seed to 42 for reproducibility\n",
        "random.seed(42)\n",
        "# to shuffle the list of words randomly\n",
        "random.shuffle(words)\n",
        "\n",
        "# to calculate the index n1, which corresponds to 80% of the total number of words\n",
        "n1 = int(0.8*len(words))\n",
        "# to calculate the index n2, which corresponds to 90% of the total number of words\n",
        "n2 = int(0.9*len(words))\n",
        "\n",
        "# to build the TRAINING dataset (Xtr, Ytr) using the first 80% of the shuffled words (n1)\n",
        "Xtr, Ytr = build_dataset(words[:n1])\n",
        "\n",
        "# to build the VALIDATION dataset (Xdev, Ydev) using the next 10% of the shuffled words (n2 - n1)\n",
        "Xdev, Ydev = build_dataset(words[n1:n2])\n",
        "\n",
        "# to bugild the TEST dataset (Xte, Yte) using the remaining 10% of the shuffled words (100% - n2)\n",
        "Xte, Yte = build_dataset(words[n2:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "84OcvcSL5RLs",
        "outputId": "fba4da03-d8ef-46aa-e8c6-954e455632b0"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([6864, 3]) torch.Size([6864])\n",
            "torch.Size([857, 3]) torch.Size([857])\n",
            "torch.Size([840, 3]) torch.Size([840])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to initialize parameters for a neural network model:\n",
        "\n",
        "# to create a random number generator for reproducibility\n",
        "g = torch.Generator().manual_seed(2147483647)\n",
        "\n",
        "# to build an INPUT layer, a random tensor C with dimensions (55, 10), where 55 is number of rows (characters in vocabulary) represented by a 10-dim embedding\n",
        "C = torch.randn((55, 10), generator=g)\n",
        "\n",
        "# to buld a HIDDEN layer of random weight matrix W1 with dimensions (30, 200), where 30 neurons are in the HIDDEN layer,\n",
        "# and each neuron has 200 connections coming from the INPUT layer\n",
        "W1 = torch.randn((30, 200), generator=g)\n",
        "\n",
        "# to build random bias vector b1 with 200 elements associated with  200 neurons in the HIDDEN layer\n",
        "b1 = torch.randn(200, generator=g)\n",
        "\n",
        "# to build a randon weight matrix W2 with dimensions (200, 55) that connecting the HIDDEN layer to the OUTPUT layer\n",
        "W2 = torch.randn((200, 55), generator=g)\n",
        "\n",
        "# to build a random bias vector b2 with 55 elements associated with 55 neurons in the OUTPUT layer\n",
        "b2 = torch.randn(55, generator=g)\n",
        "\n",
        "# to collect all the parameters of the neural network model\n",
        "parameters = [C, W1, b1, W2, b2]"
      ],
      "metadata": {
        "id": "_VFJEQob7g8X"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# number of parameters in total\n",
        "sum(p.nelement() for p in parameters)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FzkFxwLl7Vnh",
        "outputId": "3e61cace-977d-438e-9657-6d07135a5eca"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "17805"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# the loop that iterates over all parameters (C, W1, b1, W2, b2) and sets 'requires_grad' attribute to True.\n",
        "# to indicate that gradients should be computed for these parameters during backpropagation\n",
        "for p in parameters:\n",
        "  p.requires_grad = True"
      ],
      "metadata": {
        "id": "98Ytl22V7l1W"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to initialize a learning rate\n",
        "lre = torch.linspace(-3, 0, 1000)\n",
        "lrs = 10**lre"
      ],
      "metadata": {
        "id": "U46YgjDKitwe"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lri = []\n",
        "lossi = []\n",
        "stepi = []"
      ],
      "metadata": {
        "id": "baM77egq7Xs9"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to train the model:\n",
        "\n",
        "for i in range(200000): # the loop that iterates over 200k training iterations\n",
        "\n",
        "  # to select randomly 32 indices from the training data (Xtr) for creating a minibatch\n",
        "  ix = torch.randint(0, Xtr.shape[0], (32,))\n",
        "\n",
        "  # forward pass:\n",
        "  # to look up embeddings from the matrix C based on the randomly selected indices from the training data (Xtr)\n",
        "  # to create a tensor of shape (32, 3, 2)\n",
        "  emb = C[Xtr[ix]] # (32, 3, 2)\n",
        "\n",
        "  # to compute the HIDDEN layer activations using the embeddings, weight matrix W1, and bias vector b1\n",
        "  # to appliy the tanh function\n",
        "  h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "\n",
        "  # to compute the logits (output of the neural network before applying softmax)\n",
        "  # to multiply the HIDDEN layer with weight W2 and adding bias b2\n",
        "  logits = h @ W2 + b2 # (32, 55)\n",
        "\n",
        "  # to compute the cross-entropy loss between the predicted logits and the true labels (Ytr)\n",
        "  # it uses built-in cross_entropy function\n",
        "  loss = F.cross_entropy(logits, Ytr[ix])\n",
        "\n",
        "  # backward pass:\n",
        "  # the loop resets the gradients of all parameters to None before computing gradients for the current minibatch\n",
        "  for p in parameters:\n",
        "    p.grad = None\n",
        "\n",
        "  # to compute gradients of the loss using backpropagation\n",
        "  loss.backward()\n",
        "\n",
        "  # to adjust the learning rate setting the higher lr of 0.1 for the first 100k iterations\n",
        "  # and lower lr of 0.01 for the remaining iterations\n",
        "  lr = 0.1 if i < 100000 else 0.01\n",
        "\n",
        "  # the loop to update parameters with gradients and the learning rate\n",
        "  for p in parameters:\n",
        "    p.data += -lr * p.grad\n",
        "\n",
        "  # track stats\n",
        "  # to append the current iteration number to the list 'stepi'\n",
        "  stepi.append(i)\n",
        "\n",
        "  # to append the logarithm (base 10) of the loss to the list 'lossi'\n",
        "  lossi.append(loss.log10().item())"
      ],
      "metadata": {
        "id": "eWyFsqH87srN"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to print out the loss value obtained after the last training iteration (how well the model works)\n",
        "print(loss.item())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jiiFtpEt7zcM",
        "outputId": "ea4da632-1cb1-457a-c3d9-66d2310ada73"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.1290957927703857\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to plot the training loss over the course of training\n",
        "# where 'stepi' is the iteration numbers and 'lossi' is the corresponding loss values\n",
        "plt.plot(stepi, lossi)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 448
        },
        "id": "1laVusGH73qr",
        "outputId": "c3fea8d6-bc8a-482f-bd1d-1d09fc8c8644"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7b8cb5681db0>]"
            ]
          },
          "metadata": {},
          "execution_count": 19
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# training loss\n",
        "# to calculate ther trainnig loss by retrieving the embeddings for the training examples (Xtr) from the embedding matrix C\n",
        "emb = C[Xtr] # (32, 3, 2)\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "logits = h @ W2 + b2 # (32, 55)\n",
        "# to calculate cross-enthropy loss between the predicted logits and the labels (Ytr)\n",
        "loss = F.cross_entropy(logits, Ytr)\n",
        "# to print put the results\n",
        "loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rAV7G4G174lg",
        "outputId": "d3b03869-0bf5-4fd1-c5a9-6509cca1b45e"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(1.2643, grad_fn=<NllLossBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# validation loss\n",
        "# to calculate the validation loss using the same process as the training loss but with the validation dataset (Xdev, Ydev)\n",
        "emb = C[Xdev] # (32, 3, 2)\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "logits = h @ W2 + b2 # (32, 55)\n",
        "loss = F.cross_entropy(logits, Ydev)\n",
        "# to print put the results\n",
        "loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ESgkNQkQ769E",
        "outputId": "211980bb-fd77-4906-cd6b-160cb01a29dc"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(5.1243, grad_fn=<NllLossBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# test loss\n",
        "# to calculate the test loss with the test dataset (Xte, Yte)\n",
        "emb = C[Xte] # (32, 3, 2)\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "logits = h @ W2 + b2 # (32, 55)\n",
        "loss = F.cross_entropy(logits, Yte)\n",
        "# to print put the results\n",
        "loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HRYlP1TW785u",
        "outputId": "072ddc53-e92a-4159-c0c7-e8b529177b4a"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(4.6127, grad_fn=<NllLossBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# visualize dimensions 0 and 1 of the embedding matrix C for all characters\n",
        "plt.figure(figsize=(8,8)) # to create a new figure for the plot with size of 8x8 inches\n",
        "\n",
        "# to creates a scatter plot using the first and second dimensions of the embedding matrix C\n",
        "# where point in the scatter plot represents the embedding of a character\n",
        "# the s = 200 argument sets the size of each point to 200\n",
        "plt.scatter(C[:,0].data, C[:,1].data, s = 200)\n",
        "\n",
        "# the loop that iterates over each character embedding in the embedding matrix C\n",
        "for i in range(C.shape[0]):\n",
        "\n",
        "    # the annotatins to the scatter plot at the position of each character's embedding\n",
        "    plt.text(C[i,0].item(), C[i,1].item(), itos[i], ha=\"center\", va=\"center\", color='white')\n",
        "\n",
        "# to add a minor grid to the plot\n",
        "plt.grid('minor')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 676
        },
        "id": "oVlcLUQR7-wf",
        "outputId": "383b1a95-c2e0-4635-fb78-f9ec60119cef"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's sample from the model:\n",
        "\n",
        "# to create a new random number generator with a specific seed (2147483647 + 10)\n",
        "# it will be used to ensure reproducibility in the sampling process\n",
        "g = torch.Generator().manual_seed(2147483647 + 10)\n",
        "\n",
        "# the loop that iterates 50 times to generate 50 text sequences\n",
        "for _ in range(50):\n",
        "\n",
        "    # to initialize an empty list to store the sampled text sequence\n",
        "    out = []\n",
        "    # to initialize the context with a list of zeros\n",
        "    context = [0] * block_size\n",
        "    # to start an infinite loop to sample text until a termination condition is met\n",
        "    while True:\n",
        "      # to retrieve the embeddings for the current context from the embedding matrix C\n",
        "      emb = C[torch.tensor([context])] # (1,block_size,d)\n",
        "      # to compute the activations of the HIDDEN layer neurons using the embeddings, weight W1, and bias b1\n",
        "      h = torch.tanh(emb.view(1, -1) @ W1 + b1)\n",
        "      # to calculate the logits by multiplying the HIDDEN layer activations with weight W2 and adding bias b2\n",
        "      logits = h @ W2 + b2\n",
        "      # to applie the softmax function along dimension 1 (rows) to convert the logits into probabilities\n",
        "      probs = F.softmax(logits, dim=1)\n",
        "      # to sample a single character (index) from the probability distribution defined by probs using the multinomial function to represent the next character in the sequence\n",
        "      ix = torch.multinomial(probs, num_samples=1, generator=g).item()\n",
        "      # to update the context by removing the first element and appending the sampled index to the end to prepare the context for the next iteration of sampling\n",
        "      context = context[1:] + [ix]\n",
        "      # to append the sampled index to the list of sampled indices\n",
        "      out.append(ix)\n",
        "      # the condition to check if the sampled index is the termination token (0) to stop the sampling process\n",
        "      if ix == 0:\n",
        "        break\n",
        "    # to print the sampled text sequence\n",
        "    # to convert the sampled indices (out) back into characters using the itos list and see the generated results :)\n",
        "    print(''.join(itos[i] for i in out))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TZ_Eedn-8Bhh",
        "outputId": "da2ca2b0-27dc-4f03-c8ab-0c5c01c74e5a"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MrMoke.\n",
            "Hazel.\n",
            "Earwig.\n",
            "Hiro.\n",
            "Eddin.\n",
            "Beko.\n",
            "Michaelae.\n",
            "Treadna.\n",
            "Piglet.\n",
            "Elizard.\n",
            "Anna.\n",
            "Tuna.\n",
            "MsAmer.\n",
            "Smudger.\n",
            "Handa.\n",
            "Tyo.\n",
            "Jakey.\n",
            "Beanie.\n",
            "Cooter.\n",
            "Gregs.\n",
            "Johnny.\n",
            "Hayzel.\n",
            "Mails.\n",
            "Diesje.\n",
            "Stamforty.\n",
            "Zelly.\n",
            "Jups.\n",
            "Jacqueak.\n",
            "Kolbs.\n",
            "Fatt.\n",
            "Fup.\n",
            "Oliver.\n",
            "Peaf.\n",
            "SamSam.\n",
            "Calle.\n",
            "Obi.\n",
            "Dipper.\n",
            "Claudio.\n",
            "Lona.\n",
            "Tula.\n",
            "Brown.\n",
            "Sayd.\n",
            "Benry.\n",
            "Tifford.\n",
            "Puddin.\n",
            "Rozzie.\n",
            "Oaks.\n",
            "Beenie.\n",
            "Squit.\n",
            "Gunny.\n"
          ]
        }
      ]
    }
  ]
}