language_classification-LSTM-GRU.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import os\n",
    "from io import open\n",
    "import glob\n",
    "import unicodedata\n",
    "import string\n",
    "import numpy as np\n",
    "import time\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = './data/text_samples/*.txt'\n",
    "\n",
    "class LanguageDetect():\n",
    "    def __init__(self, files_path='./data/text_samples', limit_size=None):\n",
    "        # scan language files\n",
    "        lang_files = glob.glob(data_path)\n",
    "        \n",
    "        self.alphabet = string.ascii_lowercase\n",
    "        self.wordlist = []\n",
    "        self.labels = []\n",
    "        self.classes = []\n",
    "        self.padding = 0\n",
    "\n",
    "        idx = 0\n",
    "        for file in lang_files:\n",
    "            language = os.path.splitext(os.path.basename(file))[0]\n",
    "            self.classes.append(language)\n",
    "            words = self._transform_vocab(file, limit_size)\n",
    "            self.wordlist += words\n",
    "            self.labels += [idx for i in range(len(words))]\n",
    "            idx += 1\n",
    "        \n",
    "        self.padding = len(max(self.wordlist, key=len)) # size of the largest string\n",
    "           \n",
    "    def _unicodeToAscii(self, s):\n",
    "        all_letters = string.ascii_letters\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",
    "    def _transform_vocab(self, vocab, limit_size):\n",
    "        wordset = (open(vocab).read()).lower() # open file and convert letters to lowercase\n",
    "        wordset = ''.join(i for i in wordset if (i.isalpha() | i.isspace())).split() # remove all non alpha and single characters thus split into a list\n",
    "        wordset = [word for word in wordset if len(word) > 1] # remove single characters and spaces\n",
    "        wordset = [self._unicodeToAscii(word) for word in wordset] # convert to ASCII\n",
    "        wordset = list(set(wordset)) # list of unique elements\n",
    "        if limit_size is not None:\n",
    "            wordset = wordset[:limit_size]\n",
    "        return wordset\n",
    "\n",
    "\n",
    "    def _word2tensor(self, word, padding=True):\n",
    "        if padding:\n",
    "            num_charac = self.padding # pad to the fill the size\n",
    "        else:\n",
    "            num_charac = len(word)\n",
    "        len_word = len(word)\n",
    "        wtensor = torch.zeros(num_charac, 1, 1, dtype=torch.long)\n",
    "        for iletter in range(len_word):\n",
    "            wtensor[iletter][0][0] = self.alphabet.find(word[iletter])\n",
    "        return wtensor\n",
    "\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.labels)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        word = self.wordlist[idx]\n",
    "        label = self.labels[idx]\n",
    "        \n",
    "        # convert a word to a tensor (len word x 1 x alphabet)\n",
    "        word = self._word2tensor(word, padding=False)\n",
    "       \n",
    "        return word, label\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset size: 800\n",
      "classes: ['german', 'spanish', 'french', 'english']\n"
     ]
    }
   ],
   "source": [
    "dataset = LanguageDetect(data_path, limit_size=200)\n",
    "alphabet = dataset.alphabet\n",
    "\n",
    "classes = dataset.classes\n",
    "print('dataset size:', len(dataset))\n",
    "print('classes:', classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vocab_size: 26\n"
     ]
    }
   ],
   "source": [
    "vocab_size = len(alphabet)\n",
    "print('vocab_size:', vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first input: torch.Size([8, 1, 1])\n",
      "label: 0\n",
      "\n",
      "Random sample:\n",
      "language= english\n",
      "word= measured\n"
     ]
    }
   ],
   "source": [
    "def tensor2word(tensor):\n",
    "    word = ''\n",
    "    for i in range(tensor.size(0)):\n",
    "        word += alphabet[tensor[i][0][0]]\n",
    "    return word\n",
    "\n",
    "    \n",
    "# dataset dim = |idx (input,label) \n",
    "# first input\n",
    "print('first input:', dataset[0][0].size())\n",
    "# first label\n",
    "print('label:', dataset[0][1])\n",
    "print()\n",
    "\n",
    "# sample example\n",
    "sample_idx = np.random.randint(1, len(dataset))\n",
    "\n",
    "print('Random sample:')\n",
    "print('language=', classes[dataset[sample_idx][1]])\n",
    "print('word=', tensor2word(dataset[sample_idx][0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split dataset\n",
    "train_size = len(dataset)\n",
    "\n",
    "# creating dataloaders\n",
    "batch_size = 1\n",
    "\n",
    "# create training data loader\n",
    "train_loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hidden NN size\n",
    "hidden_size = 128\n",
    "embedded_dim = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using gpu: True\n"
     ]
    }
   ],
   "source": [
    "use_cuda = torch.cuda.is_available()\n",
    "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
    "print(\"Using gpu:\", use_cuda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.NLLLoss()\n",
    "learning_rate = 0.0001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, criterion, learning_rate=0.0001, epochs=1000, plots_per_epoch=100):\n",
    "    \n",
    "    cost = []\n",
    "    start_time = time.time()\n",
    "    \n",
    "    for epoch in range(1, epochs+1):\n",
    "        running_loss = 0.0\n",
    "        running_corrects = 0\n",
    "        model.train()\n",
    "        \n",
    "        for inputs, labels in train_loader:\n",
    "            inputs = inputs[0].to(device)\n",
    "            labels = labels.to(device)\n",
    "            \n",
    "            hidden = model.init_hidden()\n",
    "            model.zero_grad()\n",
    "\n",
    "            for i in range(inputs.size(0)): # go through each letter\n",
    "                hidden, output = model(inputs[i], hidden)\n",
    "                \n",
    "            loss = criterion(output, labels)\n",
    "            loss.backward()\n",
    "            \n",
    "            # Add parameters' gradients to their values, multiplied by learning rate\n",
    "            for par in model.parameters():\n",
    "                par.data.add_(-learning_rate, par.grad.data)\n",
    "\n",
    "            _, guess = output.topk(1) # return the 1 largest element from output tensor\n",
    "            guess = guess[0].item()\n",
    "            if guess == int(labels):\n",
    "                running_corrects += 1\n",
    "            running_loss += loss.item()\n",
    "            \n",
    "        cost.append(running_loss)\n",
    "        epoch_acc = running_corrects / train_size\n",
    "        \n",
    "        if epoch % plots_per_epoch == 0:\n",
    "            print('Epoch [{}] -> Loss: {:.4f}  Acc: {:.4f}'.format(\n",
    "                epoch, running_loss/train_size, epoch_acc))\n",
    "\n",
    "    \n",
    "    time_elapsed = time.time() - start_time\n",
    "    print()\n",
    "    print('Training completed in {:.0f}m {:.0f}s'.format(\n",
    "        time_elapsed // 60, time_elapsed % 60))\n",
    "    \n",
    "    torch.save(model.state_dict(), PATH_state_dict)\n",
    "    \n",
    "    return model, cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_confusion = int(0.5 * train_size) # half of the train dataset to be evaluated\n",
    "\n",
    "def confusion_matrix(model):\n",
    "    confusion = torch.zeros(len(classes), len(classes))\n",
    "    model.eval()\n",
    "    for i in range(n_confusion):\n",
    "        for inputs, label in train_loader:\n",
    "            inputs = inputs.to(device)\n",
    "            label = label.to(device)\n",
    "            hidden = model.init_hidden()\n",
    "\n",
    "            word = inputs[0]\n",
    "            for i in range(word.size()[0]): # go through each letter\n",
    "                if torch.sum(word[i]) > 0: # avoid paddding\n",
    "                    hidden, output = model(word[i], hidden)\n",
    "                else: break\n",
    "\n",
    "            _, guess = output.topk(1) # return the 1 largest element\n",
    "            guess = guess[0].item()\n",
    "            \n",
    "            confusion[int(label)][guess] += 1\n",
    "\n",
    "    # Normalize by dividing every row by its sum\n",
    "    for i in range(len(classes)):\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([''] + classes, rotation=90)\n",
    "    ax.set_yticklabels([''] + classes)\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": [
    "## The model will be based on the following chart.\n",
    "There will be one implementation using a LSTM and another using a GRU.\n",
    "![LSTM model](./images/lan_class_lstm.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LSTM model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, hidden_size, output_size):\n",
    "        super(LSTM, self).__init__()\n",
    "        \n",
    "        self.hidden_size = hidden_size\n",
    "        \n",
    "        self.embeddings = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim) \n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_size)\n",
    "        self.out = nn.Linear(hidden_size, output_size)\n",
    "        \n",
    "    def forward(self, input, last_hidden):\n",
    "        embedded = self.embeddings(input.view(-1)).view(1, 1, -1)\n",
    "        output, hidden = self.lstm(embedded, last_hidden)\n",
    "        output = F.log_softmax(self.out(output[0]), dim=1)\n",
    "        return hidden, output\n",
    "        \n",
    "    def init_hidden(self):\n",
    "        return (torch.zeros(1, 1, self.hidden_size, device=device), \n",
    "                torch.zeros(1, 1, self.hidden_size, device=device)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "lstm = LSTM(vocab_size, embedded_dim, hidden_size, len(classes)).to(device)\n",
    "PATH_state_dict = './lang_class_lstm.pth' # file to be stored the best weights of the trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [100] -> Loss: 1.0542  Acc: 0.5437\n",
      "Epoch [200] -> Loss: 0.9575  Acc: 0.5988\n",
      "Epoch [300] -> Loss: 0.8888  Acc: 0.6375\n",
      "Epoch [400] -> Loss: 0.8238  Acc: 0.6725\n",
      "Epoch [500] -> Loss: 0.7549  Acc: 0.7188\n",
      "Epoch [600] -> Loss: 0.6907  Acc: 0.7512\n",
      "Epoch [700] -> Loss: 0.6257  Acc: 0.7662\n",
      "Epoch [800] -> Loss: 0.5566  Acc: 0.8025\n",
      "Epoch [900] -> Loss: 0.4856  Acc: 0.8350\n",
      "Epoch [1000] -> Loss: 0.4159  Acc: 0.8700\n",
      "Epoch [1100] -> Loss: 0.3489  Acc: 0.8888\n",
      "Epoch [1200] -> Loss: 0.2866  Acc: 0.9163\n",
      "Epoch [1300] -> Loss: 0.2320  Acc: 0.9350\n",
      "Epoch [1400] -> Loss: 0.1840  Acc: 0.9563\n",
      "Epoch [1500] -> Loss: 0.1456  Acc: 0.9725\n",
      "Epoch [1600] -> Loss: 0.1178  Acc: 0.9762\n",
      "Epoch [1700] -> Loss: 0.0974  Acc: 0.9788\n",
      "Epoch [1800] -> Loss: 0.0824  Acc: 0.9775\n",
      "Epoch [1900] -> Loss: 0.0709  Acc: 0.9775\n",
      "Epoch [2000] -> Loss: 0.0621  Acc: 0.9800\n",
      "\n",
      "Training completed in 121m 15s\n"
     ]
    }
   ],
   "source": [
    "_, cost = train(lstm, criterion, learning_rate, epochs=2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f334bff4190>]"
      ]
     },
     "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": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(cost)"
   ]
  },
  {
   "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": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "confusion_matrix(lstm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GRU model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GRU(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, hidden_size, output_size):\n",
    "        super(GRU, self).__init__()\n",
    "        \n",
    "        self.hidden_size = hidden_size\n",
    "        \n",
    "        self.embeddings = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim) \n",
    "        self.gru = nn.GRU(embedding_dim, hidden_size)\n",
    "        self.out = nn.Linear(hidden_size, output_size)\n",
    "        \n",
    "    def forward(self, input, last_hidden):\n",
    "        embedded = self.embeddings(input.view(-1)).view(1, 1, -1)\n",
    "        output, hidden = self.gru(embedded, last_hidden)\n",
    "        output = F.log_softmax(self.out(output[0]), dim=1)\n",
    "        return hidden, output\n",
    "        \n",
    "    def init_hidden(self):\n",
    "        return torch.zeros(1, 1, self.hidden_size, device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "gru = GRU(vocab_size, embedded_dim, hidden_size, len(classes)).to(device)\n",
    "PATH_state_dict = './lang_class_gru.pth' # file to be stored the best weights of the trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [100] -> Loss: 0.9472  Acc: 0.6062\n",
      "Epoch [200] -> Loss: 0.8441  Acc: 0.6700\n",
      "Epoch [300] -> Loss: 0.7671  Acc: 0.7037\n",
      "Epoch [400] -> Loss: 0.6940  Acc: 0.7388\n",
      "Epoch [500] -> Loss: 0.6182  Acc: 0.7738\n",
      "Epoch [600] -> Loss: 0.5399  Acc: 0.8063\n",
      "Epoch [700] -> Loss: 0.4622  Acc: 0.8387\n",
      "Epoch [800] -> Loss: 0.3872  Acc: 0.8700\n",
      "Epoch [900] -> Loss: 0.3168  Acc: 0.8925\n",
      "Epoch [1000] -> Loss: 0.2532  Acc: 0.9237\n",
      "Epoch [1100] -> Loss: 0.1997  Acc: 0.9475\n",
      "Epoch [1200] -> Loss: 0.1569  Acc: 0.9637\n",
      "Epoch [1300] -> Loss: 0.1239  Acc: 0.9700\n",
      "Epoch [1400] -> Loss: 0.0993  Acc: 0.9788\n",
      "Epoch [1500] -> Loss: 0.0813  Acc: 0.9775\n",
      "Epoch [1600] -> Loss: 0.0677  Acc: 0.9838\n",
      "Epoch [1700] -> Loss: 0.0578  Acc: 0.9850\n",
      "Epoch [1800] -> Loss: 0.0506  Acc: 0.9800\n",
      "Epoch [1900] -> Loss: 0.0451  Acc: 0.9862\n",
      "Epoch [2000] -> Loss: 0.0410  Acc: 0.9812\n",
      "\n",
      "Training completed in 123m 16s\n"
     ]
    }
   ],
   "source": [
    "_, cost = train(gru, criterion, learning_rate, epochs=2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f334bf22f90>]"
      ]
     },
     "execution_count": 20,
     "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(cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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": [
    "confusion_matrix(gru)"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}