task_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6bfa59d8-15c3-4553-997e-fadff05a23b4",
   "metadata": {},
   "source": [
    "# Task 2: Multi-class Document Classification\n",
    "\n",
    "**Student Names:** Varun Jain (21963986) and Cunjun Yin (22249435) <br>\n",
    "**Due Date** 24th October 2021"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b794d01-5f17-4b76-903e-7e2763a1d9b5",
   "metadata": {},
   "source": [
    "## Library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1ff3404a-153a-4889-a6cd-dd2f90fb253a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import re\n",
    "import string\n",
    "import gensim\n",
    "import time\n",
    "import json\n",
    "\n",
    "\n",
    "import nltk\n",
    "from nltk.stem.wordnet import WordNetLemmatizer\n",
    "from nltk.stem import PorterStemmer\n",
    "from nltk import word_tokenize\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from gensim.corpora import Dictionary\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "import seaborn as sns\n",
    "\n",
    "import multiprocessing as mp\n",
    "from spellchecker import SpellChecker\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import math\n",
    "from argparse import Namespace\n",
    "\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from collections import Counter\n",
    "from tqdm import tqdm_notebook\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import ConfusionMatrixDisplay\n",
    "import codecs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5ffe5454-3b57-4ded-86b9-da1173d74001",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not nltk.find('corpora/wordnet'):\n",
    "     nltk.download('wordnet')\n",
    "porter_stemmer  = PorterStemmer()\n",
    "lemmatizer      = WordNetLemmatizer()\n",
    "regex_tokenizer = nltk.tokenize.RegexpTokenizer(r\"\\w+\")\n",
    "spell  = SpellChecker()\n",
    "one_hot_vectorizer = CountVectorizer(binary=True)\n",
    "args = Namespace(\n",
    "    # Data and Path hyper parameters\n",
    "    injury_bodyparts_file=\"./data/injurybodyparts.csv\",\n",
    "    vectorizer_file=\"vectorizer.json\",\n",
    "    cuda=True, \n",
    ")\n",
    "\n",
    "np.random.seed(666)\n",
    "torch.manual_seed(666)\n",
    "if args.cuda:\n",
    "    torch.cuda.manual_seed_all(666)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40cbf84f-31e7-4b97-92e9-59316b9e1721",
   "metadata": {},
   "source": [
    "## Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "71b3b33b-dd35-4779-9884-be1c87a94f40",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_batches(dataset, batch_size, shuffle=True,\n",
    "                     drop_last=True, device=\"cpu\"): \n",
    "    dataloader = DataLoader(dataset=dataset, batch_size=batch_size,\n",
    "                            shuffle=shuffle, drop_last=drop_last)\n",
    "\n",
    "    for data_dict in dataloader:\n",
    "        out_data_dict = {}\n",
    "        for name, tensor in data_dict.items():\n",
    "            out_data_dict[name] = data_dict[name].to(device)\n",
    "        yield out_data_dict\n",
    "\n",
    "def make_train_state(args):\n",
    "    return {'stop_early': False,\n",
    "            'early_stopping_step': 0,\n",
    "            'early_stopping_best_val': 1e8,\n",
    "            'learning_rate': args.learning_rate,\n",
    "            'epoch_index': 0,\n",
    "            'train_loss': [],\n",
    "            'train_acc': [],\n",
    "            'val_loss': [],\n",
    "            'val_acc': [],\n",
    "            'test_loss': -1,\n",
    "            'test_acc': -1,\n",
    "            'model_filename': args.model_state_file}\n",
    "\n",
    "def update_train_state(args, model, train_state):\n",
    "    # Save one model at least\n",
    "    if train_state['epoch_index'] == 0:\n",
    "        torch.save(model.state_dict(), train_state['model_filename'])\n",
    "        train_state['stop_early'] = False\n",
    "\n",
    "    # Save model if performance improved\n",
    "    elif train_state['epoch_index'] >= 1:\n",
    "        loss_tm1, loss_t = train_state['val_loss'][-2:]\n",
    "\n",
    "        # If loss worsened\n",
    "        if loss_t >= train_state['early_stopping_best_val']:\n",
    "            # Update step\n",
    "            train_state['early_stopping_step'] += 1\n",
    "        # Loss decreased\n",
    "        else:\n",
    "            # Save the best model\n",
    "            if loss_t < train_state['early_stopping_best_val']:\n",
    "                torch.save(model.state_dict(), train_state['model_filename'])\n",
    "\n",
    "            # Reset early stopping step\n",
    "            train_state['early_stopping_step'] = 0\n",
    "    return train_state\n",
    "\n",
    "#computes the accuracy of the model\n",
    "def compute_accuracy(y_pred, y_target):\n",
    "    y_target = y_target.cpu()\n",
    "    y_pred_indices = (torch.sigmoid(y_pred)>0.5).cpu().long()#.max(dim=1)[1]\n",
    "    n_correct = torch.eq(y_pred_indices, y_target).sum().item()\n",
    "    return n_correct / len(y_pred_indices) * 100\n",
    "\n",
    "def set_seed_everywhere(seed, cuda):\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    if cuda:\n",
    "        torch.cuda.manual_seed_all(seed)\n",
    "\n",
    "def handle_dirs(dirpath):\n",
    "    if not os.path.exists(dirpath):\n",
    "        os.makedirs(dirpath)\n",
    "\n",
    "def make_embedding_matrix(glove_filepath, words):\n",
    "    word_to_idx, glove_embeddings = load_glove_from_file(glove_filepath)\n",
    "    embedding_size = glove_embeddings.shape[1]\n",
    "    \n",
    "    final_embeddings = np.zeros((len(words), embedding_size))\n",
    "\n",
    "    for i, word in enumerate(words):\n",
    "        if word in word_to_idx:\n",
    "            final_embeddings[i, :] = glove_embeddings[word_to_idx[word]]\n",
    "        else:\n",
    "            embedding_i = torch.ones(1, embedding_size)\n",
    "            torch.nn.init.xavier_uniform_(embedding_i)\n",
    "            final_embeddings[i, :] = embedding_i\n",
    "\n",
    "    return final_embeddings, embedding_size\n",
    "\n",
    "#load glove data from the file\n",
    "def load_glove_from_file(glove_filepath):\n",
    "    word_to_index = {}\n",
    "    embeddings = []\n",
    "    with open(glove_filepath, encoding=\"utf8\") as fp:\n",
    "        for index, line in enumerate(fp):\n",
    "            line = line.split(\" \") # each line: word num1 num2 ...\n",
    "            word_to_index[line[0]] = index # word = line[0] \n",
    "            embedding_i = np.array([float(val) for val in line[1:]])\n",
    "            embeddings.append(embedding_i)\n",
    "    return word_to_index, np.stack(embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bf1c645b-edf8-40fb-9d01-439912866397",
   "metadata": {},
   "outputs": [],
   "source": [
    "#print training loss vs accuracy and validation training vs accuracy\n",
    "def pretty_print(epoch, t_loss, t_acc, v_loss, v_acc):\n",
    "    det = str(epoch)\n",
    "    if epoch < 100:\n",
    "        det = '0' + det\n",
    "    \n",
    "    if epoch < 10:\n",
    "        det = '0' + det\n",
    "    print(\"Epochs:\", det, '| Train loss', str(t_loss)[: 6], 'Train acc', str(t_acc)[: 6], 'Val loss', str(v_loss)[: 6], 'Val acc', str(v_acc)[: 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "64264d4b-f4fe-400c-9356-8201a411e011",
   "metadata": {},
   "outputs": [],
   "source": [
    "args = Namespace(\n",
    "    injury_bodyparts_file=\"./data/injurybodyparts.csv\",\n",
    "    vectorizer_file=\"MCWBvectorizer.json\",\n",
    "    glove_filepath = \"./Glove/glove.6B.200d.txt\",\n",
    "    model_state_file = 'RNN.h5',\n",
    "    # Training hyperparameter\n",
    "    learning_rate = 0.0002,\n",
    "    seed=666,\n",
    "    dropout_p=0.1,\n",
    "    # Runtime option\n",
    "    cuda=True, \n",
    "    num_epoch=150,\n",
    "    use_glove=True,\n",
    "    catch_keyboard_interrupt=True, \n",
    "    reload_from_files=False,\n",
    "    expand_filepaths_to_save_dir=True\n",
    ") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3d0565f-3165-4fd0-b4cd-3683645fde26",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Word embedding Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9b24bf9a-7406-48f2-9d46-03e77cfbdada",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vocabulary(object):\n",
    "    def __init__(self, token_to_idx=None):\n",
    "        if token_to_idx is None:\n",
    "            token_to_idx = {}\n",
    "        self._token_to_idx = token_to_idx\n",
    "        self._idx_to_token = {idx: token for token, idx in self._token_to_idx.items()}\n",
    "        \n",
    "    def to_serializable(self):\n",
    "        return {'token_to_idx': self._token_to_idx}\n",
    "\n",
    "    @classmethod\n",
    "    def from_serializable(cls, contents):\n",
    "        return cls(**contents)\n",
    "\n",
    "    def add_token(self, token):\n",
    "        if token in self._token_to_idx:\n",
    "            index = self._token_to_idx[token]\n",
    "        else:\n",
    "            index = len(self._token_to_idx)\n",
    "            self._token_to_idx[token] = index\n",
    "            self._idx_to_token[index] = token\n",
    "        return index\n",
    "            \n",
    "    def add_many(self, tokens):\n",
    "        return [self.add_token(token) for token in tokens]\n",
    "\n",
    "    def lookup_token(self, token):\n",
    "        return self._token_to_idx[token]\n",
    "\n",
    "    def lookup_index(self, index):\n",
    "        if index not in self._idx_to_token:\n",
    "            raise KeyError(\"the index (%d) is not in the Vocabulary\" % index)\n",
    "        return self._idx_to_token[index]\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"<Vocabulary(size=%d)>\" % len(self)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._token_to_idx)\n",
    "    \n",
    "class SequenceVocabulary(Vocabulary):\n",
    "    def __init__(self, token_to_idx=None, unk_token=\"<UNK>\",\n",
    "                 mask_token=\"<MASK>\", begin_seq_token=\"<BEGIN>\",\n",
    "                 end_seq_token=\"<END>\"):\n",
    "\n",
    "        super(SequenceVocabulary, self).__init__(token_to_idx)\n",
    "        self._mask_token = mask_token\n",
    "        self._unk_token = unk_token\n",
    "        self._begin_seq_token = begin_seq_token\n",
    "        self._end_seq_token = end_seq_token\n",
    "\n",
    "        self.mask_index = self.add_token(self._mask_token)\n",
    "        self.unk_index = self.add_token(self._unk_token)\n",
    "        self.begin_seq_index = self.add_token(self._begin_seq_token)\n",
    "        self.end_seq_index = self.add_token(self._end_seq_token)\n",
    "\n",
    "    def to_serializable(self):\n",
    "        contents = super(SequenceVocabulary, self).to_serializable()\n",
    "        contents.update({'unk_token': self._unk_token,\n",
    "                         'mask_token': self._mask_token,\n",
    "                         'begin_seq_token': self._begin_seq_token,\n",
    "                         'end_seq_token': self._end_seq_token})\n",
    "        return contents\n",
    "\n",
    "    def lookup_token(self, token):\n",
    "        if self.unk_index >= 0:\n",
    "            return self._token_to_idx.get(token, self.unk_index)\n",
    "        else:\n",
    "            return self._token_to_idx[token]\n",
    "\n",
    "class IBPVectorizer(object):\n",
    "    def __init__(self, NARRATIVE_vocab, target_vocab):\n",
    "        self.NARRATIVE_vocab = NARRATIVE_vocab\n",
    "        self.target_vocab = target_vocab\n",
    "\n",
    "    def vectorize(self, NARRATIVE, vector_length=-1):\n",
    "        indices = [self.NARRATIVE_vocab.begin_seq_index]\n",
    "        indices.extend(self.NARRATIVE_vocab.lookup_token(token) for token in NARRATIVE.split(\" \"))\n",
    "        indices.append(self.NARRATIVE_vocab.end_seq_index)\n",
    "\n",
    "        if vector_length < 0:\n",
    "            vector_length = len(indices)\n",
    "        \n",
    "        out_vector = np.zeros(vector_length, dtype=np.int64)\n",
    "        out_vector[vector_length - len(indices):] = indices\n",
    "        out_vector[:vector_length - len(indices)] = self.NARRATIVE_vocab.mask_index\n",
    "        return out_vector, vector_length\n",
    "    \n",
    "    @classmethod\n",
    "    def from_dataframe(cls, df, cutoff=5):\n",
    "        target_vocab = Vocabulary()        \n",
    "        for target in sorted(set(df.target)):\n",
    "            target_vocab.add_token(target)\n",
    "        \n",
    "        word_counts = Counter()\n",
    "        for NARRATIVE in df.NARRATIVE:\n",
    "            for token in NARRATIVE.split(\" \"):\n",
    "                if token not in string.punctuation:\n",
    "                    word_counts[token] += 1\n",
    "        \n",
    "        NARRATIVE_vocab = SequenceVocabulary()\n",
    "        for word, word_count in word_counts.items():\n",
    "            if word_count >= cutoff:\n",
    "                NARRATIVE_vocab.add_token(word)\n",
    "        \n",
    "        return cls(NARRATIVE_vocab, target_vocab)\n",
    "    \n",
    "    @classmethod\n",
    "    def from_serializable(cls, contents):\n",
    "        title_vocab = SequenceVocabulary.from_serializable(contents['NARRATIVE_vocab'])\n",
    "        category_vocab = Vocabulary.from_serializable(contents['target_vocab'])\n",
    "        return cls(NARRATIVE_vocab=NARRATIVE_vocab, target_vocab=target_vocab)\n",
    "\n",
    "    def to_serializable(self):\n",
    "        return {'NARRATIVE_vocab': self.NARRATIVE_vocab.to_serializable(), 'target_vocab': self.target_vocab.to_serializable()}\n",
    "\n",
    "class IBPDataset(Dataset):\n",
    "    def __init__(self, df, vectorizer):\n",
    "        self.df = df\n",
    "        self._vectorizer = vectorizer\n",
    "\n",
    "        # +1 if only using begin_seq, +2 if using both begin and end seq tokens\n",
    "        measure_len = lambda context: len(context.split(\" \"))\n",
    "        self._max_seq_length = max(map(measure_len, df.NARRATIVE)) + 2\n",
    "        \n",
    "        self.train_df = self.df[self.df.split=='train']\n",
    "        self.train_size = len(self.train_df)\n",
    "\n",
    "        self.val_df = self.df[self.df.split=='val']\n",
    "        self.validation_size = len(self.val_df)\n",
    "\n",
    "        self.test_df = self.df[self.df.split=='test']\n",
    "        self.test_size = len(self.test_df)\n",
    "\n",
    "        self._lookup_dict = {'train': (self.train_df, self.train_size), 'val': (self.val_df, self.validation_size), 'test': (self.test_df, self.test_size)}\n",
    "        self.set_split('train')\n",
    "\n",
    "        # Class weights\n",
    "        class_counts = df.target.value_counts().to_dict()\n",
    "        def sort_key(item):\n",
    "            return self._vectorizer.target_vocab.lookup_token(item[0])\n",
    "        sorted_counts = sorted(class_counts.items(), key=sort_key)\n",
    "        frequencies = [count for _, count in sorted_counts]\n",
    "        self.class_weights = 1.0 / torch.tensor(frequencies, dtype=torch.float32)\n",
    "        \n",
    "    @classmethod\n",
    "    def load_dataset_and_make_vectorizer(cls, news_csv):\n",
    "        df = pd.read_csv(news_csv)\n",
    "        train_df = df[df.split=='train']\n",
    "        return cls(df, IBPVectorizer.from_dataframe(train_df))\n",
    "\n",
    "    @classmethod\n",
    "    def load_dataset_and_load_vectorizer(cls, news_csv, vectorizer_filepath):\n",
    "        df = pd.read_csv(news_csv)\n",
    "        vectorizer = cls.load_vectorizer_only(vectorizer_filepath)\n",
    "        return cls(news_csv, vectorizer)\n",
    "\n",
    "    @staticmethod\n",
    "    def load_vectorizer_only(vectorizer_filepath):\n",
    "        with open(vectorizer_filepath) as fp:\n",
    "            return NameVectorizer.from_serializable(json.load(fp))\n",
    "\n",
    "    def save_vectorizer(self, vectorizer_filepath):\n",
    "        with open(vectorizer_filepath, \"w\") as fp:\n",
    "            json.dump(self._vectorizer.to_serializable(), fp)\n",
    "\n",
    "    def get_vectorizer(self):\n",
    "        return self._vectorizer\n",
    "\n",
    "    def set_split(self, split=\"train\"):\n",
    "        self._target_split = split\n",
    "        self._target_df, self._target_size = self._lookup_dict[split]\n",
    "\n",
    "    def __len__(self):\n",
    "        return self._target_size\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        row = self._target_df.iloc[index]\n",
    "        NARRATIVE_vector, vector_length = self._vectorizer.vectorize(row.NARRATIVE, self._max_seq_length)\n",
    "        target_index = self._vectorizer.target_vocab.lookup_token(row.target) #-1\n",
    "        return {'x_data': NARRATIVE_vector,'y_target': target_index, 'x_length': vector_length}\n",
    "\n",
    "    def get_num_batches(self, batch_size):\n",
    "        return len(self) // batch_size\n",
    "    \n",
    "def evaulate_performance(y_pred, y_actual, vector, ):\n",
    "    _, y_pred_indices = y_pred.max(dim=1)\n",
    "    \n",
    "    y_pred  = [vector.target_vocab.lookup_index(i.item()) for i in y_pred_indices]\n",
    "    y_test = [vector.target_vocab.lookup_index(i.item()) for i in y_actual]\n",
    "    ConfusionMatrixDisplay.from_predictions(y_test, y_pred, normalize=\"pred\")\n",
    "    ConfusionMatrixDisplay.from_predictions(y_test, y_pred)\n",
    "    \n",
    "def graph(lst,train, validation,y_axis_label,title):\n",
    "    plt.figure(figsize=(20,7))\n",
    "    plt.plot(lst[\"epoch_index\"], lst[train],'-o')\n",
    "    plt.plot(lst[\"epoch_index\"], lst[validation],'-o')\n",
    "    plt.xlabel('epoch')\n",
    "    plt.ylabel(y_axis_label)\n",
    "    plt.legend(['Train','Valid'])\n",
    "    plt.title('Train vs Valid' + ' ' + title)\n",
    "    plt.show()\n",
    "    \n",
    "def plot_graph(args):\n",
    "    return {'epoch_index': [],\n",
    "            'train_loss': [],\n",
    "            'train_acc': [],\n",
    "            'val_loss': [],\n",
    "            'val_acc': []}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f66816c-1171-41e9-b343-e3302513221e",
   "metadata": {
    "tags": []
   },
   "source": [
    "## OHE Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ccf17495-78ae-4536-8dc1-66a32369edb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class OHEIBPVectorizer(object):\n",
    "    def __init__(self, NARRATIVE_vocab, target_vocab):\n",
    "        self.NARRATIVE_vocab = NARRATIVE_vocab\n",
    "        self.target_vocab = target_vocab\n",
    "\n",
    "    def vectorize(self, NARRATIVE, vector_length=-1):\n",
    "        one_hot = np.zeros(len(self.NARRATIVE_vocab), dtype=np.float32)\n",
    "        for token in NARRATIVE.split(\" \"):\n",
    "            if token not in string.punctuation:\n",
    "                one_hot[self.NARRATIVE_vocab.lookup_token(token)] = 1\n",
    "        return one_hot, len(self.NARRATIVE_vocab)\n",
    "    \n",
    "    @classmethod\n",
    "    def from_dataframe(cls, df, cutoff=5):\n",
    "        target_vocab = Vocabulary()        \n",
    "        for target in sorted(set(df.target)):\n",
    "            target_vocab.add_token(target)\n",
    "        \n",
    "        word_counts = Counter()\n",
    "        for NARRATIVE in df.NARRATIVE:\n",
    "            for token in NARRATIVE.split(\" \"):\n",
    "                if token not in string.punctuation:\n",
    "                    word_counts[token] += 1\n",
    "        \n",
    "        NARRATIVE_vocab = SequenceVocabulary()\n",
    "        for word, word_count in word_counts.items():\n",
    "            if word_count >= cutoff:\n",
    "                NARRATIVE_vocab.add_token(word)\n",
    "        \n",
    "        return cls(NARRATIVE_vocab, target_vocab)\n",
    "    \n",
    "    @classmethod\n",
    "    def from_serializable(cls, contents):\n",
    "        title_vocab = SequenceVocabulary.from_serializable(contents['NARRATIVE_vocab'])\n",
    "        category_vocab = Vocabulary.from_serializable(contents['target_vocab'])\n",
    "        return cls(NARRATIVE_vocab=NARRATIVE_vocab, target_vocab=target_vocab)\n",
    "\n",
    "    def to_serializable(self):\n",
    "        return {'NARRATIVE_vocab': self.NARRATIVE_vocab.to_serializable(), 'target_vocab': self.target_vocab.to_serializable()}\n",
    "\n",
    "class OHEIBPDataset(Dataset):\n",
    "    def __init__(self, df, vectorizer):\n",
    "        self.df = df\n",
    "        self._vectorizer = vectorizer\n",
    "\n",
    "        # +1 if only using begin_seq, +2 if using both begin and end seq tokens\n",
    "        measure_len = lambda context: len(context.split(\" \"))\n",
    "        self._max_seq_length = max(map(measure_len, df.NARRATIVE)) + 2\n",
    "        \n",
    "        self.train_df = self.df[self.df.split=='train']\n",
    "        self.train_size = len(self.train_df)\n",
    "\n",
    "        self.val_df = self.df[self.df.split=='val']\n",
    "        self.validation_size = len(self.val_df)\n",
    "\n",
    "        self.test_df = self.df[self.df.split=='test']\n",
    "        self.test_size = len(self.test_df)\n",
    "\n",
    "        self._lookup_dict = {'train': (self.train_df, self.train_size), 'val': (self.val_df, self.validation_size), 'test': (self.test_df, self.test_size)}\n",
    "        self.set_split('train')\n",
    "\n",
    "        # Class weights\n",
    "        class_counts = df.target.value_counts().to_dict()\n",
    "        def sort_key(item):\n",
    "            return self._vectorizer.target_vocab.lookup_token(item[0])\n",
    "        sorted_counts = sorted(class_counts.items(), key=sort_key)\n",
    "        frequencies = [count for _, count in sorted_counts]\n",
    "        self.class_weights = 1.0 / torch.tensor(frequencies, dtype=torch.float32)\n",
    "        \n",
    "    @classmethod\n",
    "    def load_dataset_and_make_vectorizer(cls, news_csv):\n",
    "        df = pd.read_csv(news_csv)\n",
    "        train_df = df[df.split=='train']\n",
    "        return cls(df, OHEIBPVectorizer.from_dataframe(train_df))\n",
    "\n",
    "    @classmethod\n",
    "    def load_dataset_and_load_vectorizer(cls, news_csv, vectorizer_filepath):\n",
    "        df = pd.read_csv(news_csv)\n",
    "        vectorizer = cls.load_vectorizer_only(vectorizer_filepath)\n",
    "        return cls(news_csv, vectorizer)\n",
    "\n",
    "    @staticmethod\n",
    "    def load_vectorizer_only(vectorizer_filepath):\n",
    "        with open(vectorizer_filepath) as fp:\n",
    "            return NameVectorizer.from_serializable(json.load(fp))\n",
    "\n",
    "    def save_vectorizer(self, vectorizer_filepath):\n",
    "        with open(vectorizer_filepath, \"w\") as fp:\n",
    "            json.dump(self._vectorizer.to_serializable(), fp)\n",
    "\n",
    "    def get_vectorizer(self):\n",
    "        return self._vectorizer\n",
    "\n",
    "    def set_split(self, split=\"train\"):\n",
    "        self._target_split = split\n",
    "        self._target_df, self._target_size = self._lookup_dict[split]\n",
    "\n",
    "    def __len__(self):\n",
    "        return self._target_size\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        row = self._target_df.iloc[index]\n",
    "        NARRATIVE_vector, vector_length = self._vectorizer.vectorize(row.NARRATIVE, self._max_seq_length)\n",
    "        target_index = self._vectorizer.target_vocab.lookup_token(row.target) #-1\n",
    "        return {'x_data': NARRATIVE_vector,'y_target': target_index, 'x_length': vector_length}\n",
    "\n",
    "    def get_num_batches(self, batch_size):\n",
    "        return len(self) // batch_size"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86e64900-9f2f-4a7c-94f1-6d4266c731e5",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Model - Classifier\n",
    "Model Below based on wordembeding, not yet experimented with OHE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ff3c84ff-dc24-47d1-95b8-c9d71539dfe7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def column_gather(y_out, x_lengths):\n",
    "    x_lengths = x_lengths.long().detach().cpu().numpy() - 1\n",
    "\n",
    "    out = []\n",
    "    for batch_index, column_index in enumerate(x_lengths):\n",
    "        out.append(y_out[batch_index, column_index])\n",
    "\n",
    "    return torch.stack(out)\n",
    "\n",
    "class IBPClassifier(nn.Module):\n",
    "    def __init__(self, embedding_size, num_embeddings, num_classes, rnn_hidden_size, hidden_dim, RNN=True, pretrained_embeddings=None, padding_idx=0, batch_first=True):\n",
    "        super(IBPClassifier, self).__init__()\n",
    "\n",
    "        if pretrained_embeddings is None:\n",
    "            self.emb = nn.Embedding(embedding_dim=embedding_size, num_embeddings=num_embeddings, padding_idx=padding_idx)        \n",
    "        else:\n",
    "            pretrained_embeddings = torch.from_numpy(pretrained_embeddings).float()\n",
    "            self.emb = nn.Embedding(embedding_dim=embedding_size, num_embeddings=num_embeddings, padding_idx=padding_idx,  _weight=pretrained_embeddings)\n",
    "\n",
    "        if RNN:\n",
    "            self.rnn = VanillaRNN(input_size=embedding_size, hidden_size=rnn_hidden_size, batch_first=batch_first)\n",
    "        else:\n",
    "            self.rnn = LstmRNN(input_size=embedding_size, hidden_size=rnn_hidden_size, batch_first=batch_first)\n",
    "#             self.rnn = nn.LSTM(embedding_size, rnn_hidden_size, batch_first=batch_first) \n",
    "        \n",
    "        self.RNN = RNN\n",
    "        self.num_classes = num_classes\n",
    "        self.rnn_hidden_size = rnn_hidden_size\n",
    "        #MLP         \n",
    "        self.fc1 = nn.Linear(rnn_hidden_size, hidden_dim[0])\n",
    "        self.relu1 = nn.ReLU()\n",
    "        self.dropout1 = nn.Dropout(0.1)\n",
    "\n",
    "        self.fc2 = nn.Linear(hidden_dim[0], hidden_dim[1])\n",
    "        self.relu2 = nn.ReLU()\n",
    "\n",
    "        self.fc3 = nn.Linear(hidden_dim[1], num_classes)\n",
    "\n",
    "    def forward(self, x, x_lengths=None, apply_softmax=False):\n",
    "        # embed and permute so features are channels\n",
    "        out = self.emb(x)\n",
    "        out = self.rnn(out)\n",
    "\n",
    "        \n",
    "        if self.RNN:\n",
    "            if x_lengths is not None:\n",
    "                out = column_gather(out, x_lengths)\n",
    "            else:\n",
    "                out = out[:, -1, :]\n",
    "\n",
    "        out = self.fc1(out)\n",
    "        out = self.relu1(out)\n",
    "        out = self.dropout1(out)\n",
    "        \n",
    "        out = self.fc2(out)\n",
    "        out = self.relu2(out)\n",
    "        \n",
    "        out = self.fc3(out)\n",
    "\n",
    "        if apply_softmax:\n",
    "            out = torch.nn.functional.softmax(out, dim=1)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d2b26d5-1040-449f-a545-4fc68a248be0",
   "metadata": {
    "tags": []
   },
   "source": [
    "## VanillaRNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f03cdad6-2e18-4cfd-8ffe-e6d5cea36687",
   "metadata": {},
   "outputs": [],
   "source": [
    "class VanillaRNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, batch_first=False):\n",
    "        super(VanillaRNN, self).__init__()\n",
    "        self.rnn_cell = nn.RNNCell(input_size, hidden_size)\n",
    "        self.batch_first = batch_first\n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "    def _initial_hidden(self, batch_size):\n",
    "        return torch.zeros((batch_size, self.hidden_size))\n",
    "\n",
    "    def forward(self, x_in, initial_hidden=None):\n",
    "        if self.batch_first:\n",
    "            batch_size, seq_size, feat_size = x_in.size()\n",
    "            x_in = x_in.permute(1, 0, 2)\n",
    "        else:\n",
    "            seq_size, batch_size, feat_size = x_in.size()\n",
    "    \n",
    "        hiddens = []\n",
    "\n",
    "        if initial_hidden is None:\n",
    "            initial_hidden = self._initial_hidden(batch_size)\n",
    "            initial_hidden = initial_hidden.to(x_in.device)\n",
    "\n",
    "        hidden_t = initial_hidden\n",
    "                    \n",
    "        for t in range(seq_size):\n",
    "            hidden_t = self.rnn_cell(x_in[t], hidden_t)\n",
    "            hiddens.append(hidden_t)\n",
    "            \n",
    "        hiddens = torch.stack(hiddens)\n",
    "\n",
    "        if self.batch_first:\n",
    "            hiddens = hiddens.permute(1, 0, 2)\n",
    "\n",
    "        return hiddens\n",
    "def compute_accuracy(y_pred, y_target):\n",
    "    _, y_pred_indices = y_pred.max(dim=1)\n",
    "    n_correct = torch.eq(y_pred_indices, y_target).sum().item()\n",
    "    return n_correct / len(y_pred_indices) * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9e09dfd7-6829-4d59-bb36-60d315f4ae08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using pre-trained embeddings\n"
     ]
    }
   ],
   "source": [
    "if args.reload_from_files:\n",
    "    # training from a checkpoint\n",
    "    dataset = IBPDataset.load_dataset_and_load_vectorizer(args.injury_bodyparts_file, args.vectorizer_file)\n",
    "else:\n",
    "    # create dataset and vectorizer\n",
    "    dataset = IBPDataset.load_dataset_and_make_vectorizer(args.injury_bodyparts_file)\n",
    "    dataset.save_vectorizer(args.vectorizer_file)\n",
    "vectorizer = dataset.get_vectorizer()\n",
    "\n",
    "# Use GloVe or randomly initialized embeddings\n",
    "if args.use_glove:\n",
    "    words = vectorizer.NARRATIVE_vocab._token_to_idx.keys()\n",
    "    embeddings, embedding_size = make_embedding_matrix(glove_filepath=args.glove_filepath, words=words)\n",
    "    print(\"Using pre-trained embeddings\")\n",
    "else:\n",
    "    print(\"Not using pre-trained embeddings\")\n",
    "    embeddings = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "62c64319-8b84-4f96-809f-214a9b46fe0a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'x_data': array([ 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,  0,  0,  0,  0,  0,  0,  0,  2,  4,  5,  6,\n",
       "         7,  8,  9, 10, 11, 12,  7, 13,  1,  7,  9, 14, 15,  7,  1, 16, 17,\n",
       "        18, 19,  1,  3]),\n",
       " 'y_target': 0,\n",
       " 'x_length': 72}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "99654d8f-7445-4dc7-8200-4fcd03bc98a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using CUDA: True\n"
     ]
    }
   ],
   "source": [
    "# Check CUDA\n",
    "if not torch.cuda.is_available():\n",
    "    args.cuda = False\n",
    "\n",
    "args.device = torch.device(\"cuda\" if args.cuda else \"cpu\")\n",
    "    \n",
    "print(\"Using CUDA: {}\".format(args.cuda))\n",
    "# Set seed for reproducibility\n",
    "set_seed_everywhere(args.seed, args.cuda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4523c2be-478b-4db8-b021-cc82265d5473",
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier = IBPClassifier(\n",
    "    embedding_size=embedding_size, \n",
    "    num_embeddings=len(vectorizer.NARRATIVE_vocab),\n",
    "    num_classes=len(vectorizer.target_vocab),\n",
    "    rnn_hidden_size=256,\n",
    "    hidden_dim = [128, 64],\n",
    "    padding_idx=vectorizer.NARRATIVE_vocab.mask_index,\n",
    "    pretrained_embeddings=embeddings\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d9cc4399-157b-479b-a672-cc59b6b03623",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs: 000 | Train loss 1.6114 Train acc 21.773 Val loss 1.6095 Val acc 21.985\n",
      "Epochs: 003 | Train loss 1.6066 Train acc 21.931 Val loss 1.6061 Val acc 24.113\n",
      "Epochs: 004 | Train loss 1.6051 Train acc 24.228 Val loss 1.6051 Val acc 25.531\n",
      "Epochs: 005 | Train loss 1.6036 Train acc 27.553 Val loss 1.6039 Val acc 27.659\n",
      "Epochs: 006 | Train loss 1.6024 Train acc 29.532 Val loss 1.6027 Val acc 28.368\n",
      "Epochs: 016 | Train loss 1.5802 Train acc 37.608 Val loss 1.5856 Val acc 31.914\n",
      "Epochs: 017 | Train loss 1.5773 Train acc 38.875 Val loss 1.5831 Val acc 32.624\n",
      "Epochs: 018 | Train loss 1.5737 Train acc 38.004 Val loss 1.5802 Val acc 33.333\n",
      "Epochs: 019 | Train loss 1.5699 Train acc 38.717 Val loss 1.5770 Val acc 34.042\n",
      "Epochs: 020 | Train loss 1.5659 Train acc 39.034 Val loss 1.5736 Val acc 35.460\n",
      "Epochs: 022 | Train loss 1.5565 Train acc 39.746 Val loss 1.5657 Val acc 36.170\n",
      "Epochs: 024 | Train loss 1.5461 Train acc 41.171 Val loss 1.5563 Val acc 36.879\n",
      "Epochs: 025 | Train loss 1.5404 Train acc 41.646 Val loss 1.5508 Val acc 37.588\n",
      "Epochs: 026 | Train loss 1.5325 Train acc 42.042 Val loss 1.5447 Val acc 39.007\n",
      "Epochs: 027 | Train loss 1.5262 Train acc 42.121 Val loss 1.5377 Val acc 41.134\n",
      "Epochs: 030 | Train loss 1.4986 Train acc 44.418 Val loss 1.5080 Val acc 42.553\n",
      "Epochs: 031 | Train loss 1.4868 Train acc 44.418 Val loss 1.4924 Val acc 43.262\n",
      "Epochs: 032 | Train loss 1.4782 Train acc 43.784 Val loss 1.4731 Val acc 46.099\n",
      "Epochs: 033 | Train loss 1.4674 Train acc 46.080 Val loss 1.4507 Val acc 49.645\n",
      "Epochs: 035 | Train loss 1.4454 Train acc 47.980 Val loss 1.4233 Val acc 51.773\n",
      "Epochs: 037 | Train loss 1.4190 Train acc 51.068 Val loss 1.4122 Val acc 53.900\n",
      "Epochs: 042 | Train loss 1.3450 Train acc 56.769 Val loss 1.3268 Val acc 58.865\n",
      "Epochs: 043 | Train loss 1.3277 Train acc 57.244 Val loss 1.3007 Val acc 59.574\n",
      "Epochs: 044 | Train loss 1.3091 Train acc 61.282 Val loss 1.2836 Val acc 64.539\n",
      "Epochs: 046 | Train loss 1.2884 Train acc 59.699 Val loss 1.2667 Val acc 66.666\n",
      "Epochs: 052 | Train loss 1.2090 Train acc 66.429 Val loss 1.1813 Val acc 68.085\n",
      "Epochs: 060 | Train loss 1.0916 Train acc 71.179 Val loss 1.0940 Val acc 70.921\n",
      "Epochs: 061 | Train loss 1.0847 Train acc 71.338 Val loss 1.0766 Val acc 73.049\n",
      "Epochs: 067 | Train loss 0.9993 Train acc 74.030 Val loss 1.0121 Val acc 74.468\n",
      "Epochs: 071 | Train loss 0.9424 Train acc 75.455 Val loss 0.9797 Val acc 75.886\n",
      "Epochs: 074 | Train loss 0.8995 Train acc 76.247 Val loss 0.9611 Val acc 76.595\n",
      "Epochs: 079 | Train loss 0.8394 Train acc 76.088 Val loss 0.9424 Val acc 77.304\n",
      "Epochs: 082 | Train loss 0.8123 Train acc 76.801 Val loss 0.9252 Val acc 78.014\n"
     ]
    }
   ],
   "source": [
    "classifier = classifier.to(args.device)\n",
    "dataset.class_weights = dataset.class_weights.to(args.device)\n",
    "    \n",
    "loss_func = nn.CrossEntropyLoss(dataset.class_weights)\n",
    "optimizer = optim.Adam(classifier.parameters(), lr=args.learning_rate)\n",
    "\n",
    "train_state = make_train_state(args)\n",
    "\n",
    "best_val  = {\n",
    "    'epoch': 0,\n",
    "    'model_state_dict': 0,\n",
    "    'optimizer_state_dict': 0,\n",
    "    'loss': 0,\n",
    "    'acc':0\n",
    "}\n",
    "loss_acc_plot = plot_graph(args)\n",
    "try:\n",
    "    for epoch_index in range(args.num_epoch):\n",
    "        train_state['epoch_index'] = epoch_index\n",
    "\n",
    "        # Iterate over training dataset\n",
    "        # setup: batch generator, set loss and acc to 0, set train mode on\n",
    "        dataset.set_split('train')\n",
    "        batch_generator = generate_batches(dataset, batch_size=len(dataset), device=args.device)\n",
    "        running_loss = 0.0\n",
    "        running_acc = 0.0\n",
    "        classifier.train()\n",
    "\n",
    "        for batch_index, batch_dict in enumerate(batch_generator):\n",
    "            # the training routine is these 5 steps:\n",
    "\n",
    "            # --------------------------------------    \n",
    "            # step 1. zero the gradients\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # step 2. compute the output\n",
    "            y_pred = classifier(x=batch_dict['x_data'], x_lengths=batch_dict['x_length'])\n",
    "\n",
    "            # step 3. compute the loss\n",
    "            loss = loss_func(y_pred, batch_dict['y_target'])\n",
    "    \n",
    "            running_loss += (loss.item() - running_loss) / (batch_index + 1)\n",
    "\n",
    "            # step 4. use loss to produce gradients\n",
    "            loss.backward()\n",
    "\n",
    "            # step 5. use optimizer to take gradient step\n",
    "            optimizer.step()\n",
    "            # -----------------------------------------\n",
    "            # compute the accuracy\n",
    "            acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n",
    "            running_acc += (acc_t - running_acc) / (batch_index + 1)\n",
    "\n",
    "        train_state['train_loss'].append(running_loss)\n",
    "        train_state['train_acc'].append(running_acc)\n",
    "\n",
    "        # Iterate over val dataset\\\n",
    "        # setup: batch generator, set loss and acc to 0; set eval mode on\n",
    "\n",
    "        dataset.set_split('val')\n",
    "        batch_generator = generate_batches(dataset, batch_size=len(dataset), device=args.device)\n",
    "        running_loss = 0.\n",
    "        running_acc = 0.\n",
    "        classifier.eval()\n",
    "\n",
    "        for batch_index, batch_dict in enumerate(batch_generator):\n",
    "            # compute the output\n",
    "            y_pred = classifier(x=batch_dict['x_data'], x_lengths=batch_dict['x_length'])\n",
    "\n",
    "            # step 3. compute the loss\n",
    "            loss = loss_func(y_pred, batch_dict['y_target'])\n",
    "            running_loss += (loss.item() - running_loss) / (batch_index + 1)\n",
    "\n",
    "            # compute the accuracy\n",
    "            acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n",
    "            running_acc += (acc_t - running_acc) / (batch_index + 1)\n",
    "\n",
    "        train_state['val_loss'].append(running_loss)\n",
    "        train_state['val_acc'].append(running_acc)\n",
    "        if(best_val['acc']<train_state['val_acc'][-1]):\n",
    "            best_val  = {\n",
    "                'epoch': epoch_index,\n",
    "                'model_state_dict': classifier.state_dict(),\n",
    "                'optimizer_state_dict': optimizer.state_dict(),\n",
    "                'loss': running_loss,\n",
    "                'acc': running_acc,\n",
    "            }\n",
    "            pretty_print(epoch_index, train_state['train_loss'][-1], train_state['train_acc'][-1], train_state['val_loss'][-1], train_state['val_acc'][-1])\n",
    "            loss_acc_plot['epoch_index'].append(epoch_index)\n",
    "            loss_acc_plot['val_loss'].append(round(train_state['val_loss'][-1], 4))\n",
    "            loss_acc_plot['val_acc'].append(round(train_state['val_acc'][-1], 4))\n",
    "            loss_acc_plot['train_loss'].append(round(train_state['train_loss'][-1], 4))\n",
    "            loss_acc_plot['train_acc'].append(round(train_state['train_acc'][-1], 4))\n",
    "        train_state = update_train_state(args=args, model=classifier, train_state=train_state)\n",
    "        \n",
    "except KeyboardInterrupt:\n",
    "    print(\"Exiting loop\")\n",
    "torch.save(best_val, \"RNNGlove.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8248a9cb-a71e-467c-bec0-190b1f039268",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph(loss_acc_plot,'train_acc', 'val_acc','Accuracy','Accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "221b23ba-1f32-4ebf-944b-61eca2c16843",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph(loss_acc_plot, 'train_loss', 'val_loss','Loss','Loss')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "19fc4739-2ae4-443b-a22c-2276edcb2260",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 1.2309035062789917;\n",
      "Test Accuracy: 70.37037037037037\n"
     ]
    }
   ],
   "source": [
    "checkpoint = torch.load(\"RNNGlove.h5\")\n",
    "classifier.load_state_dict(checkpoint['model_state_dict'])\n",
    "optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
    "classifier.eval()\n",
    "\n",
    "args.device = torch.device(\"cpu\")\n",
    "\n",
    "classifier = classifier.to(args.device)\n",
    "dataset.class_weights = dataset.class_weights.to(args.device)\n",
    "loss_func = nn.CrossEntropyLoss(dataset.class_weights)\n",
    "\n",
    "dataset.set_split('test')\n",
    "\n",
    "batch_generator = generate_batches(dataset, batch_size=len(dataset), device=args.device)\n",
    "running_loss = 0.\n",
    "running_acc = 0.\n",
    "\n",
    "classifier.eval()\n",
    "for batch_index, batch_dict in enumerate(batch_generator):\n",
    "    # compute the output\n",
    "    y_pred =  classifier(batch_dict['x_data'], x_lengths=batch_dict['x_length'])\n",
    "    y_actual = batch_dict['y_target']\n",
    "    \n",
    "    # compute the loss\n",
    "    loss = loss_func(y_pred, batch_dict['y_target'])\n",
    "    loss_t = loss.item()\n",
    "    running_loss += (loss_t - running_loss) / (batch_index + 1)\n",
    "\n",
    "    # compute the accuracy\n",
    "    acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n",
    "    running_acc += (acc_t - running_acc) / (batch_index + 1)\n",
    "\n",
    "train_state['test_loss'] = running_loss\n",
    "train_state['test_acc'] = running_acc\n",
    "print(\"Test loss: {};\".format(train_state['test_loss']))\n",
    "print(\"Test Accuracy: {}\".format(train_state['test_acc']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b8a84cdc-bb4a-4290-bd73-5f05f595786a",
   "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"
    },
    {
     "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": [
    "evaulate_performance(y_pred, y_actual, vectorizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56ab027b-eb3f-4c98-bb0c-55836f5ecb8c",
   "metadata": {},
   "source": [
    "The confusion matrix above returns the performance of the Vanilla RNN. From the confusion matrix, we can state the following observations:\n",
    "- The diagonal from the top left to the bottom right represent the true positives. From observation, the model seems to be performing relatively well. Other than the category **Multiple Parts** all other categories have a accuracy rate above 50%. \n",
    "- The **leg** and **Arm** categories have the lowest misclassification rate with 71% and 83% accuracy rate, rectrosepctively. \n",
    "- Only 18% of the **Multiple Parts** instances have been correctly by the classifier. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4424aa38-a812-481e-bb7c-ec9340f196cd",
   "metadata": {
    "tags": []
   },
   "source": [
    "## LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e457107a-bcdf-4524-acb2-ca48784c0ea7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LstmRNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, batch_first=True):\n",
    "        super(LstmRNN, self).__init__()\n",
    "        \n",
    "        self.lstm = nn.LSTM(input_size, hidden_size,num_layers=1, batch_first=batch_first) \n",
    "        self.hidden_size = hidden_size\n",
    "        self.batch_first = batch_first\n",
    "        \n",
    "    def forward(self, x):\n",
    "        if self.batch_first:\n",
    "            batch_first_output, (self.hidden, self.cell) = self.lstm(x)\n",
    "        else:\n",
    "            batch_first_output, (self.hidden, self.cell) = self.lstm(x)\n",
    "        return batch_first_output[:, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e90f407f-3f61-4fff-b619-bee9af10e094",
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier = IBPClassifier(\n",
    "    embedding_size=embedding_size, \n",
    "    num_embeddings=len(vectorizer.NARRATIVE_vocab),\n",
    "    num_classes=len(vectorizer.target_vocab),\n",
    "    rnn_hidden_size=256,\n",
    "    hidden_dim = [128, 64],\n",
    "    RNN=False,\n",
    "    padding_idx=vectorizer.NARRATIVE_vocab.mask_index,\n",
    "    pretrained_embeddings=embeddings\n",
    ")\n",
    "args.device = torch.device(\"cuda\" if args.cuda else \"cpu\")\n",
    "set_seed_everywhere(args.seed, args.cuda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e6bc288e-ab4a-4f6e-874c-b59929bced2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs: 000 | Train loss 1.6126 Train acc 20.506 Val loss 1.6124 Val acc 20.567\n",
      "Epochs: 027 | Train loss 1.5878 Train acc 21.852 Val loss 1.5862 Val acc 21.985\n",
      "Epochs: 028 | Train loss 1.5849 Train acc 24.544 Val loss 1.5833 Val acc 24.822\n",
      "Epochs: 029 | Train loss 1.5816 Train acc 26.840 Val loss 1.5798 Val acc 26.950\n",
      "Epochs: 030 | Train loss 1.5784 Train acc 27.157 Val loss 1.5759 Val acc 28.368\n",
      "Epochs: 032 | Train loss 1.5699 Train acc 30.878 Val loss 1.5656 Val acc 29.078\n",
      "Epochs: 033 | Train loss 1.5642 Train acc 32.066 Val loss 1.5589 Val acc 31.205\n",
      "Epochs: 035 | Train loss 1.5497 Train acc 34.125 Val loss 1.5411 Val acc 36.879\n",
      "Epochs: 036 | Train loss 1.5402 Train acc 38.163 Val loss 1.5290 Val acc 42.553\n",
      "Epochs: 037 | Train loss 1.5285 Train acc 43.151 Val loss 1.5139 Val acc 49.645\n",
      "Epochs: 038 | Train loss 1.5142 Train acc 48.456 Val loss 1.4953 Val acc 56.028\n",
      "Epochs: 039 | Train loss 1.4984 Train acc 52.969 Val loss 1.4734 Val acc 58.865\n",
      "Epochs: 040 | Train loss 1.4795 Train acc 57.798 Val loss 1.4514 Val acc 62.411\n",
      "Epochs: 049 | Train loss 1.3319 Train acc 60.886 Val loss 1.2903 Val acc 63.829\n",
      "Epochs: 053 | Train loss 1.2927 Train acc 61.124 Val loss 1.2332 Val acc 67.375\n",
      "Epochs: 056 | Train loss 1.2362 Train acc 64.449 Val loss 1.1860 Val acc 68.794\n",
      "Epochs: 057 | Train loss 1.2135 Train acc 66.825 Val loss 1.1846 Val acc 70.212\n",
      "Epochs: 061 | Train loss 1.1577 Train acc 68.012 Val loss 1.1171 Val acc 71.631\n",
      "Epochs: 063 | Train loss 1.1201 Train acc 68.883 Val loss 1.0935 Val acc 72.340\n",
      "Epochs: 066 | Train loss 1.0714 Train acc 70.467 Val loss 1.0307 Val acc 73.049\n",
      "Epochs: 067 | Train loss 1.0568 Train acc 70.308 Val loss 1.0204 Val acc 73.758\n",
      "Epochs: 075 | Train loss 0.9453 Train acc 74.030 Val loss 0.9416 Val acc 77.304\n",
      "Epochs: 108 | Train loss 0.6103 Train acc 81.551 Val loss 0.8036 Val acc 78.014\n",
      "Epochs: 137 | Train loss 0.3399 Train acc 90.261 Val loss 0.8613 Val acc 78.723\n"
     ]
    }
   ],
   "source": [
    "classifier = classifier.to(args.device)\n",
    "dataset.class_weights = dataset.class_weights.to(args.device)\n",
    "loss_func = nn.CrossEntropyLoss(weight=dataset.class_weights)\n",
    "optimizer = optim.Adam(classifier.parameters(), lr=args.learning_rate)\n",
    "train_state = make_train_state(args)\n",
    "\n",
    "best_val  = {\n",
    "    'epoch': 0,\n",
    "    'model_state_dict': 0,\n",
    "    'optimizer_state_dict': 0,\n",
    "    'loss': 0,\n",
    "    'acc':0\n",
    "}\n",
    "lstm_loss_acc_plot = plot_graph(args)\n",
    "try:\n",
    "    for epoch_index in range(args.num_epoch):\n",
    "        train_state['epoch_index'] = epoch_index\n",
    "\n",
    "        # Iterate over training dataset\n",
    "        # setup: batch generator, set loss and acc to 0, set train mode on\n",
    "        dataset.set_split('train')\n",
    "        batch_generator = generate_batches(dataset, batch_size=len(dataset), device=args.device)\n",
    "        running_loss = 0.0\n",
    "        running_acc = 0.0\n",
    "        classifier.train()\n",
    "\n",
    "        for batch_index, batch_dict in enumerate(batch_generator):\n",
    "            # the training routine is these 5 steps:\n",
    "\n",
    "            # --------------------------------------    \n",
    "            # step 1. zero the gradients\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # step 2. compute the output\n",
    "            y_pred = classifier(x=batch_dict['x_data'], x_lengths=batch_dict['x_length'])\n",
    "\n",
    "            # step 3. compute the loss\n",
    "            loss = loss_func(y_pred, batch_dict['y_target'])\n",
    "    \n",
    "            running_loss += (loss.item() - running_loss) / (batch_index + 1)\n",
    "\n",
    "            # step 4. use loss to produce gradients\n",
    "            loss.backward()\n",
    "\n",
    "            # step 5. use optimizer to take gradient step\n",
    "            optimizer.step()\n",
    "            # -----------------------------------------\n",
    "            # compute the accuracy\n",
    "            acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n",
    "            running_acc += (acc_t - running_acc) / (batch_index + 1)\n",
    "\n",
    "        train_state['train_loss'].append(running_loss)\n",
    "        train_state['train_acc'].append(running_acc)\n",
    "\n",
    "        # Iterate over val dataset\\\n",
    "        # setup: batch generator, set loss and acc to 0; set eval mode on\n",
    "\n",
    "        dataset.set_split('val')\n",
    "        batch_generator = generate_batches(dataset, batch_size=len(dataset), device=args.device)\n",
    "        running_loss = 0.\n",
    "        running_acc = 0.\n",
    "        classifier.eval()\n",
    "\n",
    "        for batch_index, batch_dict in enumerate(batch_generator):\n",
    "            # compute the output\n",
    "            y_pred = classifier(x=batch_dict['x_data'], x_lengths=batch_dict['x_length'])\n",
    "\n",
    "            # step 3. compute the loss\n",
    "            loss = loss_func(y_pred, batch_dict['y_target'])\n",
    "            running_loss += (loss.item() - running_loss) / (batch_index + 1)\n",
    "\n",
    "            # compute the accuracy\n",
    "            acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n",
    "            running_acc += (acc_t - running_acc) / (batch_index + 1)\n",
    "\n",
    "        train_state['val_loss'].append(running_loss)\n",
    "        train_state['val_acc'].append(running_acc)\n",
    "        if(best_val['acc']<train_state['val_acc'][-1]):\n",
    "            best_val  = {\n",
    "                'epoch': epoch_index,\n",
    "                'model_state_dict': classifier.state_dict(),\n",
    "                'optimizer_state_dict': optimizer.state_dict(),\n",
    "                'loss': running_loss,\n",
    "                'acc': running_acc,\n",
    "            }\n",
    "            pretty_print(epoch_index, train_state['train_loss'][-1], train_state['train_acc'][-1], train_state['val_loss'][-1], train_state['val_acc'][-1])\n",
    "            lstm_loss_acc_plot['epoch_index'].append(epoch_index)\n",
    "            lstm_loss_acc_plot['val_loss'].append(round(train_state['val_loss'][-1], 4))\n",
    "            lstm_loss_acc_plot['val_acc'].append(round(train_state['val_acc'][-1], 4))\n",
    "            lstm_loss_acc_plot['train_loss'].append(round(train_state['train_loss'][-1], 4))\n",
    "            lstm_loss_acc_plot['train_acc'].append(round(train_state['train_acc'][-1], 4))\n",
    "        train_state = update_train_state(args=args, model=classifier, train_state=train_state)\n",
    "\n",
    "except KeyboardInterrupt:\n",
    "    print(\"Exiting loop\")\n",
    "torch.save(best_val, \"LSTMGlove.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2c700fcf-ca19-4eb8-8ac6-351b8bc95afb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph(lstm_loss_acc_plot,'train_acc', 'val_acc','Accuracy','Accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f232ba53-916a-445e-bf85-db25f09376e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph(lstm_loss_acc_plot, 'train_loss', 'val_loss','Loss','Loss')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2116a7e2-8310-4a04-b846-5642dc567742",
   "metadata": {},
   "source": [
    "The models seems to be overfitting, hence it may impact the models performance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ee05cae2-2786-4a8c-96cb-0b0360a51997",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 1.270143985748291;\n",
      "Test Accuracy: 71.50997150997152\n"
     ]
    }
   ],
   "source": [
    "checkpoint = torch.load(\"LSTMGlove.h5\")\n",
    "classifier.load_state_dict(checkpoint['model_state_dict'])\n",
    "optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
    "classifier.eval()\n",
    "\n",
    "args.device = torch.device(\"cpu\")\n",
    "\n",
    "classifier = classifier.to(args.device)\n",
    "dataset.class_weights = dataset.class_weights.to(args.device)\n",
    "loss_func = nn.CrossEntropyLoss(dataset.class_weights)\n",
    "\n",
    "dataset.set_split('test')\n",
    "\n",
    "batch_generator = generate_batches(dataset, batch_size=len(dataset), device=args.device)\n",
    "running_loss = 0.\n",
    "running_acc = 0.\n",
    "\n",
    "classifier.eval()\n",
    "for batch_index, batch_dict in enumerate(batch_generator):\n",
    "    # compute the output\n",
    "    y_pred =  classifier(batch_dict['x_data'], x_lengths=batch_dict['x_length'])\n",
    "    y_actual = batch_dict['y_target']\n",
    "    \n",
    "    # compute the loss\n",
    "    loss = loss_func(y_pred, batch_dict['y_target'])\n",
    "    loss_t = loss.item()\n",
    "    running_loss += (loss_t - running_loss) / (batch_index + 1)\n",
    "\n",
    "    # compute the accuracy\n",
    "    acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n",
    "    running_acc += (acc_t - running_acc) / (batch_index + 1)\n",
    "\n",
    "train_state['test_loss'] = running_loss\n",
    "train_state['test_acc'] = running_acc\n",
    "print(\"Test loss: {};\".format(train_state['test_loss']))\n",
    "print(\"Test Accuracy: {}\".format(train_state['test_acc']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a4b4be56-8cf9-450b-86af-7db0826dbcaf",
   "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"
    },
    {
     "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": [
    "evaulate_performance(y_pred, y_actual, vectorizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d875382-9879-4f64-9528-45c30a222cf3",
   "metadata": {},
   "source": [
    "The confusion matrix above returns the performance of the Vanilla RNN. From the confusion matrix, we can state the following observations:\n",
    "- The diagonal from the top left to the bottom right represent the true positives. From observation, the model seems to be performing relatively well. Other than the category **Multiple Parts** all other categories have a accuracy rate above 70%. \n",
    "- Low percentage (only 13%) of the categories Multiple Parts has ben correctly identified. The **Arm** category peforms the best with 90% accuracy rate (108 instances correctly identified). "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c24ebb6a-3f3b-4e27-ad9a-299343471764",
   "metadata": {},
   "source": [
    "## Overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "2f1cb38f-c838-4654-9a0b-317347466697",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Train Loss</th>\n",
       "      <th>Train Acc</th>\n",
       "      <th>Val Loss</th>\n",
       "      <th>Val Acc</th>\n",
       "      <th>Test loss</th>\n",
       "      <th>Test Accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Vanilla RNN</th>\n",
       "      <td>0.8123</td>\n",
       "      <td>76.801</td>\n",
       "      <td>0.9252</td>\n",
       "      <td>78.014</td>\n",
       "      <td>1.2309</td>\n",
       "      <td>70.3704</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LSTM</th>\n",
       "      <td>0.3399</td>\n",
       "      <td>90.261</td>\n",
       "      <td>0.8613</td>\n",
       "      <td>78.723</td>\n",
       "      <td>1.2701</td>\n",
       "      <td>71.5099</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Train Loss  Train Acc  Val Loss  Val Acc  Test loss  \\\n",
       "Vanilla RNN      0.8123     76.801    0.9252   78.014     1.2309   \n",
       "LSTM             0.3399     90.261    0.8613   78.723     1.2701   \n",
       "\n",
       "             Test Accuracy  \n",
       "Vanilla RNN        70.3704  \n",
       "LSTM               71.5099  "
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = {'Train Loss':[0.8123 ,0.3399],\n",
    "        'Train Acc':[76.801,90.261],\n",
    "       'Val Loss':[0.9252,0.8613 ],\n",
    "       'Val Acc':[78.014,78.723],\n",
    "       'Test loss':[1.2309,1.2701],\n",
    "       'Test Accuracy':[70.3704,71.5099]}\n",
    "\n",
    "df = pd.DataFrame(data, index=['Vanilla RNN','LSTM'])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a1c44c4-ef67-4b89-bf27-805291e00c05",
   "metadata": {},
   "source": [
    "From the Test Accuracy, we can see that the LSTM performs slightly better than the Vanilla RNN model. Referencing from the LSTM training and validation loss, the model may potentially be overfitting the data hence resulting in a higher test loss score. In terms of accuracy, the LSTM performs better. \n",
    "\n",
    "#### Confusion Matrix\n",
    "- The confusion matrix of the two model tells a different story. If we look at the two matrics, you will notice that the matrix for the LSTM model perform much better than for RNN. \n",
    "- In both models, the categories **Arm, Body, Head** produce the high accuracy rate with **Arm** in lead with 90% for the lstm model and 83% for the vanilla RNN model. \n",
    "- In both models, the category **Multiple Parts** perform the worst. There is a noticable difference for this particular category, as for the RNN model, 18% of the instances are correctly identified, and relatively lower for the RNN at 13%. \n",
    "- There is a severe improvement for the **Leg** categories as there is a massive jump from 71% to 84% of correcntly idenfitied instances, from the RNN to LSRM model, rectrosepctively. \n",
    "- Overvall, there is only small improvements in terms of the classificaiton rate (the performance) for the LSTM over the Vanilla RNN. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2255b4f1-014d-453f-a37e-5b41bca5d743",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Bonus | GRU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4ddaf987-bfbd-4ddd-a4d1-7b3de5340e6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GruRNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, batch_first=True):\n",
    "        super(GruRNN, self).__init__()\n",
    "        \n",
    "        self.lstm = nn.GRU(input_size, hidden_size,num_layers=1, batch_first=batch_first) \n",
    "        self.hidden_size = hidden_size\n",
    "        self.batch_first = batch_first\n",
    "        \n",
    "    def forward(self, x):\n",
    "        if self.batch_first:\n",
    "            batch_first_output, self.hidden = self.lstm(x)\n",
    "        else:\n",
    "            batch_first_output, self.hidden = self.lstm(x)\n",
    "        return batch_first_output[:, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "86eb63fc-032c-4447-91a6-9e301936477f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GRU_Model(nn.Module):\n",
    "    def __init__(self, embedding_size, num_embeddings, num_classes, rnn_hidden_size, hidden_dim, RNN=True, pretrained_embeddings=None, padding_idx=0, batch_first=True):\n",
    "        super(GRU_Model, self).__init__()\n",
    "\n",
    "        self.emb = nn.Embedding(embedding_dim=embedding_size, num_embeddings=num_embeddings, padding_idx=padding_idx) \n",
    "\n",
    "        self.rnn = GruRNN(input_size=embedding_size, hidden_size=rnn_hidden_size, batch_first=batch_first)\n",
    "\n",
    "        \n",
    "        self.RNN = RNN\n",
    "        self.num_classes = num_classes\n",
    "        self.rnn_hidden_size = rnn_hidden_size\n",
    "        #MLP         \n",
    "        self.fc1 = nn.Linear(rnn_hidden_size, hidden_dim[0])\n",
    "        self.relu1 = nn.ReLU()\n",
    "        self.dropout1 = nn.Dropout(0.1)\n",
    "\n",
    "        self.fc2 = nn.Linear(hidden_dim[0], hidden_dim[1])\n",
    "        self.relu2 = nn.ReLU()\n",
    "\n",
    "        self.fc3 = nn.Linear(hidden_dim[1], num_classes)\n",
    "\n",
    "    def forward(self, x, x_lengths=None, apply_softmax=False):\n",
    "        # embed and permute so features are channels\n",
    "        out = self.emb(x)\n",
    "        out = self.rnn(out)\n",
    "\n",
    "        \n",
    "        if self.RNN:\n",
    "            if x_lengths is not None:\n",
    "                out = column_gather(out, x_lengths)\n",
    "            else:\n",
    "                out = out[:, -1, :]\n",
    "\n",
    "        out = self.fc1(out)\n",
    "        out = self.relu1(out)\n",
    "        out = self.dropout1(out)\n",
    "        \n",
    "        out = self.fc2(out)\n",
    "        out = self.relu2(out)\n",
    "        \n",
    "        out = self.fc3(out)\n",
    "\n",
    "        if apply_softmax:\n",
    "            out = torch.nn.functional.softmax(out, dim=1)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "96c4d75a-b45f-4210-9e42-ff4384846c5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier = GRU_Model(\n",
    "    embedding_size=embedding_size, \n",
    "    num_embeddings=len(vectorizer.NARRATIVE_vocab),\n",
    "    num_classes=len(vectorizer.target_vocab),\n",
    "    rnn_hidden_size=256,\n",
    "    hidden_dim = [128, 64],\n",
    "    padding_idx=vectorizer.NARRATIVE_vocab.mask_index,\n",
    "    pretrained_embeddings=embeddings,\n",
    "    RNN=False\n",
    ")\n",
    "args.device = torch.device(\"cuda\" if args.cuda else \"cpu\")\n",
    "set_seed_everywhere(args.seed, args.cuda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "6d6ad158-4ad5-4d08-b3a8-0bf09d6115e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs: 000 | Train loss 1.6117 Train acc 16.389 Val loss 1.6091 Val acc 21.985\n",
      "Epochs: 003 | Train loss 1.6076 Train acc 21.536 Val loss 1.6050 Val acc 22.695\n",
      "Epochs: 004 | Train loss 1.6063 Train acc 21.773 Val loss 1.6037 Val acc 24.113\n",
      "Epochs: 005 | Train loss 1.6045 Train acc 20.902 Val loss 1.6024 Val acc 25.531\n",
      "Epochs: 006 | Train loss 1.6030 Train acc 22.723 Val loss 1.6012 Val acc 29.078\n",
      "Epochs: 009 | Train loss 1.5985 Train acc 28.107 Val loss 1.5967 Val acc 29.787\n",
      "Epochs: 012 | Train loss 1.5931 Train acc 32.304 Val loss 1.5910 Val acc 32.624\n",
      "Epochs: 013 | Train loss 1.5910 Train acc 34.283 Val loss 1.5889 Val acc 35.460\n",
      "Epochs: 014 | Train loss 1.5881 Train acc 34.204 Val loss 1.5865 Val acc 36.170\n",
      "Epochs: 016 | Train loss 1.5837 Train acc 36.896 Val loss 1.5812 Val acc 39.007\n",
      "Epochs: 017 | Train loss 1.5799 Train acc 38.796 Val loss 1.5782 Val acc 41.843\n",
      "Epochs: 019 | Train loss 1.5730 Train acc 41.488 Val loss 1.5717 Val acc 43.971\n",
      "Epochs: 020 | Train loss 1.5701 Train acc 40.775 Val loss 1.5680 Val acc 44.680\n",
      "Epochs: 021 | Train loss 1.5665 Train acc 43.863 Val loss 1.5640 Val acc 46.099\n",
      "Epochs: 027 | Train loss 1.5340 Train acc 46.080 Val loss 1.5334 Val acc 46.808\n",
      "Epochs: 028 | Train loss 1.5280 Train acc 47.189 Val loss 1.5269 Val acc 47.517\n",
      "Epochs: 033 | Train loss 1.4864 Train acc 52.731 Val loss 1.4870 Val acc 48.226\n",
      "Epochs: 035 | Train loss 1.4652 Train acc 52.810 Val loss 1.4674 Val acc 48.936\n",
      "Epochs: 036 | Train loss 1.4517 Train acc 53.998 Val loss 1.4567 Val acc 50.354\n",
      "Epochs: 037 | Train loss 1.4394 Train acc 55.977 Val loss 1.4455 Val acc 51.063\n",
      "Epochs: 038 | Train loss 1.4236 Train acc 56.848 Val loss 1.4338 Val acc 51.773\n",
      "Epochs: 052 | Train loss 1.1355 Train acc 65.716 Val loss 1.2354 Val acc 53.191\n",
      "Epochs: 053 | Train loss 1.1096 Train acc 66.508 Val loss 1.2203 Val acc 53.900\n",
      "Epochs: 054 | Train loss 1.0891 Train acc 66.270 Val loss 1.2008 Val acc 54.609\n",
      "Epochs: 055 | Train loss 1.0594 Train acc 67.695 Val loss 1.1840 Val acc 56.028\n",
      "Epochs: 056 | Train loss 1.0398 Train acc 68.171 Val loss 1.1652 Val acc 58.156\n",
      "Epochs: 057 | Train loss 1.0087 Train acc 69.358 Val loss 1.1459 Val acc 59.574\n",
      "Epochs: 058 | Train loss 0.9829 Train acc 69.596 Val loss 1.1274 Val acc 63.120\n",
      "Epochs: 059 | Train loss 0.9546 Train acc 70.942 Val loss 1.1097 Val acc 63.829\n",
      "Epochs: 061 | Train loss 0.9002 Train acc 72.921 Val loss 1.0758 Val acc 64.539\n",
      "Epochs: 062 | Train loss 0.8722 Train acc 72.129 Val loss 1.0622 Val acc 67.375\n",
      "Epochs: 063 | Train loss 0.8478 Train acc 73.792 Val loss 1.0514 Val acc 68.085\n",
      "Epochs: 064 | Train loss 0.8188 Train acc 74.425 Val loss 1.0417 Val acc 68.794\n",
      "Epochs: 067 | Train loss 0.7444 Train acc 76.563 Val loss 1.0236 Val acc 69.503\n",
      "Epochs: 070 | Train loss 0.6716 Train acc 78.543 Val loss 1.0248 Val acc 70.212\n",
      "Epochs: 071 | Train loss 0.6538 Train acc 79.651 Val loss 1.0193 Val acc 72.340\n",
      "Epochs: 074 | Train loss 0.5820 Train acc 82.026 Val loss 1.0196 Val acc 73.049\n",
      "Epochs: 075 | Train loss 0.5600 Train acc 81.551 Val loss 1.0182 Val acc 73.758\n",
      "Epochs: 076 | Train loss 0.5408 Train acc 81.947 Val loss 1.0160 Val acc 75.177\n",
      "Epochs: 078 | Train loss 0.4992 Train acc 84.006 Val loss 1.0161 Val acc 76.595\n",
      "Epochs: 082 | Train loss 0.4333 Train acc 85.510 Val loss 1.0282 Val acc 78.014\n",
      "Epochs: 089 | Train loss 0.3314 Train acc 89.548 Val loss 1.0906 Val acc 78.723\n",
      "Epochs: 098 | Train loss 0.2164 Train acc 92.953 Val loss 1.1804 Val acc 79.432\n",
      "Epochs: 129 | Train loss 0.0357 Train acc 99.524 Val loss 1.5223 Val acc 80.141\n",
      "Epochs: 143 | Train loss 0.0174 Train acc 99.841 Val loss 1.6340 Val acc 80.851\n",
      "Epochs: 149 | Train loss 0.0113 Train acc 99.920 Val loss 1.6721 Val acc 81.560\n"
     ]
    }
   ],
   "source": [
    "classifier = classifier.to(args.device)\n",
    "dataset.class_weights = dataset.class_weights.to(args.device)\n",
    "    \n",
    "loss_func = nn.CrossEntropyLoss(weight=dataset.class_weights)\n",
    "optimizer = optim.Adam(classifier.parameters(), lr=args.learning_rate)\n",
    "\n",
    "train_state = make_train_state(args)\n",
    "\n",
    "best_val  = {\n",
    "    'epoch': 0,\n",
    "    'model_state_dict': 0,\n",
    "    'optimizer_state_dict': 0,\n",
    "    'loss': 0,\n",
    "    'acc':0\n",
    "}\n",
    "\n",
    "try:\n",
    "    for epoch_index in range(args.num_epoch):\n",
    "        train_state['epoch_index'] = epoch_index\n",
    "\n",
    "        # Iterate over training dataset\n",
    "        # setup: batch generator, set loss and acc to 0, set train mode on\n",
    "        dataset.set_split('train')\n",
    "        batch_generator = generate_batches(dataset, batch_size=len(dataset), device=args.device)\n",
    "        running_loss = 0.0\n",
    "        running_acc = 0.0\n",
    "        classifier.train()\n",
    "\n",
    "        for batch_index, batch_dict in enumerate(batch_generator):\n",
    "            # the training routine is these 5 steps:\n",
    "\n",
    "            # --------------------------------------    \n",
    "            # step 1. zero the gradients\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # step 2. compute the output\n",
    "            y_pred = classifier(x=batch_dict['x_data'], x_lengths=batch_dict['x_length'])\n",
    "\n",
    "            # step 3. compute the loss\n",
    "            loss = loss_func(y_pred, batch_dict['y_target'])\n",
    "    \n",
    "            running_loss += (loss.item() - running_loss) / (batch_index + 1)\n",
    "\n",
    "            # step 4. use loss to produce gradients\n",
    "            loss.backward()\n",
    "\n",
    "            # step 5. use optimizer to take gradient step\n",
    "            optimizer.step()\n",
    "            # -----------------------------------------\n",
    "            # compute the accuracy\n",
    "            acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n",
    "            running_acc += (acc_t - running_acc) / (batch_index + 1)\n",
    "\n",
    "        train_state['train_loss'].append(running_loss)\n",
    "        train_state['train_acc'].append(running_acc)\n",
    "\n",
    "        # Iterate over val dataset\\\n",
    "        # setup: batch generator, set loss and acc to 0; set eval mode on\n",
    "\n",
    "        dataset.set_split('val')\n",
    "        batch_generator = generate_batches(dataset, batch_size=len(dataset), device=args.device)\n",
    "        running_loss = 0.\n",
    "        running_acc = 0.\n",
    "        classifier.eval()\n",
    "\n",
    "        for batch_index, batch_dict in enumerate(batch_generator):\n",
    "            # compute the output\n",
    "            y_pred = classifier(x=batch_dict['x_data'], x_lengths=batch_dict['x_length'])\n",
    "\n",
    "            # step 3. compute the loss\n",
    "            loss = loss_func(y_pred, batch_dict['y_target'])\n",
    "            running_loss += (loss.item() - running_loss) / (batch_index + 1)\n",
    "\n",
    "            # compute the accuracy\n",
    "            acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n",
    "            running_acc += (acc_t - running_acc) / (batch_index + 1)\n",
    "\n",
    "        train_state['val_loss'].append(running_loss)\n",
    "        train_state['val_acc'].append(running_acc)\n",
    "        if(best_val['acc']<train_state['val_acc'][-1]):\n",
    "            best_val  = {\n",
    "                'epoch': epoch_index,\n",
    "                'model_state_dict': classifier.state_dict(),\n",
    "                'optimizer_state_dict': optimizer.state_dict(),\n",
    "                'loss': running_loss,\n",
    "                'acc': running_acc,\n",
    "            }\n",
    "            pretty_print(epoch_index, train_state['train_loss'][-1], train_state['train_acc'][-1], train_state['val_loss'][-1], train_state['val_acc'][-1])\n",
    "            \n",
    "        train_state = update_train_state(args=args, model=classifier, train_state=train_state)\n",
    "\n",
    "except KeyboardInterrupt:\n",
    "    print(\"Exiting loop\")\n",
    "torch.save(best_val, \"GRUGlove.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "3272f1c6-70c2-4f65-88cc-00c568b37d39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 1.6799514293670654;\n",
      "Test Accuracy: 76.63817663817663\n"
     ]
    }
   ],
   "source": [
    "args.device = torch.device(\"cpu\")\n",
    "checkpoint = torch.load(\"GRUGlove.h5\")\n",
    "classifier.load_state_dict(checkpoint['model_state_dict'])\n",
    "optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
    "classifier.eval()\n",
    "\n",
    "classifier = classifier.to(args.device)\n",
    "dataset.class_weights = dataset.class_weights.to(args.device)\n",
    "loss_func = nn.CrossEntropyLoss(dataset.class_weights)\n",
    "\n",
    "dataset.set_split('test')\n",
    "\n",
    "batch_generator = generate_batches(dataset, batch_size=len(dataset), device=args.device)\n",
    "running_loss = 0.\n",
    "running_acc = 0.\n",
    "\n",
    "classifier.eval()\n",
    "for batch_index, batch_dict in enumerate(batch_generator):\n",
    "    # compute the output\n",
    "    y_pred =  classifier(batch_dict['x_data'], x_lengths=batch_dict['x_length'])\n",
    "    y_actual = batch_dict['y_target']\n",
    "    \n",
    "    # compute the loss\n",
    "    loss = loss_func(y_pred, batch_dict['y_target'])\n",
    "    loss_t = loss.item()\n",
    "    running_loss += (loss_t - running_loss) / (batch_index + 1)\n",
    "\n",
    "    # compute the accuracy\n",
    "    acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n",
    "    running_acc += (acc_t - running_acc) / (batch_index + 1)\n",
    "\n",
    "train_state['test_loss'] = running_loss\n",
    "train_state['test_acc'] = running_acc\n",
    "print(\"Test loss: {};\".format(train_state['test_loss']))\n",
    "print(\"Test Accuracy: {}\".format(train_state['test_acc']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "076bfb41-f728-4dd1-8363-5f8a79b50392",
   "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"
    },
    {
     "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": [
    "evaulate_performance(y_pred, y_actual, vectorizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a0aca57-367c-4262-8a1b-012af933bf9c",
   "metadata": {},
   "source": [
    "Add a "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f7febf5a-b2b4-4579-9cb2-ae87c8c52e18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Arm', 'Body', 'Head', 'Leg', 'Multiple Parts')"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vectorizer.target_vocab.lookup_index(0), vectorizer.target_vocab.lookup_index(1), vectorizer.target_vocab.lookup_index(2), vectorizer.target_vocab.lookup_index(3), vectorizer.target_vocab.lookup_index(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0a45cfe-0232-415f-a82d-b9d5bf446514",
   "metadata": {},
   "source": [
    "# Conclustion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed9e06b5-2ae6-4887-a5d9-79f90f31dcf3",
   "metadata": {},
   "source": [
    "We can see the model performance of `LSTM` performance is lower than Basic `RNN` and `GRN`\n",
    "\n",
    "As shown in the table below, GRU has a test accuracy of 76.64% with a test loss of 1.68. I believe out of the three models, depite the high accuracy achieve by the GRU model, the Vanilla RNN produces the best results due to its lower test loss. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "8c8ec021-a779-4968-b93a-bf1d29e4bddd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Train Loss</th>\n",
       "      <th>Train Acc</th>\n",
       "      <th>Val Loss</th>\n",
       "      <th>Val Acc</th>\n",
       "      <th>Test loss</th>\n",
       "      <th>Test Accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Vanilla RNN</th>\n",
       "      <td>0.8123</td>\n",
       "      <td>76.801</td>\n",
       "      <td>0.9252</td>\n",
       "      <td>78.014</td>\n",
       "      <td>1.2309</td>\n",
       "      <td>70.3704</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LSTM</th>\n",
       "      <td>0.3399</td>\n",
       "      <td>90.261</td>\n",
       "      <td>0.8613</td>\n",
       "      <td>78.723</td>\n",
       "      <td>1.2701</td>\n",
       "      <td>71.5099</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>GRU</th>\n",
       "      <td>0.0113</td>\n",
       "      <td>99.920</td>\n",
       "      <td>1.6721</td>\n",
       "      <td>81.560</td>\n",
       "      <td>1.6800</td>\n",
       "      <td>76.6382</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Train Loss  Train Acc  Val Loss  Val Acc  Test loss  \\\n",
       "Vanilla RNN      0.8123     76.801    0.9252   78.014     1.2309   \n",
       "LSTM             0.3399     90.261    0.8613   78.723     1.2701   \n",
       "GRU              0.0113     99.920    1.6721   81.560     1.6800   \n",
       "\n",
       "             Test Accuracy  \n",
       "Vanilla RNN        70.3704  \n",
       "LSTM               71.5099  \n",
       "GRU                76.6382  "
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = {'Train Loss':[0.8123 ,0.3399, 0.0113],\n",
    "        'Train Acc':[76.801,90.261, 99.920],\n",
    "       'Val Loss':[0.9252,0.8613, 1.6721 ],\n",
    "       'Val Acc':[78.014,78.723,81.560 ],\n",
    "       'Test loss':[1.2309,1.2701, 1.6800],\n",
    "       'Test Accuracy':[70.3704,71.5099,76.6382 ]}\n",
    "\n",
    "df = pd.DataFrame(data, index=['Vanilla RNN','LSTM', 'GRU'])\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "519cd857-8c36-4c68-8bb1-a4271a5f552f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}