classifying_names_with_character-level_RNN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A character-level RNN reads words as a series of characters - outputting a prediction and “hidden state” at each step, feeding its previous hidden state into each next step. We take the final prediction to be the output, i.e. which class the word belongs to.\n",
    "\n",
    "Specifically, we’ll train on a few thousand surnames from 18 languages of origin, and predict which language a name is from based on the spelling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import unicode_literals, print_function, division\n",
    "from io import open\n",
    "import glob\n",
    "import os\n",
    "\n",
    "import unicodedata\n",
    "import string\n",
    "import time\n",
    "import math\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findFiles(path): \n",
    "    return glob.glob(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['data/names/Czech.txt', 'data/names/German.txt', 'data/names/Arabic.txt', 'data/names/Japanese.txt', 'data/names/Chinese.txt', 'data/names/Vietnamese.txt', 'data/names/Russian.txt', 'data/names/French.txt', 'data/names/Irish.txt', 'data/names/English.txt', 'data/names/Spanish.txt', 'data/names/Greek.txt', 'data/names/Italian.txt', 'data/names/Portuguese.txt', 'data/names/Scottish.txt', 'data/names/Dutch.txt', 'data/names/Korean.txt', 'data/names/Polish.txt']\n"
     ]
    }
   ],
   "source": [
    "print(findFiles('data/names/*.txt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "57"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return all ASCII letters (both lower and upper case)\n",
    "\n",
    "all_letters = string.ascii_letters + \" .,;'\"\n",
    "n_letters = len(all_letters)\n",
    "n_letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "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",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slusarski\n"
     ]
    }
   ],
   "source": [
    "print(unicodeToAscii('Ślusàrski'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Abandonato', 'Abatangelo', 'Abatantuono', 'Abate', 'Abategiovanni']\n",
      "['Abbas', 'Abbey', 'Abbott', 'Abdi', 'Abel']\n"
     ]
    }
   ],
   "source": [
    "# Build the category_lines dictionary, a list of names per language\n",
    "\n",
    "category_lines = {}\n",
    "all_categories = []\n",
    "\n",
    "# Read a file and split into lines\n",
    "\n",
    "def readLines(filename):\n",
    "    lines = open(filename, encoding='utf-8').read().strip().split('\\n')\n",
    "    return [unicodeToAscii(line) for line in lines]\n",
    "\n",
    "for filename in findFiles('data/names/*.txt'):\n",
    "    category = os.path.splitext(os.path.basename(filename))[0]\n",
    "    all_categories.append(category)\n",
    "    lines = readLines(filename)\n",
    "    category_lines[category] = lines\n",
    "\n",
    "n_categories = len(all_categories)\n",
    "print(category_lines['Italian'][:5])\n",
    "print(category_lines['English'][:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Turning names into tensors:\n",
    "\n",
    "Now that we have all the names organized, we need to turn them into Tensors to make any use of them.\n",
    "\n",
    "To represent a single letter, we use a “one-hot vector” of size <1 x n_letters>. A one-hot vector is filled with 0s except for a 1 at index of the current letter, e.g. \"b\" = <0 1 0 0 0 ...>.\n",
    "\n",
    "To make a word we join a bunch of those into a 2D matrix <line_length x 1 x n_letters>. The extra 1 dimension is because PyTorch assumes everything is in batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "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., 1.,\n",
      "         0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
      "         0., 0., 0.]])\n",
      "torch.Size([5, 1, 57])\n"
     ]
    }
   ],
   "source": [
    "# Find letter index from all_letters, e.g. \"a\" = 0\n",
    "def letterToIndex(letter):\n",
    "    return all_letters.find(letter)\n",
    "\n",
    "# Just for demonstration, turn a letter into a <1 x n_letters> Tensor\n",
    "def letterToTensor(letter):\n",
    "    tensor = torch.zeros(1, n_letters)\n",
    "    tensor[0][letterToIndex(letter)] = 1\n",
    "    return tensor\n",
    "\n",
    "# Turn a line into a <line_length x 1 x n_letters>, or an array of one-hot letter vectors\n",
    "def lineToTensor(line):\n",
    "    tensor = torch.zeros(len(line), 1, n_letters)\n",
    "    for li, letter in enumerate(line):\n",
    "        tensor[li][0][letterToIndex(letter)] = 1\n",
    "    return tensor\n",
    "\n",
    "print(letterToTensor('J'))\n",
    "\n",
    "print(lineToTensor('Jones').size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Network\n",
    "\n",
    "This RNN module is just 2 linear layers which operate on an input and hidden state, with a LogSoftmax layer after the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size):\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",
    "        self.i2o = nn.Linear(input_size + hidden_size, output_size)\n",
    "        self.softmax = nn.LogSoftmasx(dim=1)\n",
    "\n",
    "    def forward(self, input, hidden):\n",
    "        combined = torch.cat((input, hidden), 1)\n",
    "        hidden = self.i2h(combined)\n",
    "        output = self.i2o(combined)\n",
    "        output = self.softmax(output)\n",
    "        return output, hidden\n",
    "\n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, self.hidden_size)\n",
    "\n",
    "n_hidden = 128\n",
    "rnn = RNN(n_letters, n_hidden, n_categories)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To run a step of this network we need to pass an input (in our case, the Tensor for the current letter) and a previous hidden state (which we initialize as zeros at first). We’ll get back the output (probability of each language) and a next hidden state (which we keep for the next step)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "input = letterToTensor('A')\n",
    "hidden =torch.zeros(1, n_hidden)\n",
    "\n",
    "output, next_hidden = rnn(input, hidden)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the sake of efficiency we don’t want to be creating a new Tensor for every step, so we will use lineToTensor instead of letterToTensor and use slices. This could be further optimized by pre-computing batches of Tensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-2.8134, -2.8416, -2.8171, -2.8544, -2.8806, -2.8574, -2.8914, -2.9934,\n",
      "         -2.9063, -3.0185, -3.0062, -2.9240, -2.8852, -2.9296, -2.8848, -2.8845,\n",
      "         -2.8499, -2.8208]], grad_fn=<LogSoftmaxBackward>)\n"
     ]
    }
   ],
   "source": [
    "input = lineToTensor('Albert')\n",
    "hidden = torch.zeros(1, n_hidden)\n",
    "\n",
    "output, next_hidden = rnn(input[0], hidden)\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing for Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Czech', 0)\n"
     ]
    }
   ],
   "source": [
    "def categoryFromOutput(output):\n",
    "    top_n, top_i = output.topk(1)\n",
    "    category_i = top_i[0].item()\n",
    "    return all_categories[category_i], category_i\n",
    "\n",
    "print(categoryFromOutput(output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "category = Italian / line = Acqua\n",
      "category = Polish / line = Szwedko\n",
      "category = Polish / line = Slazak\n",
      "category = Irish / line = Roach\n",
      "category = Czech / line = Cerv\n",
      "category = German / line = Jager\n",
      "category = Korean / line = Gwang \n",
      "category = German / line = Voss\n",
      "category = English / line = Paterson\n",
      "category = Russian / line = Chuvaldin\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def randomChoice(l):\n",
    "    return l[random.randint(0, len(l) - 1)]\n",
    "\n",
    "def randomTrainingExample():\n",
    "    category = randomChoice(all_categories)\n",
    "    line = randomChoice(category_lines[category])\n",
    "    category_tensor = torch.tensor([all_categories.index(category)], dtype=torch.long)\n",
    "    line_tensor = lineToTensor(line)\n",
    "    return category, line, category_tensor, line_tensor\n",
    "\n",
    "for i in range(10):\n",
    "    category, line, category_tensor, line_tensor = randomTrainingExample()\n",
    "    print('category =', category, '/ line =', line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training the Network\n",
    "\n",
    "For the loss function nn.NLLLoss is appropriate, since the last layer of the RNN is nn.LogSoftmax.\n",
    "\n",
    "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 keep hidden state for next letter    \n",
    "-> Compare final output to target     \n",
    "-> Back-propagate    \n",
    "-> Return the output and loss\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.NLLLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 0.005 # If you set this too high, it might explode. If too low, it might not learn\n",
    "\n",
    "def train(category_tensor, line_tensor):\n",
    "    hidden = rnn.initHidden()\n",
    "\n",
    "    rnn.zero_grad()\n",
    "\n",
    "    for i in range(line_tensor.size()[0]):\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=-learning_rate)\n",
    "\n",
    "    return output, loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5000 5% (0m 7s) 2.4633 Coiro / Italian ✓\n",
      "10000 10% (0m 15s) 1.8807 Wang / Chinese ✗ (Korean)\n",
      "15000 15% (0m 23s) 1.9186 Demko / Polish ✗ (Czech)\n",
      "20000 20% (0m 30s) 2.2772 Mckay / Russian ✗ (Scottish)\n",
      "25000 25% (0m 38s) 1.1568 Ping / Vietnamese ✗ (Chinese)\n",
      "30000 30% (0m 46s) 0.1932 Hachaturov / Russian ✓\n",
      "35000 35% (0m 54s) 0.3231 Kihara / Japanese ✓\n",
      "40000 40% (1m 1s) 0.8559 Tolbert / French ✓\n",
      "45000 45% (1m 9s) 1.2188 Romao / Portuguese ✓\n",
      "50000 50% (1m 17s) 0.6475 Foerstner / German ✓\n",
      "55000 55% (1m 25s) 0.7170 Kubo / Japanese ✓\n",
      "60000 60% (1m 33s) 0.0315 Vamvakidis / Greek ✓\n",
      "65000 65% (1m 43s) 2.3608 Schwarzenberg / German ✗ (Dutch)\n",
      "70000 70% (1m 51s) 0.3965 To / Vietnamese ✓\n",
      "75000 75% (1m 58s) 0.0543 Grzeskiewicz / Polish ✓\n",
      "80000 80% (2m 6s) 1.9426 Dunnett / French ✗ (English)\n",
      "85000 85% (2m 14s) 2.9177 Belmonte / Dutch ✗ (Spanish)\n",
      "90000 90% (2m 21s) 1.1510 Pugliese / Italian ✓\n",
      "95000 95% (2m 29s) 0.4687 Ziemniak / Polish ✓\n",
      "100000 100% (2m 36s) 2.0758 Cerney / English ✗ (Czech)\n"
     ]
    }
   ],
   "source": [
    "n_iters = 100000\n",
    "print_every = 5000\n",
    "plot_every = 1000\n",
    "\n",
    "\n",
    "\n",
    "# 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)\n",
    "\n",
    "start = time.time()\n",
    "\n",
    "for iter in range(1, n_iters + 1):\n",
    "    category, line, category_tensor, line_tensor = randomTrainingExample()\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": "markdown",
   "metadata": {},
   "source": [
    "### Plotting the Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7faf21cf8e10>]"
      ]
     },
     "execution_count": 41,
     "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": [
    "plt.figure()\n",
    "plt.plot(all_losses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluating the Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Keep track of correct guesses in a confusion matrix\n",
    "confusion = torch.zeros(n_categories, n_categories)\n",
    "n_confusion = 10000\n",
    "\n",
    "# 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\n",
    "\n",
    "# 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()\n",
    "\n",
    "# Set up plot\n",
    "fig = plt.figure()\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",
   "metadata": {},
   "source": [
    "### Running on User Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "> Dovesky\n",
      "(-0.57) Russian\n",
      "(-1.42) Czech\n",
      "(-2.49) English\n",
      "\n",
      "> Jackson\n",
      "(-0.94) Scottish\n",
      "(-1.39) Russian\n",
      "(-1.60) English\n",
      "\n",
      "> Satoshi\n",
      "(-0.85) Japanese\n",
      "(-1.54) Arabic\n",
      "(-2.13) Polish\n"
     ]
    }
   ],
   "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]])\n",
    "\n",
    "predict('Dovesky')\n",
    "predict('Jackson')\n",
    "predict('Satoshi')"
   ]
  },
  {
   "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}