classify_name_CharRNN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "classify_name_CharRNN.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Download and prepare dataset"
      ],
      "metadata": {
        "id": "-kfX0AlW60Zo"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "svIuoC4r4hSR"
      },
      "outputs": [],
      "source": [
        "!wget https://download.pytorch.org/tutorial/data.zip\n",
        "!unzip data.zip"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from __future__ import unicode_literals, print_function, division\n",
        "from io import open\n",
        "import glob\n",
        "import os\n",
        "\n",
        "def findFiles(path):\n",
        "  return glob.glob(path)\n",
        "\n",
        "print(findFiles('data/names/*.txt'))\n",
        "\n",
        "import unicodedata\n",
        "import string\n",
        "\n",
        "all_letters = string.ascii_letters + \" .,;'\"\n",
        "n_letters = len(all_letters)\n",
        "\n",
        "# Turn a Unicode string to plain ASCII, thanks to https://stackoverflow.com/a/518232/2809427\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'))\n",
        "\n",
        "# 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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RswFH0Ua5EKE",
        "outputId": "249d835b-3964-4f22-c9ee-90484b5cb459"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['data/names/Polish.txt', 'data/names/German.txt', 'data/names/Czech.txt', 'data/names/Scottish.txt', 'data/names/Japanese.txt', 'data/names/Italian.txt', 'data/names/Chinese.txt', 'data/names/Russian.txt', 'data/names/Portuguese.txt', 'data/names/Irish.txt', 'data/names/Dutch.txt', 'data/names/Vietnamese.txt', 'data/names/Arabic.txt', 'data/names/Korean.txt', 'data/names/English.txt', 'data/names/French.txt', 'data/names/Spanish.txt', 'data/names/Greek.txt']\n",
            "Slusarski\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(category_lines['Italian'][:5])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D43hIw6l6m5W",
        "outputId": "9c9e9daa-1a34-4444-95ad-5e719e525622"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Abandonato', 'Abatangelo', 'Abatantuono', 'Abate', 'Abategiovanni']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Turning name in tensor"
      ],
      "metadata": {
        "id": "wL1Rp2lP62pj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "def letterToIdx(letter):\n",
        "  return all_letters.find(letter)\n",
        "\n",
        "# We actually don't use this\n",
        "def letterToTensor(letter):\n",
        "  tensor = torch.zeros(1, n_letters)\n",
        "  tensor[0][letterToIdx(letter)] = 1\n",
        "  return tensor # one hot vector\n",
        "\n",
        "# Turn a line: Abandonato into Tensor of shape: [num_char_in_line, 1, n_letters]\n",
        "def lineToTensor(line):\n",
        "  tensor = torch.zeros(len(line), 1, n_letters)\n",
        "  for line_idx, letter in enumerate(line):\n",
        "    tensor[line_idx][0][letterToIdx(letter)] = 1\n",
        "  return tensor\n",
        "\n",
        "print(letterToTensor('J'))\n",
        "\n",
        "print(lineToTensor('Jones').size())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AX2Oc_YT6yBH",
        "outputId": "0b77f750-8fb9-4a5e-a14c-0429e7b3543a"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Creating the network"
      ],
      "metadata": {
        "id": "mbQdsC9C4sU9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "class RNN(nn.Module):\n",
        "  def __init__(self, input_size, hidden_size, output_size):\n",
        "    super(RNN, self).__init__()\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",
        "\n",
        "  def init_hidden(self):\n",
        "    return torch.zeros(1, self.hidden_size)\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 = F.log_softmax(output, dim=1)\n",
        "    return output, hidden\n",
        "\n",
        "n_hidden = 128\n",
        "rnn = RNN(n_letters, n_hidden, n_categories)"
      ],
      "metadata": {
        "id": "gur92CyY40kN"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "input = letterToTensor('A')\n",
        "hidden = rnn.init_hidden()\n",
        "\n",
        "with torch.no_grad():\n",
        "  output, next_hidden = rnn(input, hidden)\n",
        "print(output)\n",
        "print(next_hidden)"
      ],
      "metadata": {
        "id": "2Yc0y55b5tBi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ffaea780-55ec-40ee-afca-7a53b1438a25"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[-2.8402, -2.9274, -2.8994, -2.8556, -3.0209, -2.7966, -2.9589, -2.9114,\n",
            "         -2.9345, -2.8402, -2.9200, -2.8372, -2.9322, -2.8463, -2.8715, -2.8976,\n",
            "         -2.9913, -2.7806]])\n",
            "tensor([[ 5.8985e-02, -1.1291e-02, -4.1824e-02, -6.4282e-02,  2.4660e-02,\n",
            "         -1.1473e-01,  3.5859e-02, -3.2638e-02,  6.3994e-02,  3.3924e-02,\n",
            "          2.5085e-02,  4.6567e-03,  4.0549e-02,  1.1328e-01,  5.0712e-02,\n",
            "          5.6844e-02,  2.9481e-02,  3.8077e-02, -5.8498e-02,  3.7190e-02,\n",
            "          5.0150e-05, -1.0731e-01, -5.6037e-02, -2.4882e-02,  8.1689e-02,\n",
            "          1.0756e-01, -8.0525e-03, -1.5084e-02,  1.6585e-02,  4.5512e-02,\n",
            "          5.2777e-02,  7.9954e-02,  4.6754e-02,  6.0379e-02,  2.3662e-02,\n",
            "          3.2974e-02, -7.0316e-02,  6.1280e-02,  6.4800e-02,  3.1320e-02,\n",
            "          3.9467e-02,  3.2924e-02, -2.5343e-02, -1.1001e-02, -4.2726e-02,\n",
            "          1.2725e-01,  7.4832e-02,  1.0770e-01, -3.3840e-02, -3.4960e-03,\n",
            "          3.3608e-02, -8.4123e-02, -3.5485e-02,  2.8162e-02,  2.0806e-02,\n",
            "          6.3795e-02, -1.2934e-01, -1.0349e-01,  2.7736e-02, -1.3627e-02,\n",
            "          5.1575e-03, -3.8770e-02,  5.7758e-02,  5.1951e-02,  5.7170e-02,\n",
            "         -5.2378e-05,  3.4720e-02, -2.3289e-02,  9.6235e-03, -1.7316e-02,\n",
            "         -7.9958e-02,  3.4907e-02, -5.4733e-02,  6.0293e-03, -2.1884e-02,\n",
            "          4.4560e-02,  3.7967e-02, -6.6302e-02, -3.7811e-03,  2.9611e-02,\n",
            "          8.8934e-02, -1.5726e-02,  2.8635e-02,  3.2864e-02,  3.9372e-02,\n",
            "          1.5779e-02, -1.1650e-02,  1.5742e-02, -1.3718e-03, -4.1052e-03,\n",
            "         -1.0388e-01, -4.3296e-02, -1.0799e-01, -9.6816e-02,  1.1644e-01,\n",
            "         -7.4625e-02,  3.4582e-02,  2.4499e-02, -1.3964e-02,  7.9455e-02,\n",
            "         -5.7144e-03, -2.6408e-02, -1.0526e-02,  5.0414e-02, -2.3539e-02,\n",
            "         -3.4231e-02, -1.6147e-02,  1.1908e-01, -4.4771e-02, -5.9738e-03,\n",
            "          5.3618e-02,  1.2789e-01, -1.2565e-01,  3.2690e-02, -1.9801e-02,\n",
            "         -3.3351e-02,  3.5155e-02, -8.2818e-03,  2.7423e-03, -9.2462e-03,\n",
            "         -4.5806e-02, -6.4717e-02,  2.0357e-02,  1.9727e-02,  1.3783e-01,\n",
            "         -3.8322e-02, -9.9005e-02,  8.4570e-02]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "input = lineToTensor('Albert')\n",
        "hidden = rnn.init_hidden()\n",
        "\n",
        "with torch.no_grad():\n",
        "  output, next_hidden= rnn(input[0], hidden)\n",
        "print(output)\n",
        "print(next_hidden)"
      ],
      "metadata": {
        "id": "XswPT6yV5_a5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "be9b4cb0-f140-47f3-dcd3-209fc78bceaa"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[-2.8402, -2.9274, -2.8994, -2.8556, -3.0209, -2.7966, -2.9589, -2.9114,\n",
            "         -2.9345, -2.8402, -2.9200, -2.8372, -2.9322, -2.8463, -2.8715, -2.8976,\n",
            "         -2.9913, -2.7806]])\n",
            "tensor([[ 5.8985e-02, -1.1291e-02, -4.1824e-02, -6.4282e-02,  2.4660e-02,\n",
            "         -1.1473e-01,  3.5859e-02, -3.2638e-02,  6.3994e-02,  3.3924e-02,\n",
            "          2.5085e-02,  4.6567e-03,  4.0549e-02,  1.1328e-01,  5.0712e-02,\n",
            "          5.6844e-02,  2.9481e-02,  3.8077e-02, -5.8498e-02,  3.7190e-02,\n",
            "          5.0150e-05, -1.0731e-01, -5.6037e-02, -2.4882e-02,  8.1689e-02,\n",
            "          1.0756e-01, -8.0525e-03, -1.5084e-02,  1.6585e-02,  4.5512e-02,\n",
            "          5.2777e-02,  7.9954e-02,  4.6754e-02,  6.0379e-02,  2.3662e-02,\n",
            "          3.2974e-02, -7.0316e-02,  6.1280e-02,  6.4800e-02,  3.1320e-02,\n",
            "          3.9467e-02,  3.2924e-02, -2.5343e-02, -1.1001e-02, -4.2726e-02,\n",
            "          1.2725e-01,  7.4832e-02,  1.0770e-01, -3.3840e-02, -3.4960e-03,\n",
            "          3.3608e-02, -8.4123e-02, -3.5485e-02,  2.8162e-02,  2.0806e-02,\n",
            "          6.3795e-02, -1.2934e-01, -1.0349e-01,  2.7736e-02, -1.3627e-02,\n",
            "          5.1575e-03, -3.8770e-02,  5.7758e-02,  5.1951e-02,  5.7170e-02,\n",
            "         -5.2378e-05,  3.4720e-02, -2.3289e-02,  9.6235e-03, -1.7316e-02,\n",
            "         -7.9958e-02,  3.4907e-02, -5.4733e-02,  6.0293e-03, -2.1884e-02,\n",
            "          4.4560e-02,  3.7967e-02, -6.6302e-02, -3.7811e-03,  2.9611e-02,\n",
            "          8.8934e-02, -1.5726e-02,  2.8635e-02,  3.2864e-02,  3.9372e-02,\n",
            "          1.5779e-02, -1.1650e-02,  1.5742e-02, -1.3718e-03, -4.1052e-03,\n",
            "         -1.0388e-01, -4.3296e-02, -1.0799e-01, -9.6816e-02,  1.1644e-01,\n",
            "         -7.4625e-02,  3.4582e-02,  2.4499e-02, -1.3964e-02,  7.9455e-02,\n",
            "         -5.7144e-03, -2.6408e-02, -1.0526e-02,  5.0414e-02, -2.3539e-02,\n",
            "         -3.4231e-02, -1.6147e-02,  1.1908e-01, -4.4771e-02, -5.9738e-03,\n",
            "          5.3618e-02,  1.2789e-01, -1.2565e-01,  3.2690e-02, -1.9801e-02,\n",
            "         -3.3351e-02,  3.5155e-02, -8.2818e-03,  2.7423e-03, -9.2462e-03,\n",
            "         -4.5806e-02, -6.4717e-02,  2.0357e-02,  1.9727e-02,  1.3783e-01,\n",
            "         -3.8322e-02, -9.9005e-02,  8.4570e-02]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training"
      ],
      "metadata": {
        "id": "I4fTTdnV6RNB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def categoryFromOutput(output):\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))"
      ],
      "metadata": {
        "id": "4tcfZn2D6R7C",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "542b55b7-f48a-4edf-9c69-d70daa4586b2"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Greek', 17)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\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)"
      ],
      "metadata": {
        "id": "tAtYuhffVaXn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "88895d51-9888-4a68-81cf-3c740fc0133a"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "category= Portuguese / line = Araujo\n",
            "category= Italian / line = Potenza\n",
            "category= English / line = Danks\n",
            "category= French / line = Robert\n",
            "category= Arabic / line = Assaf\n",
            "category= Vietnamese / line = Phi\n",
            "category= Chinese / line = Dong\n",
            "category= Scottish / line = Gray\n",
            "category= English / line = Goodchild\n",
            "category= Scottish / line = Douglas\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training"
      ],
      "metadata": {
        "id": "TU7RpA6zaVUR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "criterion = nn.NLLLoss()"
      ],
      "metadata": {
        "id": "3ihHrTLlacl8"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "learning_rate = 0.005\n",
        "\n",
        "def train(category_tensor, line_tensor):\n",
        "  hidden = rnn.init_hidden()\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",
        "  for p in rnn.parameters():\n",
        "    p.data.add_(p.grad.data, alpha=-learning_rate)\n",
        "  \n",
        "  return output, loss.item()"
      ],
      "metadata": {
        "id": "3j-Xp4DMaknZ"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import time\n",
        "import math\n",
        "\n",
        "n_iters = 100000\n",
        "print_every = 5000\n",
        "plot_every = 1000\n",
        "\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",
        "  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,\n",
        "                                            timeSince(start), loss, line, guess,\n",
        "                                            correct))\n",
        "  if iter % plot_every == 0:\n",
        "    all_losses.append(current_loss / plot_every)\n",
        "    current_loss = 0"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mZZXRj7YbGEe",
        "outputId": "cd589486-a594-44a4-98b3-6064cb9476cd"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5000 5% (0m 4s) 2.7383 O'Neill / Dutch ✗ (Irish)\n",
            "10000 10% (0m 9s) 2.4352 Araujo / Portuguese ✗ (Spanish)\n",
            "15000 15% (0m 14s) 2.3601 Sze  / Korean ✗ (Chinese)\n",
            "20000 20% (0m 19s) 2.2354 Sakellariou / Scottish ✗ (Greek)\n",
            "25000 25% (0m 24s) 3.4521 Latham / Arabic ✗ (English)\n",
            "30000 30% (0m 29s) 3.0382 Romeijn / Irish ✗ (Dutch)\n",
            "35000 35% (0m 33s) 4.1045 Bondesan / Scottish ✗ (Italian)\n",
            "40000 40% (0m 38s) 1.7171 Sansone / French ✗ (Italian)\n",
            "45000 45% (0m 43s) 1.2416 Marie / French ✓\n",
            "50000 50% (0m 48s) 2.0478 Langbroek / French ✗ (Dutch)\n",
            "55000 55% (0m 52s) 1.6134 Mckenzie / Russian ✗ (Scottish)\n",
            "60000 60% (0m 57s) 0.3865 Dam / Vietnamese ✓\n",
            "65000 65% (1m 2s) 0.7308 Gonzalez / Spanish ✓\n",
            "70000 70% (1m 7s) 2.9189 Arthur / Arabic ✗ (French)\n",
            "75000 75% (1m 11s) 1.2856 Nigro / Portuguese ✗ (Italian)\n",
            "80000 80% (1m 16s) 2.5812 Garb / Arabic ✗ (German)\n",
            "85000 85% (1m 21s) 3.3537 Sierzant / Dutch ✗ (Polish)\n",
            "90000 90% (1m 26s) 1.5503 Montero / Portuguese ✗ (Spanish)\n",
            "95000 95% (1m 30s) 1.1692 Ton / Chinese ✗ (Vietnamese)\n",
            "100000 100% (1m 35s) 0.1112 Roggeveen / Dutch ✓\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Plot the results"
      ],
      "metadata": {
        "id": "_z2p9GEkcRbb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.ticker as ticker\n",
        "\n",
        "plt.figure()\n",
        "plt.plot(all_losses)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "7SJeJN1UcTZa",
        "outputId": "bbb00411-7149-4bc4-fb24-25916dbf6005"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fcc61233c10>]"
            ]
          },
          "metadata": {},
          "execution_count": 24
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Evaluating the results"
      ],
      "metadata": {
        "id": "2pCFIl_EccHF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "confusion = torch.zeros(n_categories, n_categories)\n",
        "n_confusion = 10000\n",
        "\n",
        "def evaluate(line_tensor):\n",
        "  hidden = rnn.init_hidden()\n",
        "\n",
        "  for i in range(line_tensor.size()[0]):\n",
        "    output, hidden = rnn(line_tensor[i], hidden)\n",
        "  \n",
        "  return output\n",
        "\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",
        "for i in range(n_categories):\n",
        "  confusion[i] = confusion[i] / confusion[i].sum()\n",
        "\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111)\n",
        "cax = ax.matshow(confusion.numpy())\n",
        "fig.colorbar(cax)\n",
        "\n",
        "ax.set_xticklabels([''] + all_categories, rotation = 90)\n",
        "ax.set_yticklabels([''] + all_categories)\n",
        "\n",
        "ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n",
        "ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 320
        },
        "id": "X5kdCJFqcdxo",
        "outputId": "a3c8400e-d537-4965-e0f4-1b8852809e99"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Running on User Input"
      ],
      "metadata": {
        "id": "XM7Pj7GIdxaN"
      }
    },
    {
      "cell_type": "code",
      "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",
        "    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')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4_gntJHsd12S",
        "outputId": "3a251dce-8d05-479c-9aa1-905574b150c9"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            " Dovesky\n",
            "(-0.42) Russian\n",
            "(-1.36) Czech\n",
            "(-3.52) English\n",
            "\n",
            " Jackson\n",
            "(-0.13) Scottish\n",
            "(-2.87) English\n",
            "(-3.73) Russian\n",
            "\n",
            " Satoshi\n",
            "(-0.44) Japanese\n",
            "(-1.59) Arabic\n",
            "(-2.78) Italian\n"
          ]
        }
      ]
    }
  ]
}