Name_Language_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4639d07e-45a0-46eb-89bb-6ce666321c9a",
   "metadata": {},
   "source": [
    "# Name Classification\n",
    "\n",
    "In this notebook, we'll be creating a simple model for classifying names based upon language. For example: `Schmidhuber` sounds more like a name in the `German language`, whereas `Hinton` sounds more like a name in the `Scottish language`.\n",
    "\n",
    "## Imports\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a9254704-3464-407a-ac26-49d8a4a7748c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import unicodedata, string\n",
    "from glob import glob\n",
    "import torch\n",
    "import torch.nn as nn"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c677ac23-af28-4b89-8851-8838653a0de5",
   "metadata": {},
   "source": [
    "## Dataset\n",
    "\n",
    "The dataset contains of 18 text files named as “[Language].txt”. Each file contains a bunch of names, one name per line, mostly romanized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "859ad645-74ed-470e-bb6f-d1b8b00a0b0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_categories = []\n",
    "category_lines = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a1bbcbf5-deeb-4d77-bf98-f6a7b2d9f1fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Turn a Unicode string to plain ASCII\n",
    "def unicodeToAscii(s):\n",
    "    return ''.join(\n",
    "        c for c in unicodedata.normalize('NFD', s)\n",
    "        if unicodedata.category(c) != 'Mn'\n",
    "        and c in all_letters\n",
    "    )\n",
    "\n",
    "def read_file(fpath):\n",
    "    lines = open(fpath, \"r\").read().strip().split('\\n')\n",
    "    return [unicodeToAscii(line) for line in lines]\n",
    "\n",
    "all_letters = string.ascii_letters + \" .,;'\"\n",
    "n_letters = len(all_letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bda6898b-b2f1-46a9-8ec7-7c83f45358e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read language names into array, and {language: [names]} into a dictionary\n",
    "for fpath in glob(\"./data/names/*.txt\"):\n",
    "    category = os.path.basename(fpath).split(\".txt\")[0]\n",
    "    all_categories.append(category)\n",
    "    lines = read_file(fpath)\n",
    "    category_lines[category] = lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5f13e19d-89d9-4f62-9f4e-ad7ad3755c5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Czech',\n",
       " 'German',\n",
       " 'Arabic',\n",
       " 'Japanese',\n",
       " 'Chinese',\n",
       " 'Vietnamese',\n",
       " 'Russian',\n",
       " 'French',\n",
       " 'Irish',\n",
       " 'English',\n",
       " 'Spanish',\n",
       " 'Greek',\n",
       " 'Italian',\n",
       " 'Portuguese',\n",
       " 'Scottish',\n",
       " 'Dutch',\n",
       " 'Korean',\n",
       " 'Polish']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "339c7095-78b7-4a37-ae69-281b5199c945",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Abbing', 'Abel', 'Abeln', 'Abt', 'Achilles']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "category_lines[\"German\"][:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f63c498c-7d35-4ff4-8e4f-bb6472d74d8e",
   "metadata": {},
   "source": [
    "## Turning Names into Tensor\n",
    "\n",
    "To convert names into tensors, we split names into characters and represent each character as a `One Hot Encoded` vector representation of size `<1 x n_letters>`. Then, to make a word we join a bunch of these representations into a 2D matrix of size `<word_length, 1, n_letters>`.\n",
    "\n",
    "For example: \n",
    "\n",
    "A word `ape` can be represented in One Hot Vector as follows:\n",
    "\n",
    "```\n",
    "a b c d e f g h i j k l m n o p q r s t u v w x y z\n",
    "\n",
    "1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
    "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0\n",
    "0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
    "\n",
    "Shape: [3, 1, 26]\n",
    "```\n",
    "\n",
    "**Note:**\n",
    "\n",
    "1. In the example above, `1` represents the batch size. Since, we are using only 1 word, the batch size is 1. \n",
    "2. Also, the 26 in n_letters used above is when only considering characters from a to z. In practice, we'll have characters from `a to z`, `A to Z` and special characters ` .,;'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1f6caf94-31f6-47f2-a73c-cc7e63a12df6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper Functions\n",
    "\n",
    "# Get index of letter\n",
    "def letterToIndex(letter):\n",
    "    return all_letters.find(letter)\n",
    "\n",
    "\n",
    "def letterToTensor(letter):\n",
    "    ohe_letter = torch.zeros(1, n_letters)\n",
    "    ohe_letter[0][letterToIndex(letter)] = 1\n",
    "    \n",
    "    return ohe_letter\n",
    "\n",
    "\n",
    "# Function to convert Word to OHE Tensor\n",
    "def lineToTensor(line):\n",
    "    # Initialize word tensor with zeros\n",
    "    ohe_word = torch.zeros(len(line), 1, n_letters)\n",
    "    \n",
    "    # Go through all letters in the word and set to 1 \n",
    "    # corresponding to index of letter in word\n",
    "    for idx, letter in enumerate(line):\n",
    "        ohe_word[idx][0][letterToIndex(letter)] = 1\n",
    "    \n",
    "    return ohe_word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a32e7b5b-c127-447f-99b4-45da901f3f71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letterToIndex:  35\n",
      "lineToTensor: tensor([[[1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "          0., 0., 0., 0., 0., 0.]],\n",
      "\n",
      "        [[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.,\n",
      "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "          0., 0., 0., 0., 0., 0.]],\n",
      "\n",
      "        [[0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "          0., 0., 0., 0., 0., 0.]]]), \n",
      "shape: torch.Size([3, 1, 57])\n"
     ]
    }
   ],
   "source": [
    "# Test\n",
    "print(\"letterToIndex: \", letterToIndex('J'))\n",
    "print(f\"lineToTensor: {lineToTensor('ape')}, \\nshape: {lineToTensor('ape').shape}\")"
   ]
  },
  {
   "attachments": {
    "5cc9616f-ca65-41d6-88c3-fb7ba4073ccf.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "c94058e0-3660-4026-b2e5-f71ca8e752b3",
   "metadata": {},
   "source": [
    "## Creating the Network\n",
    "\n",
    "Here, we'll create a simple RNN model first for performing classification.\n",
    "\n",
    "![image.png](attachment:5cc9616f-ca65-41d6-88c3-fb7ba4073ccf.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "44190b37-2bb5-410c-821b-38b66e0bd0d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNN(nn.Module):\n",
    "    def __init__(self, in_size, hidden_size, out_size):\n",
    "        super(RNN, self).__init__()\n",
    "        \n",
    "        self.hidden_size = hidden_size\n",
    "        \n",
    "        # Combined Layer Output = input + hidden\n",
    "        self.i2o = nn.Linear(in_features=in_size + hidden_size, out_features=out_size)\n",
    "        self.i2h = nn.Linear(in_features=in_size + hidden_size, out_features=hidden_size)\n",
    "        self.softmax = nn.LogSoftmax(dim=1)\n",
    "    \n",
    "    def forward(self, input, hidden):\n",
    "        # print(f\"in: {input}, shape: {input.shape}\")\n",
    "        # print(f\"\\nhidden_prev: {hidden}, shape: {hidden.shape}\")\n",
    "        \n",
    "        combined = torch.cat((input, hidden), 1)\n",
    "        # print(f\"\\ncombined: {combined}, shape: {combined.shape}\")\n",
    "        \n",
    "        hidden = self.i2h(combined)\n",
    "        # print(f\"\\nhidden_next: {hidden}, shape: {hidden.shape}\")\n",
    "        \n",
    "        output = self.softmax(self.i2o(combined))\n",
    "        # print(f\"\\noutput: {output}, shape{output.shape}\")\n",
    "        \n",
    "        return output, hidden\n",
    "    \n",
    "    # Initialize Hidden Layer with Zeros\n",
    "    def initHidden(self):\n",
    "        return torch.zeros((1, self.hidden_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dca40369-8f67-427b-b3dc-4a8a9835aff6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RNN(\n",
      "  (i2o): Linear(in_features=185, out_features=18, bias=True)\n",
      "  (i2h): Linear(in_features=185, out_features=128, bias=True)\n",
      "  (softmax): LogSoftmax(dim=1)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "n_categories = len(all_categories)\n",
    "n_hidden = 128\n",
    "\n",
    "rnn = RNN(in_size=n_letters, hidden_size=n_hidden, out_size=n_categories)\n",
    "print(rnn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5e444f5b-563d-4cf7-8456-6885bf9658e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output: torch.Size([1, 18]), next_hidden: torch.Size([1, 128])\n"
     ]
    }
   ],
   "source": [
    "# TEST: One Character as Input\n",
    "input = letterToTensor(\"A\")\n",
    "hidden = torch.zeros(1, n_hidden)\n",
    "\n",
    "output, next_hidden = rnn(input, hidden)\n",
    "print(f\"output: {output.shape}, next_hidden: {next_hidden.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "24caac2a-1c56-4ef0-8c42-c18d2ed0ca29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output: tensor([[-2.9388, -3.0059, -2.9733, -2.9006, -2.9282, -2.9148, -2.9378, -2.9886,\n",
      "         -2.8060, -2.9766, -2.8329, -2.8388, -2.8630, -2.8619, -2.8397, -2.7695,\n",
      "         -2.8216, -2.8692]], grad_fn=<LogSoftmaxBackward0>), shape: torch.Size([1, 18])\n",
      "\n",
      "next_hidden: tensor([[ 0.0414, -0.0731,  0.0592, -0.0429, -0.0566,  0.0569, -0.0497, -0.0544,\n",
      "          0.0060, -0.0199, -0.0488, -0.0314, -0.0628,  0.0467, -0.0380, -0.0885,\n",
      "          0.0154,  0.0218,  0.0203,  0.1115,  0.0593,  0.0402,  0.0780,  0.0087,\n",
      "         -0.0194, -0.0370, -0.0160,  0.1268, -0.0216, -0.0432, -0.0152,  0.0408,\n",
      "          0.0953,  0.0616,  0.0712, -0.0235, -0.0072,  0.1011,  0.0773,  0.0185,\n",
      "         -0.1373,  0.0080,  0.0302, -0.0574, -0.0644,  0.1190,  0.1007, -0.0246,\n",
      "          0.0928, -0.0052,  0.0865, -0.0494, -0.0088,  0.0452,  0.0240,  0.0438,\n",
      "         -0.0140,  0.0085,  0.0051, -0.0641, -0.0378, -0.0622,  0.0122, -0.0484,\n",
      "          0.1204,  0.0523,  0.0057, -0.0035,  0.0116,  0.0102,  0.0568, -0.0564,\n",
      "         -0.0337,  0.1054, -0.0160, -0.0740, -0.0227,  0.0993,  0.0864,  0.0935,\n",
      "         -0.0080, -0.0317, -0.0238,  0.0393,  0.0135, -0.0971, -0.0458,  0.0368,\n",
      "          0.0112, -0.0127, -0.0140, -0.0656, -0.0063, -0.0363, -0.0920, -0.0694,\n",
      "         -0.1187, -0.0422,  0.0352, -0.1108,  0.0022, -0.0431,  0.0387, -0.0051,\n",
      "         -0.0274, -0.0305,  0.0173,  0.1113,  0.0172, -0.0741, -0.1178,  0.0175,\n",
      "         -0.0037,  0.0291,  0.0534,  0.0874,  0.0808, -0.0440, -0.0488, -0.0946,\n",
      "          0.1057,  0.1110,  0.0071, -0.0934, -0.0684,  0.0501, -0.0652, -0.0042]],\n",
      "       grad_fn=<AddmmBackward0>), shape: torch.Size([1, 128])\n"
     ]
    }
   ],
   "source": [
    "# TEST: Full Word as Input\n",
    "input = lineToTensor(\"Anuj\")\n",
    "hidden = torch.zeros(1, n_hidden)\n",
    "\n",
    "output, next_hidden = rnn(input[0], hidden)\n",
    "print(f\"output: {output}, shape: {output.shape}\")\n",
    "print(f\"\\nnext_hidden: {next_hidden}, shape: {next_hidden.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24aa0c54-385a-4163-b5cb-ed1822379d7c",
   "metadata": {},
   "source": [
    "As we can see the output is a `<1 x n_categories>` Tensor, where every item is the likelihood of that category (higher is more likely)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69473176-435e-4087-9dcd-0c2fc164e5af",
   "metadata": {},
   "source": [
    "## Training\n",
    "\n",
    "Before going into training we should make a few helper functions. The first is to interpret the output of the network, which we know to be a likelihood of each category. We can use `Tensor.topk` to get the index of the greatest value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "01efde95-af59-41cf-abe2-a948a8e3b441",
   "metadata": {},
   "outputs": [],
   "source": [
    "def categoryFromOutput(output):\n",
    "    # Index of top-1 probability from predictions\n",
    "    top_n, top_i = output.topk(1)\n",
    "    category_i = top_i[0].item()\n",
    "    \n",
    "    return all_categories[category_i], category_i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f2946213-f3c6-4f7a-a2e5-1d36a250c80e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Dutch', 15)\n"
     ]
    }
   ],
   "source": [
    "# Predicted label & category index\n",
    "print(categoryFromOutput(output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1fed2c60-4d01-4b0a-831e-77c38ea299a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "category = Czech / line = Cermak / category_tensor_shape = torch.Size([1]) / line_tensor_shape = torch.Size([6, 1, 57])\n",
      "category = Russian / line = Yatzyshin / category_tensor_shape = torch.Size([1]) / line_tensor_shape = torch.Size([9, 1, 57])\n",
      "category = German / line = Grosz / category_tensor_shape = torch.Size([1]) / line_tensor_shape = torch.Size([5, 1, 57])\n",
      "category = Italian / line = Lama / category_tensor_shape = torch.Size([1]) / line_tensor_shape = torch.Size([4, 1, 57])\n",
      "category = Chinese / line = Yep / category_tensor_shape = torch.Size([1]) / line_tensor_shape = torch.Size([3, 1, 57])\n",
      "category = English / line = Robbins / category_tensor_shape = torch.Size([1]) / line_tensor_shape = torch.Size([7, 1, 57])\n",
      "category = Spanish / line = Suarez / category_tensor_shape = torch.Size([1]) / line_tensor_shape = torch.Size([6, 1, 57])\n",
      "category = Polish / line = Kaluza / category_tensor_shape = torch.Size([1]) / line_tensor_shape = torch.Size([6, 1, 57])\n",
      "category = English / line = Gilks / category_tensor_shape = torch.Size([1]) / line_tensor_shape = torch.Size([5, 1, 57])\n",
      "category = Chinese / line = Khu / category_tensor_shape = torch.Size([1]) / line_tensor_shape = torch.Size([3, 1, 57])\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def randomChoice(l):\n",
    "    return l[random.randint(0, len(l) - 1)]\n",
    "\n",
    "def randomTrainingExample():\n",
    "    # Pick a category at random from all categories\n",
    "    category = randomChoice(all_categories)\n",
    "    \n",
    "    # Get random name from the selected category\n",
    "    line = randomChoice(category_lines[category])\n",
    "    \n",
    "    # GT Label - Category Tensor containing index of categories\n",
    "    category_tensor = torch.tensor([all_categories.index(category)], dtype=torch.long)\n",
    "    \n",
    "    # Create a One Hot Encoded Tensor corresponding to the characters\n",
    "    # in the random name selected from a random category\n",
    "    # Shape = (len(word), 1, total_number_of_letters)\n",
    "    line_tensor = lineToTensor(line)\n",
    "    \n",
    "    return category, line, category_tensor, line_tensor\n",
    "\n",
    "\n",
    "for i in range(10):\n",
    "    category, line, category_tensor, line_tensor = randomTrainingExample()\n",
    "    print('category =', category, '/ line =', line, '/ category_tensor_shape =', category_tensor.shape, '/ line_tensor_shape =', line_tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "58d945eb-03c3-4112-9361-47ea08abc3f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loss\n",
    "criterion = nn.NLLLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8095a51e-e98f-460f-a29e-0c3f9901a39d",
   "metadata": {},
   "source": [
    "Each loop of training will:\n",
    "\n",
    "1. Create input and target tensors\n",
    "2. Create a zeroed initial hidden state\n",
    "3. Read each letter in and\n",
    "4. Keep hidden state for next letter\n",
    "5. Compare final output to target\n",
    "6. Back-propagate the loss\n",
    "7. Return the output and loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "cb130796-8073-43bc-9a6d-03b9f91c75e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Learning Rate\n",
    "lr = 0.005\n",
    "\n",
    "def train(category_tensor, line_tensor):\n",
    "    \"\"\"\n",
    "        category_tensor: Ground Truth tensor containing the index of language category\n",
    "        line_tensor: Tensor containing One Hot Encoded characters in a word\n",
    "    \"\"\"\n",
    "    \n",
    "    # Initial Hidden State - torch.zero() tensor\n",
    "    hidden = rnn.initHidden()\n",
    "    \n",
    "    rnn.zero_grad()\n",
    "    \n",
    "    # Pass in OHE tensor for each word, character by character\n",
    "    for i in range(line_tensor.size()[0]):\n",
    "        # Output and next hidden state\n",
    "        output, hidden = rnn(line_tensor[i], hidden)\n",
    "    \n",
    "    loss = criterion(output, category_tensor)\n",
    "    loss.backward()\n",
    "    \n",
    "    # Add parameters' gradients to their values, multiplied by learning rate\n",
    "    for p in rnn.parameters():\n",
    "        p.data.add_(p.grad.data, alpha=-lr)\n",
    "    \n",
    "    return output, loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "339f87eb-32c9-4f96-9ed3-25c0570a337a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "03495018-b55f-45d1-af48-3970b342bb14",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_iters = 100000\n",
    "print_every = 5000\n",
    "plot_every = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "89b995cd-77ba-4f6d-a476-d3fa8c2ba50b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Keep track of losses for plotting\n",
    "current_loss = 0\n",
    "all_losses = []\n",
    "\n",
    "def timeSince(since):\n",
    "    now = time.time()\n",
    "    s = now - since\n",
    "    m = math.floor(s / 60)\n",
    "    s -= m * 60\n",
    "    return '%dm %ds' % (m, s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b8b0cfb4-c0b1-4a6e-827c-1f798af289d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5000 5% (0m 3s) 2.4079 Amerighi / Dutch ✗ (Italian)\n",
      "10000 10% (0m 6s) 1.3826 Nam / Chinese ✗ (Korean)\n",
      "15000 15% (0m 9s) 2.1845 D'cruz / Spanish ✗ (Portuguese)\n",
      "20000 20% (0m 12s) 3.4283 Amador / Russian ✗ (Spanish)\n",
      "25000 25% (0m 15s) 0.7827 Hishida / Japanese ✓\n",
      "30000 30% (0m 19s) 1.4981 Sokolof / Czech ✗ (Polish)\n",
      "35000 35% (0m 22s) 2.8204 Gonzalez / Spanish ✗ (English)\n",
      "40000 40% (0m 25s) 1.6948 Urbina / Italian ✗ (Spanish)\n",
      "45000 45% (0m 28s) 0.7381 Podolinsky / Russian ✓\n",
      "50000 50% (0m 31s) 0.2599 Riagan / Irish ✓\n",
      "55000 55% (0m 35s) 0.8771 Murray / Scottish ✓\n",
      "60000 60% (0m 38s) 0.8228 Makino / Japanese ✓\n",
      "65000 65% (0m 42s) 1.3310 Greenberg / Dutch ✗ (German)\n",
      "70000 70% (0m 45s) 3.8880 Vandale / French ✗ (Dutch)\n",
      "75000 75% (0m 49s) 3.2326 Gaspar / Portuguese ✗ (Spanish)\n",
      "80000 80% (0m 52s) 2.9876 Sessa / Czech ✗ (Italian)\n",
      "85000 85% (0m 56s) 0.6299 Gong / Chinese ✓\n",
      "90000 90% (0m 59s) 0.2075 Khoury / Arabic ✓\n",
      "95000 95% (1m 2s) 2.5050 Baumbach / French ✗ (German)\n",
      "100000 100% (1m 6s) 3.0053 Almasi / Italian ✗ (Arabic)\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "\n",
    "for iter in range(1, n_iters + 1):\n",
    "    # Get a tensor for a random word and corresponding Ground truth category Tensor\n",
    "    category, line, category_tensor, line_tensor = randomTrainingExample()\n",
    "    \n",
    "    # Train the Model, returns output at current timestep & next hidden state\n",
    "    output, loss = train(category_tensor, line_tensor)\n",
    "    current_loss += loss\n",
    "\n",
    "    # Print iter number, loss, name and guess\n",
    "    if iter % print_every == 0:\n",
    "        guess, guess_i = categoryFromOutput(output)\n",
    "        correct = '✓' if guess == category else '✗ (%s)' % category\n",
    "        print('%d %d%% (%s) %.4f %s / %s %s' % (iter, iter / n_iters * 100, timeSince(start), loss, line, guess, correct))\n",
    "\n",
    "    # Add current loss avg to list of losses\n",
    "    if iter % plot_every == 0:\n",
    "        all_losses.append(current_loss / plot_every)\n",
    "        current_loss = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "97ad8f7c-e7d5-42aa-8e27-d4a4943b0257",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1245b33a0>]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting the Training Results\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(all_losses)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45b57ce7-2bbd-4327-b725-a1a43f6253f6",
   "metadata": {},
   "source": [
    "## Evaluate Trained Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "5e957d79-87c3-4eca-abba-733dd6d6e061",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just return an output given a line\n",
    "def evaluate(line_tensor):\n",
    "    hidden = rnn.initHidden()\n",
    "\n",
    "    for i in range(line_tensor.size()[0]):\n",
    "        output, hidden = rnn(line_tensor[i], hidden)\n",
    "\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9c9f2889-2afb-4f9b-b2bd-8e1362922b44",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Keep track of correct guesses in a confusion matrix\n",
    "confusion = torch.zeros(n_categories, n_categories)\n",
    "n_confusion = 10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "82a86e25-1086-4263-91ab-006834f8650f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Go through a bunch of examples and record which are correctly guessed\n",
    "for i in range(n_confusion):\n",
    "    category, line, category_tensor, line_tensor = randomTrainingExample()\n",
    "    output = evaluate(line_tensor)\n",
    "    guess, guess_i = categoryFromOutput(output)\n",
    "    category_i = all_categories.index(category)\n",
    "    confusion[category_i][guess_i] += 1\n",
    "\n",
    "# Normalize by dividing every row by its sum\n",
    "for i in range(n_categories):\n",
    "    confusion[i] = confusion[i] / confusion[i].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "46f64214-7735-412a-98d5-9e7291d859c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/rk/3j211bj53lb3k3wgfh02x3p80000gn/T/ipykernel_5565/1733772511.py:8: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_xticklabels([''] + all_categories, rotation=90)\n",
      "/var/folders/rk/3j211bj53lb3k3wgfh02x3p80000gn/T/ipykernel_5565/1733772511.py:9: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_yticklabels([''] + all_categories)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set up plot\n",
    "fig = plt.figure(figsize=(20,10))\n",
    "ax = fig.add_subplot(111)\n",
    "cax = ax.matshow(confusion.numpy())\n",
    "fig.colorbar(cax)\n",
    "\n",
    "# Set up axes\n",
    "ax.set_xticklabels([''] + all_categories, rotation=90)\n",
    "ax.set_yticklabels([''] + all_categories)\n",
    "\n",
    "# Force label at every tick\n",
    "ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "\n",
    "# sphinx_gallery_thumbnail_number = 2\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e6aaa78-6d7f-434f-80c9-32aaae1cba77",
   "metadata": {},
   "source": [
    "## Inferencing on User Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "21a939c2-2378-41e1-9151-f5af2ea83fa3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(input_line, n_predictions=3):\n",
    "    print('\\n> %s' % input_line)\n",
    "    with torch.no_grad():\n",
    "        output = evaluate(lineToTensor(input_line))\n",
    "\n",
    "        # Get top N categories\n",
    "        topv, topi = output.topk(n_predictions, 1, True)\n",
    "        predictions = []\n",
    "\n",
    "        for i in range(n_predictions):\n",
    "            value = topv[0][i].item()\n",
    "            category_index = topi[0][i].item()\n",
    "            print('(%.2f) %s' % (value, all_categories[category_index]))\n",
    "            predictions.append([value, all_categories[category_index]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "99bfbf22-e891-4340-8505-f9c98d23c8df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "> Jackson\n",
      "(-0.34) Scottish\n",
      "(-2.09) English\n",
      "(-3.02) Russian\n"
     ]
    }
   ],
   "source": [
    "predict('Jackson')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "121c410d-fb96-4e74-8f8b-683d007c47b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "> Satoshi\n",
      "(-1.09) Japanese\n",
      "(-1.69) Arabic\n",
      "(-1.89) Italian\n"
     ]
    }
   ],
   "source": [
    "predict('Satoshi')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}