6_Classifying names with RNN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classifying names with RNN\n",
    "### Download the data from [here](https://download.pytorch.org/tutorial/data.zip) and extract it to the current directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from __future__ import unicode_literals, print_function, division\n",
    "from io import open\n",
    "import glob\n",
    "import os\n",
    "import unicodedata\n",
    "import string\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import random\n",
    "import time\n",
    "import math\n",
    "from tqdm import tqdm_notebook as tq\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['data/names\\\\Arabic.txt', 'data/names\\\\Chinese.txt', 'data/names\\\\Czech.txt', 'data/names\\\\Dutch.txt', 'data/names\\\\English.txt', 'data/names\\\\French.txt', 'data/names\\\\German.txt', 'data/names\\\\Greek.txt', 'data/names\\\\Irish.txt', 'data/names\\\\Italian.txt', 'data/names\\\\Japanese.txt', 'data/names\\\\Korean.txt', 'data/names\\\\Polish.txt', 'data/names\\\\Portuguese.txt', 'data/names\\\\Russian.txt', 'data/names\\\\Scottish.txt', 'data/names\\\\Spanish.txt', 'data/names\\\\Vietnamese.txt']\n"
     ]
    }
   ],
   "source": [
    "def findFiles(path):\n",
    "    return glob.glob(path)\n",
    "\n",
    "print(findFiles('data/names/*.txt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_letters = string.ascii_letters + \" .,;'\"\n",
    "n_letters = len(all_letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slusarski\n"
     ]
    }
   ],
   "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",
    "print(unicodeToAscii('Ślusàrski'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Abandonato', 'Abatangelo', 'Abatantuono', 'Abate', 'Abategiovanni']\n"
     ]
    }
   ],
   "source": [
    "# Build the category_lines dictionary, a list of names per language\n",
    "category_lines = {}\n",
    "all_categories = []\n",
    "\n",
    "# Read a file and split into lines\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])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>,\n",
    "# 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": "code",
   "execution_count": 7,
   "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.LogSoftmax(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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_hidden = 128\n",
    "rnn = RNN(n_letters, n_hidden, n_categories)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "input = letterToTensor('A')\n",
    "hidden =torch.zeros(1, n_hidden)\n",
    "\n",
    "output, next_hidden = rnn(input, hidden)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-2.8983, -2.8679, -2.9328, -2.9722, -2.9292, -2.9289, -2.8842, -2.8772,\n",
      "         -2.8967, -2.8880, -2.9275, -2.8418, -2.8708, -2.8986, -2.8024, -2.9640,\n",
      "         -2.8538, -2.8110]], 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": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Russian', 14)\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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "category = Dutch / line = Kappel\n",
      "category = Chinese / line = Loh\n",
      "category = French / line = Simon\n",
      "category = Irish / line = O'Reilly\n",
      "category = Irish / line = O'Callaghann\n",
      "category = Dutch / line = Penders\n",
      "category = Polish / line = Sowka\n",
      "category = Czech / line = Bastl\n",
      "category = Italian / line = Leggieri\n",
      "category = Russian / line = Baderskov\n"
     ]
    }
   ],
   "source": [
    "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.NLLLoss()\n",
    "learning_rate = 0.005\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_(-learning_rate, p.grad.data)\n",
    "\n",
    "    return output, loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8a9d3f8b6c6c462db5e25016bb4483c0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=100000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5000 5% (0m 9s) 2.4691 Takenouchi / Russian ✗ (Japanese)\n",
      "10000 10% (0m 18s) 2.0973 Shamoon / Irish ✗ (Arabic)\n",
      "15000 15% (0m 28s) 1.3656 Fernandes / Portuguese ✓\n",
      "20000 20% (0m 37s) 2.7913 Koenig / Russian ✗ (German)\n",
      "25000 25% (0m 46s) 0.0956 Nagasawa / Japanese ✓\n",
      "30000 30% (0m 55s) 1.6980 Jirovy / Czech ✓\n",
      "35000 35% (1m 4s) 3.3409 Bellamy / Irish ✗ (French)\n",
      "40000 40% (1m 13s) 1.9735 Sokal / Czech ✗ (Polish)\n",
      "45000 45% (1m 22s) 2.3596 Hunter / German ✗ (Scottish)\n",
      "50000 50% (1m 31s) 0.8998 Ri / Korean ✓\n",
      "55000 55% (1m 41s) 0.3723 Madeira / Portuguese ✓\n",
      "60000 60% (1m 50s) 1.3197 Cha / Vietnamese ✗ (Korean)\n",
      "65000 65% (1m 59s) 0.4571 Madeira / Portuguese ✓\n",
      "70000 70% (2m 8s) 0.7876 Schmitz / German ✓\n",
      "75000 75% (2m 18s) 2.1626 Hetherington / Russian ✗ (English)\n",
      "80000 80% (2m 28s) 1.8659 Muir / German ✗ (Scottish)\n",
      "85000 85% (2m 37s) 0.1254 Ukhovsky / Russian ✓\n",
      "90000 90% (2m 47s) 2.5954 Pitterman / German ✗ (Czech)\n",
      "95000 95% (2m 57s) 0.1844 O'Doherty / Irish ✓\n",
      "100000 100% (3m 7s) 0.4494 Kanaan / Arabic ✓\n",
      "\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 tq(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": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x16e6bea8c88>]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "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": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "> Dovesky\n",
      "(-0.61) Russian\n",
      "(-1.18) Czech\n",
      "(-2.75) English\n",
      "\n",
      "> Jackson\n",
      "(-0.20) Scottish\n",
      "(-2.54) English\n",
      "(-2.80) Russian\n",
      "\n",
      "> Satoshi\n",
      "(-0.65) Arabic\n",
      "(-1.53) Japanese\n",
      "(-2.92) Portuguese\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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}