predict-language-of-a-name.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Simplified and modified from the PyTorch tutorial available here:\n",
    "\n",
    "https://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html#creating-the-network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from io import open\n",
    "import glob\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "['datasets/Czech.txt', 'datasets/German.txt', 'datasets/Arabic.txt', 'datasets/Japanese.txt', 'datasets/Chinese.txt', 'datasets/Vietnamese.txt', 'datasets/Russian.txt', 'datasets/French.txt', 'datasets/Irish.txt', 'datasets/English.txt', 'datasets/Spanish.txt', 'datasets/Greek.txt', 'datasets/Italian.txt', 'datasets/Portuguese.txt', 'datasets/Scottish.txt', 'datasets/Dutch.txt', 'datasets/Korean.txt', 'datasets/Polish.txt']\n"
     ]
    }
   ],
   "source": [
    "print(glob.glob('datasets/*.txt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ .,;'\""
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unicodedata\n",
    "import string\n",
    "\n",
    "all_letters = string.ascii_letters + \" .,;'\"\n",
    "n_letters = len(all_letters)\n",
    "\n",
    "all_letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "57"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_letters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build the language_names dictionary, a list of names per language"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "language_names = {}\n",
    "\n",
    "all_languages = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Read a file and split into lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Turn a Unicode string to plain ASCII (may alter the meaning of words)\n",
    "https://stackoverflow.com/questions/517923/what-is-the-best-way-to-remove-accents-in-a-python-unicode-string/518232#518232"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Emile\n"
     ]
    }
   ],
   "source": [
    "print(unicodeToAscii('Émile'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findFiles(path): \n",
    "    return glob.glob(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_names = 0\n",
    "\n",
    "for filename in findFiles('datasets/*.txt'):\n",
    "    \n",
    "    language = os.path.splitext(os.path.basename(filename))[0]\n",
    "    \n",
    "    all_languages.append(language)\n",
    "    \n",
    "    read_names = open(filename, encoding='utf-8').read().strip().split('\\n')\n",
    "    \n",
    "    names = [unicodeToAscii(line) for line in read_names]\n",
    "    \n",
    "    language_names[language] = names\n",
    "    \n",
    "    total_names += len(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### There are 18 languages to which a name can be classified into"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "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": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_languages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_languages = len(all_languages)\n",
    "n_languages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20074"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have language_names, a dictionary mapping each category (language) to a list of lines (names). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Abl', 'Adsit', 'Ajdrna', 'Alt', 'Antonowitsch']\n"
     ]
    }
   ],
   "source": [
    "print(language_names['Czech'][:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Turning Names into Tensors\n",
    "\n",
    "Represent each name in one-hot encoded form (1 for the position of the letter, 0 elsewhere)\n",
    "\n",
    "To make a word we join a bunch of those into a 2D matrix <line_length x 1 x n_letters>.\n",
    "That extra 1 dimension is because PyTorch assumes everything is in batches - we're just using a batch size of 1 here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def letterToTensor(letter):\n",
    "    \n",
    "    tensor = torch.zeros(1, n_letters)\n",
    "    tensor[0][all_letters.find(letter)] = 1\n",
    "    \n",
    "    return tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 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., 0.,\n",
      "         0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "         0., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "print(letterToTensor('a'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[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., 0., 0., 0.,\n",
      "         0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.,\n",
      "         0., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "print(letterToTensor('Z'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nameToTensor(name):\n",
    "    tensor = torch.zeros(len(name), 1, n_letters)\n",
    "    \n",
    "    for li, letter in enumerate(name):\n",
    "        tensor[li][0][all_letters.find(letter)] = 1\n",
    "    \n",
    "    return tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([4, 1, 57])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mary_tensor = nameToTensor('Mary')\n",
    "\n",
    "mary_tensor.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[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., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0.]],\n",
       "\n",
       "        [[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., 0., 0.,\n",
       "          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.]],\n",
       "\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., 1., 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.]]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mary_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "\n",
    "class RNN(nn.Module):\n",
    "    \n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        \n",
    "        super(RNN, self).__init__()\n",
    "\n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        self.i2h = nn.Linear(input_size + hidden_size, hidden_size)\n",
    "        \n",
    "        self.i2o = nn.Linear(input_size + hidden_size, output_size)\n",
    "        \n",
    "        self.softmax = nn.LogSoftmax(dim=1)\n",
    "\n",
    "    def forward(self, input, hidden):\n",
    "        combined = torch.cat((input, hidden), 1)\n",
    "        \n",
    "        hidden = self.i2h(combined)\n",
    "        \n",
    "        output = self.i2o(combined)\n",
    "        output = self.softmax(output)\n",
    "        \n",
    "        return output, hidden\n",
    "\n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, self.hidden_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_hidden = 256\n",
    "\n",
    "rnn = RNN(n_letters, n_hidden, n_languages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Manually testing the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output size = torch.Size([1, 18])\n",
      "next_hidden size = torch.Size([1, 256])\n"
     ]
    }
   ],
   "source": [
    "inp = letterToTensor('C')\n",
    "\n",
    "hidden = torch.zeros(1, n_hidden)\n",
    "\n",
    "output, next_hidden = rnn(inp, hidden)\n",
    "\n",
    "print('output size =', output.size())\n",
    "print('next_hidden size =', next_hidden.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can see the output is a < 1 x n_categories >"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "inp = nameToTensor('Charron')\n",
    "\n",
    "hidden = torch.zeros(1, n_hidden)\n",
    "\n",
    "output, next_hidden = rnn(inp[0], hidden)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-2.9201, -2.8437, -2.9337, -2.8996, -2.9487, -2.8158, -2.8755, -2.8304,\n",
      "         -2.8963, -2.8802, -2.9558, -2.9442, -2.9310, -2.8827, -2.8514, -2.8347,\n",
      "         -2.8924, -2.9064]], grad_fn=<LogSoftmaxBackward>)\n"
     ]
    }
   ],
   "source": [
    "print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.0460,  0.0001,  0.0199,  0.0120, -0.0108,  0.0264, -0.0025,  0.0840,\n",
      "          0.0578,  0.0481, -0.0841, -0.0279, -0.0607, -0.0228,  0.0506,  0.0262,\n",
      "          0.0307,  0.0785,  0.0396,  0.0019,  0.0524,  0.0039, -0.0044, -0.0992,\n",
      "          0.0384,  0.0863, -0.0095, -0.0299,  0.0898,  0.0107,  0.0447, -0.0552,\n",
      "         -0.0270, -0.0288, -0.0802,  0.0136,  0.0089,  0.0488, -0.0442, -0.0615,\n",
      "         -0.0090, -0.0308, -0.0509,  0.0606, -0.1017, -0.0037, -0.0155, -0.0220,\n",
      "         -0.0805, -0.0056,  0.0604, -0.0678,  0.0770,  0.0403,  0.0572,  0.0000,\n",
      "          0.0956,  0.0672,  0.0059, -0.0413, -0.0189, -0.0105,  0.0015, -0.1103,\n",
      "         -0.0397, -0.0075, -0.0595, -0.0448, -0.0556, -0.0476,  0.0318, -0.0724,\n",
      "         -0.0046, -0.0015, -0.0459,  0.0496,  0.0539,  0.0351, -0.0775, -0.0371,\n",
      "          0.1074,  0.0910, -0.0803, -0.0086,  0.0618,  0.0257, -0.0180, -0.0290,\n",
      "         -0.0665,  0.0225, -0.0192,  0.0066, -0.0031,  0.0217,  0.0353, -0.0436,\n",
      "          0.0716, -0.0304, -0.0146, -0.0414, -0.0599, -0.0171,  0.0071,  0.0625,\n",
      "          0.0705,  0.0693, -0.0365, -0.0056, -0.0093,  0.0206,  0.0520,  0.0920,\n",
      "          0.0901,  0.0245, -0.0452, -0.0424,  0.0619, -0.0140, -0.0390, -0.0019,\n",
      "         -0.0509, -0.1089, -0.0228,  0.0956,  0.0080, -0.0076, -0.0081,  0.0572,\n",
      "         -0.0043,  0.0151,  0.0605,  0.0394,  0.0393, -0.0192,  0.0974, -0.0101,\n",
      "         -0.0193,  0.0033, -0.0550, -0.0136,  0.0091,  0.0346, -0.0736,  0.0169,\n",
      "         -0.0577, -0.0240, -0.0114,  0.0253,  0.0709, -0.0293,  0.0871, -0.0438,\n",
      "         -0.0923, -0.0328,  0.0729,  0.0649, -0.0446,  0.0634,  0.0141, -0.0768,\n",
      "         -0.0544, -0.0750, -0.1011,  0.0553,  0.0078, -0.0218, -0.0884, -0.0645,\n",
      "          0.0109,  0.0608,  0.0101,  0.0764,  0.0405, -0.0419,  0.0040, -0.0357,\n",
      "          0.0157,  0.0458,  0.0084, -0.0942,  0.0461,  0.0232, -0.0469,  0.0116,\n",
      "          0.0132,  0.0623,  0.0011, -0.0316, -0.0233, -0.0106,  0.0170, -0.0985,\n",
      "         -0.0378,  0.0383,  0.0106, -0.0111, -0.0137, -0.0308,  0.0145,  0.0471,\n",
      "         -0.0882,  0.0355,  0.0127,  0.0581,  0.0534,  0.0162, -0.0178,  0.0451,\n",
      "          0.0235,  0.0139,  0.0422, -0.0500,  0.0103, -0.0756,  0.0573, -0.0698,\n",
      "         -0.0577, -0.0386, -0.0617, -0.0245,  0.0555, -0.0160, -0.0311, -0.0095,\n",
      "          0.0067,  0.0170,  0.0293,  0.0111,  0.0532, -0.0479,  0.0892, -0.0053,\n",
      "          0.0732,  0.0023,  0.0756, -0.0694, -0.0114,  0.0212,  0.0178, -0.0697,\n",
      "         -0.0594, -0.0082,  0.0521, -0.0551, -0.0504,  0.0718,  0.0211,  0.0346,\n",
      "         -0.0174,  0.0799,  0.0121,  0.0806,  0.0246,  0.0200, -0.0684, -0.0010]],\n",
      "       grad_fn=<ThAddmmBackward>)\n"
     ]
    }
   ],
   "source": [
    "print(next_hidden)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Preparing for Training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We  make a few helper functions  the first one is to interpret the output of the network, which we know to be a likelihood of each language. We can use Tensor.topk to get the index of the greatest value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "def languageFromOutput(output):\n",
    "    \n",
    "    _, top_i = output.topk(1)\n",
    "    \n",
    "    language_i = top_i[0].item()\n",
    "    \n",
    "    return all_languages[language_i], language_i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Vietnamese', 5)\n"
     ]
    }
   ],
   "source": [
    "print(languageFromOutput(output))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also want a quick way to get a training example (a name and its language)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def randomTrainingExample():\n",
    "    \n",
    "    random_language_index = random.randint(0, n_languages - 1)\n",
    "    language = all_languages[random_language_index]\n",
    "    \n",
    "    random_language_names = language_names[language]\n",
    "    \n",
    "    name = random_language_names[random.randint(0, len(random_language_names) - 1)]\n",
    "    \n",
    "    language_tensor = torch.tensor([all_languages.index(language)], dtype=torch.long)\n",
    "    name_tensor = nameToTensor(name)\n",
    "    \n",
    "    return language, name, language_tensor, name_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "language = German , name = Bohn\n",
      "language = French , name = Paquet\n",
      "language = Italian , name = Albani\n",
      "language = Japanese , name = Shigi\n",
      "language = Portuguese , name = Moreno\n",
      "language = Scottish , name = Mackenzie\n",
      "language = Arabic , name = Shamon\n",
      "language = Irish , name = Suaird\n",
      "language = German , name = Reiher\n",
      "language = English , name = Busby\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    language, name, language_tensor, name_tensor = randomTrainingExample()\n",
    "    \n",
    "    print('language =', language, ', name =', name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Training the Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.NLLLoss()\n",
    "learning_rate = 0.005 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each loop of training will:\n",
    "\n",
    "- Create input and target tensors\n",
    "- Create a zeroed initial hidden state\n",
    "- Read each letter in and\n",
    "- Keep hidden state for next letter\n",
    "- Compare final output to target\n",
    "- Back-propagate\n",
    "- Return the output and loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(langauge_tensor, name_tensor):\n",
    "    \n",
    "    hidden = rnn.initHidden()\n",
    "\n",
    "    rnn.zero_grad()\n",
    "\n",
    "    for i in range(name_tensor.size()[0]):\n",
    "        output, hidden = rnn(name_tensor[i], hidden)\n",
    "\n",
    "    loss = criterion(output, langauge_tensor)\n",
    "    loss.backward()\n",
    "\n",
    "    for p in rnn.parameters():\n",
    "        p.data.add_(-learning_rate, p.grad.data)\n",
    "\n",
    "    return output, loss.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we just have to run that with a bunch of examples. Since the train function returns both the output and loss we can print its guesses and also keep track of loss for plotting. Since there are 1000s of examples we print only every print_every examples, and take an average of the loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_iters = 200000\n",
    "\n",
    "current_loss = 0\n",
    "all_losses = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Get a random training input and target\n",
    "- Print iter number, loss, name and guess\n",
    "- Add current loss avg to list of losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5000 2% 2.9732 Klerkx / Spanish ✗ (Dutch)\n",
      "10000 5% 4.0740 Rao / Chinese ✗ (Italian)\n",
      "15000 7% 0.8086 Bertsimas / Greek ✓\n",
      "20000 10% 1.2744 Duong / Vietnamese ✓\n",
      "25000 12% 0.9755 Vuu / Vietnamese ✓\n",
      "30000 15% 2.2516 Chou / Korean ✗ (Chinese)\n",
      "35000 17% 2.4976 Buckholtz / Polish ✗ (German)\n",
      "40000 20% 2.5506 Segal / Irish ✗ (French)\n",
      "45000 22% 1.9578 Vaca / Spanish ✗ (Czech)\n",
      "50000 25% 2.2387 Vogt / French ✗ (German)\n",
      "55000 27% 1.1187 Romao / Portuguese ✓\n",
      "60000 30% 2.1793 Michel / Irish ✗ (Polish)\n",
      "65000 32% 4.4637 Ivor / French ✗ (Irish)\n",
      "70000 35% 0.6650 Pagano / Italian ✓\n",
      "75000 37% 0.5543 Kappel / Dutch ✓\n",
      "80000 40% 0.6744 Baiborodoff / Russian ✓\n",
      "85000 42% 1.7367 Artz / Spanish ✗ (German)\n",
      "90000 45% 2.4913 Rios / Portuguese ✗ (Spanish)\n",
      "95000 47% 1.2147 You / Korean ✗ (Chinese)\n",
      "100000 50% 0.6506 Thai / Vietnamese ✓\n",
      "105000 52% 2.4480 Oberst / Dutch ✗ (German)\n",
      "110000 55% 0.6118 Abasolo / Spanish ✓\n",
      "115000 57% 0.5204 Gomulka / Polish ✓\n",
      "120000 60% 0.6427 Cardozo / Portuguese ✓\n",
      "125000 62% 0.4868 Eoghan / Irish ✓\n",
      "130000 65% 0.4835 Rim / Korean ✓\n",
      "135000 67% 0.6802 Vela / Spanish ✓\n",
      "140000 70% 2.5384 Bleskan / Arabic ✗ (Czech)\n",
      "145000 72% 4.1416 Mein / Chinese ✗ (German)\n",
      "150000 75% 0.4106 Krusen / Dutch ✓\n",
      "155000 77% 0.0082 Agelakos / Greek ✓\n",
      "160000 80% 1.9269 Tracey / French ✗ (Irish)\n",
      "165000 82% 0.1694 Ta / Vietnamese ✓\n",
      "170000 85% 0.5188 Schoorl / Dutch ✓\n",
      "175000 87% 0.2314 Van / Vietnamese ✓\n",
      "180000 90% 0.6076 Dertilis / Greek ✓\n",
      "185000 92% 2.0079 Mcintosh / Czech ✗ (Scottish)\n",
      "190000 95% 0.0273 Wyrzyk / Polish ✓\n",
      "195000 97% 0.0534 Belloni / Italian ✓\n",
      "200000 100% 0.5450 Ngai / Korean ✓\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1, n_iters + 1):\n",
    "    \n",
    "    language, name, language_tensor, name_tensor = randomTrainingExample()\n",
    "    \n",
    "    output, loss = train(language_tensor, name_tensor)\n",
    "    current_loss += loss\n",
    "\n",
    "    if epoch % 5000 == 0:\n",
    "        guess, guess_i = languageFromOutput(output)\n",
    "        correct = '✓' if guess == language else '✗ (%s)' % language\n",
    "        \n",
    "        print('%d %d%% %.4f %s / %s %s' % (epoch, \n",
    "                                           epoch / n_iters * 100,\n",
    "                                           loss,\n",
    "                                           name, \n",
    "                                           guess, \n",
    "                                           correct))\n",
    "\n",
    "    if epoch % 1000 == 0:\n",
    "        all_losses.append(current_loss / 1000)\n",
    "        current_loss = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(all_losses)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running on User Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_predictions = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_name = 'Batsakis' #Re-run for 'Amaya' and 'Bukoski'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-0.17) Greek\n",
      "(-2.43) Russian\n",
      "(-3.92) Dutch\n"
     ]
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    \n",
    "    name_tensor = nameToTensor(input_name)\n",
    "    \n",
    "    hidden = rnn.initHidden()\n",
    "    for i in range(name_tensor.size()[0]):\n",
    "        output, hidden = rnn(name_tensor[i], hidden)\n",
    "\n",
    "    topv, topi = output.topk(n_predictions, 1, True)\n",
    "\n",
    "    for i in range(n_predictions):\n",
    "        \n",
    "        value = topv[0][i].item()\n",
    "        language_index = topi[0][i].item()\n",
    "        \n",
    "        print('(%.2f) %s' % (value, all_languages[language_index]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.7-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}