5_LSTM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 - LSTM (inbuilt PyTorch module): Name Origin Classification\n",
    "\n",
    "We will observe better result in LSTM in comparison to simple RNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import unicode_literals, print_function, division\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import glob  #helpful in finding pathnames following specific pattern\n",
    "import unicodedata\n",
    "import string\n",
    "import os\n",
    "import random\n",
    "import torch.nn.functional as F\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_letters = string.ascii_letters + \" .,;'\"\n",
    "n_letters = len(all_letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing data and making its tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findTxtFiles(path_pattern):\n",
    "    return glob.glob(path_pattern)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_pattern = \"./rnn_data/names/*.txt\"\n",
    "files = findTxtFiles(path_pattern)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['./rnn_data/names/Czech.txt',\n",
       " './rnn_data/names/Dutch.txt',\n",
       " './rnn_data/names/Korean.txt',\n",
       " './rnn_data/names/Russian.txt',\n",
       " './rnn_data/names/Scottish.txt',\n",
       " './rnn_data/names/Spanish.txt',\n",
       " './rnn_data/names/Greek.txt',\n",
       " './rnn_data/names/Vietnamese.txt',\n",
       " './rnn_data/names/Irish.txt',\n",
       " './rnn_data/names/German.txt',\n",
       " './rnn_data/names/Polish.txt',\n",
       " './rnn_data/names/French.txt',\n",
       " './rnn_data/names/Portuguese.txt',\n",
       " './rnn_data/names/Chinese.txt',\n",
       " './rnn_data/names/Italian.txt',\n",
       " './rnn_data/names/Arabic.txt',\n",
       " './rnn_data/names/English.txt',\n",
       " './rnn_data/names/Japanese.txt']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_list = []\n",
    "word_class_dict = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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",
    "def readTxt(file):\n",
    "    lines = open(file, encoding='utf-8').read().strip().split('\\n')\n",
    "    return [unicodeToAscii(line) for line in lines]\n",
    "\n",
    "for file in files:\n",
    "    class_name = os.path.splitext(os.path.basename(file))[0]\n",
    "    class_list.append(class_name)\n",
    "    lines = readTxt(file)\n",
    "    word_class_dict[class_name] = lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Abel', 'Abraham', 'Adam', 'Albert', 'Allard']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_class_dict['French'][:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_class = len(class_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "#preparing character-wise tensor\n",
    "print(all_letters.index('g'))\n",
    "\n",
    "\n",
    "def letter2index(letter):\n",
    "    return all_letters.index(letter)\n",
    "def letter2tensor(letter):\n",
    "    idx = letter2index(letter)\n",
    "    x = torch.zeros(1,n_letters)\n",
    "    x[0][idx]=1\n",
    "    return x\n",
    "def name2tensor(name):\n",
    "    n_name = len(name)\n",
    "    x = torch.zeros(n_name,1,n_letters)\n",
    "    for i,letter in enumerate(name):\n",
    "        x[i][0][letter2index(letter)]=1\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "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., 0., 0.,\n",
       "          0., 1., 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., 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., 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., 1., 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",
       "          0., 1., 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., 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., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0.]]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name2tensor('ashish')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Auxillary Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predictClass(output):\n",
    "    max_val,max_idx = output.topk(1)\n",
    "    class_idx = max_idx[0].item()\n",
    "    return class_list[class_idx],class_idx\n",
    "\n",
    "# give random choice index in a list\n",
    "def makeRandomChoice(l):\n",
    "    return random.randint(0,len(l)-1)\n",
    "\n",
    "\n",
    "\n",
    "def makeRandomExampleTensor():\n",
    "    choose_class = class_list[makeRandomChoice(class_list)]\n",
    "    choose_word = word_class_dict[choose_class][makeRandomChoice(word_class_dict[choose_class])]\n",
    "    y = torch.tensor([class_list.index(choose_class)],dtype=torch.long)\n",
    "    X = name2tensor(choose_word)\n",
    "    return choose_class,choose_word,X,y\n",
    "\n",
    "\n",
    "            \n",
    "def initCuda(force_cpu=True):\n",
    "    ## Do check for cuda device\n",
    "    if torch.cuda.is_available() and force_cpu==False:\n",
    "        device = torch.device(\"cuda:0\")\n",
    "        print(\"GPU Process\")\n",
    "    elif force_cpu:\n",
    "        device = torch.device(\"cpu\")\n",
    "        print(\"CPU Process\")\n",
    "    else:\n",
    "        device = torch.device(\"cpu\")\n",
    "        print(\"CPU Process\")\n",
    "    return device\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### RNN duing LSTM cell Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self,input_size,hidden_size,output_size):\n",
    "        super(LSTM,self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.input_size = input_size\n",
    "        \n",
    "        #Layers\n",
    "        self.input_hidden = nn.LSTM(self.input_size,self.hidden_size)\n",
    "        self.hidden_output = nn.Linear(self.hidden_size,output_size)\n",
    "        self.softmax = nn.LogSoftmax(dim=1)\n",
    "    #forward gives us recursion by prev_hidden arguement!\n",
    "    def forward(self,data, prev_hidden):\n",
    "        #lstm(input,(h_0,c_0))\n",
    "        lstm_out,hidden = self.input_hidden(data,prev_hidden)\n",
    "        #hidden = F.relu(hidden)\n",
    "        output = self.hidden_output(lstm_out[-1])\n",
    "        output = self.softmax(output)\n",
    "        return output,hidden\n",
    "    \n",
    "    #h_0 of shape  - (num_layers * num_directions, batch, hidden_size)\n",
    "    #c_0 of shape - (num_layers * num_directions, batch, hidden_size\n",
    "    def init_hidden(self):\n",
    "        #return tuple of (h_0,c_0)\n",
    "        return (torch.zeros(1, 1, self.hidden_size).to(device),\n",
    "                torch.zeros(1, 1, self.hidden_size).to(device))\n",
    "    \n",
    "\n",
    "    \n",
    "###Training Function\n",
    "\n",
    "def train(model,n_iters):\n",
    "    loss_tracker = []\n",
    "    for i in tqdm(range(n_iters)):\n",
    "        hidden = model.init_hidden()\n",
    "        _,_,X,y = makeRandomExampleTensor()\n",
    "        X=X.to(device)\n",
    "        y=y.to(device)\n",
    "        model.zero_grad()\n",
    "        \n",
    "        output,hidden = model(X,hidden)\n",
    "        #output.to(device)\n",
    "        #hidden\n",
    "            #print(output)\n",
    "            #print(y)\n",
    "        loss = criterion(output,y)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        if i%5000==0:\n",
    "            loss_tracker.append(loss)    \n",
    "    return loss_tracker\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU Process\n"
     ]
    }
   ],
   "source": [
    "device = initCuda(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RNN(\n",
      "  (input_hidden): LSTM(57, 128)\n",
      "  (hidden_output): Linear(in_features=128, out_features=18, bias=True)\n",
      "  (softmax): LogSoftmax()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "hidden_size = 128\n",
    "rnn = RNN(n_letters,hidden_size,n_class).to(device)\n",
    "print(rnn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(rnn.parameters()).is_cuda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "optimizer = optim.Adam(rnn.parameters(),lr=0.001)\n",
    "criterion = nn.NLLLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 250000/250000 [08:03<00:00, 517.09it/s]\n"
     ]
    }
   ],
   "source": [
    "loss_plot = train(rnn,250000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "plt.plot(loss_plot)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Copied as it is from 60 min blitz\n",
    "confusion = torch.zeros(n_class, n_class)\n",
    "n_confusion = 10000\n",
    "all_categories=class_list\n",
    "n_categories = n_class\n",
    "# Just return an output given a line\n",
    "def evaluate(line_tensor):\n",
    "    with torch.no_grad():\n",
    "        hidden = rnn.init_hidden()\n",
    "\n",
    "        output, hidden = rnn(line_tensor, 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, line_tensor,category_tensor = makeRandomExampleTensor()\n",
    "    #print(line_tensor)\n",
    "    output = evaluate(line_tensor.to(device))\n",
    "    guess, guess_i = predictClass(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(figsize=(15,15))\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": 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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}