baseline.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "Verbose = False\n",
    "if Verbose:\n",
    "    def vprint(*args, **kwargs): print(*args, **kwargs, flush=True)\n",
    "else: # do-nothing function\n",
    "    def vprint(*args, **kwargs): None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "pd.set_option(\"display.width\", 380)\n",
    "pd.set_option('max_colwidth', 100)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from IPython.display import display\n",
    "\n",
    "device = torch.device('cuda:1' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load the sentences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df_train = pd.read_csv(\"./sick_train/SICK_train.txt\", sep=\"\\t\")\n",
    "df_train = df_train.drop(['relatedness_score'], axis=1)\n",
    "\n",
    "df_dev = pd.read_csv(\"./sick_trial/SICK_trial.txt\", sep=\"\\t\")\n",
    "df_dev = df_dev.drop(['relatedness_score'], axis=1)\n",
    "\n",
    "df_test = pd.read_csv(\"./sick_test/SICK_test.txt\", sep=\"\\t\")\n",
    "df_test = df_test.drop(['relatedness_score'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data.dataloader import DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gensim import corpora"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "class SickDataset(Dataset):\n",
    "    endOfSentence   = '</s>'\n",
    "    startOfSentence = '<s>'\n",
    "    separator2Sentences = '<sep>'\n",
    "    \n",
    "    text_label = [\"NEUTRAL\", \"ENTAILMENT\", \"CONTRADICTION\"]\n",
    "    \n",
    "    tokens = [startOfSentence, separator2Sentences, endOfSentence]\n",
    "    \n",
    "    def join_sentence(self, row):\n",
    "        \"\"\"\n",
    "        Create a new sentence (<s> + s_A + <sep> + s_B + </s>)\n",
    "        \"\"\"\n",
    "        sentence_a = row['sentence_A'].split(\" \")\n",
    "        sentence_b = row['sentence_B'].split(\" \")\n",
    "        return np.concatenate((\n",
    "            [self.startOfSentence],\n",
    "            sentence_a,\n",
    "            [self.separator2Sentences],\n",
    "            sentence_b,\n",
    "            [self.endOfSentence]\n",
    "        ))\n",
    "    \n",
    "    def series_text_2_labelID(self, series, keep_n=1000):\n",
    "        \"\"\"\n",
    "        Convert text Label into label id\n",
    "        \"\"\"\n",
    "        reverse_dict = {v: k for k, v in  dict(enumerate(self.text_label)).items()}\n",
    "        return series.map(reverse_dict)\n",
    "    \n",
    "    def series_2_dict(self, series, keep_n):\n",
    "        \"\"\"\n",
    "        Convert document (a list of words) into a list of indexes\n",
    "        AND apply some filter on the documents\n",
    "        \"\"\"\n",
    "        dictionary = corpora.Dictionary(series)\n",
    "        dictionary.filter_extremes(\n",
    "            no_below=1,\n",
    "            no_above=1,\n",
    "            keep_n=keep_n,\n",
    "            keep_tokens=self.tokens)\n",
    "        return dictionary\n",
    "    \n",
    "    \n",
    "    def __init__(self, df, vocabulary_size, dic=None):\n",
    "        self.vocabulary_size = vocabulary_size\n",
    "        \n",
    "        # Label text as ids\n",
    "        df[\"entailment_id\"] = self.series_text_2_labelID(df['entailment_judgment'])\n",
    "        \n",
    "        # Add <s>,</s>,<sep> tokens to the vocabulary\n",
    "        df['sentence_AB'] = df.apply(self.join_sentence, axis=1)\n",
    "        \n",
    "        # check if the dictionary is given\n",
    "        if dic is None:\n",
    "            # Create the Dictionary\n",
    "            self.dictionary = self.series_2_dict(df['sentence_AB'], vocabulary_size)\n",
    "        else:\n",
    "            self.dictionary = dic\n",
    "        \n",
    "        # sentence of words -> array of idx\n",
    "        # Adds unknown to the voc (idx = len(dictionary)), len(dictionary) = vocabulary_size\n",
    "        # Adds one to each (no tokens at 0, even <unk>)\n",
    "        # 0 is for the padding when using mini-batch\n",
    "        df[\"word_idx\"] = df[\"sentence_AB\"].apply(\n",
    "            lambda word: np.array(self.dictionary.doc2idx(word, unknown_word_index=vocabulary_size)) + 1\n",
    "        )\n",
    "        \n",
    "        self.df = df\n",
    "\n",
    "        # compute a sorted occurence dictionary on the whole corpus\n",
    "        occ_dict = {}\n",
    "        for serie in df['sentence_AB']:\n",
    "            unique, counts = np.unique(serie, return_counts=True)\n",
    "            tmp_dict = dict(zip(unique, counts))\n",
    "            \n",
    "            for key, value in tmp_dict.items():\n",
    "                if key in occ_dict:\n",
    "                    occ_dict[key] = occ_dict[key] + tmp_dict[key]\n",
    "                else:\n",
    "                    occ_dict[key] = value\n",
    "        \n",
    "        self.occ_dict_list = [[key, value] for key, value in occ_dict.items()]\n",
    "        self.occ_dict_list.sort(key=lambda x: x[1], reverse=True)\n",
    "        \n",
    "    def getSortedOccDictList(self):\n",
    "        return self.occ_dict_list\n",
    "    \n",
    "    def plotVocabularyCoverage(self):\n",
    "        occdict_list = self.occ_dict_list\n",
    "        \n",
    "        total = 0\n",
    "        y = []\n",
    "        for i, value in enumerate(occdict_list):\n",
    "            total += value[1]\n",
    "            y.append(total)\n",
    "            if (i == self.vocabulary_size):\n",
    "                current_voc_cov = total\n",
    "\n",
    "        current_voc_cov = current_voc_cov*100.0/total\n",
    "        \n",
    "        y = [tmp*100.0/total for tmp in y]\n",
    "\n",
    "        x = np.linspace(0, len(occdict_list), len(occdict_list))\n",
    "\n",
    "        # Show graph\n",
    "        fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "        fig_size[0] = 20\n",
    "        fig_size[1] = 9\n",
    "        plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "\n",
    "        legend, = plt.plot(x, y, label='Vocabulary size ')\n",
    "\n",
    "        plt.title(('Current vocabulary size n=' + str(self.vocabulary_size) + ' coverage = ' +\"{:.4}\".format(current_voc_cov) + '%'),\n",
    "                     fontsize=14, fontweight='bold', color='gray')\n",
    "        plt.suptitle(('Vocabulary coverage'),\n",
    "                     fontsize=24, fontweight='bold', color='gray')\n",
    "        plt.xlabel(\"Size of unique vocabulary\", color='gray', fontsize=14)\n",
    "        plt.ylabel(\"Vocabulary coverage %\", color='gray', fontsize=14)\n",
    "\n",
    "        ## Plot Swagg ##\n",
    "        plt.yticks(fontsize=14, rotation=0, color='gray')\n",
    "        plt.xticks(fontsize=14, rotation=0, color='gray')\n",
    "\n",
    "        # Less border\n",
    "        plt.gca().xaxis.grid(True)\n",
    "        plt.gca().yaxis.grid(True)\n",
    "        plt.gca().spines['top'].set_visible(False)\n",
    "        plt.gca().spines['right'].set_visible(False)\n",
    "        plt.gca().spines['left'].set_visible(False)\n",
    "        plt.gca().spines['bottom'].set_visible(False)\n",
    "        plt.show()\n",
    "        \n",
    "    def getRef(self, index):\n",
    "        return self.df['sentence_AB'][index]\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        return (\n",
    "            self.df['word_idx'][index],\n",
    "            self.df['entailment_id'][index])\n",
    "    \n",
    "    def getDictionary(self):\n",
    "        return self.dictionary\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.df)\n",
    "\n",
    "    \n",
    "vocabulary_size = 1500"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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>pair_ID</th>\n",
       "      <th>sentence_A</th>\n",
       "      <th>sentence_B</th>\n",
       "      <th>entailment_judgment</th>\n",
       "      <th>entailment_id</th>\n",
       "      <th>sentence_AB</th>\n",
       "      <th>word_idx</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>A group of kids is playing in a yard and an old man is standing in the background</td>\n",
       "      <td>A group of boys in a yard is playing and a man is standing in the background</td>\n",
       "      <td>NEUTRAL</td>\n",
       "      <td>0</td>\n",
       "      <td>[&lt;s&gt;, A, group, of, kids, is, playing, in, a, yard, and, an, old, man, is, standing, in, the, ba...</td>\n",
       "      <td>[2, 4, 10, 15, 13, 12, 17, 11, 5, 20, 7, 6, 16, 14, 12, 18, 11, 19, 8, 3, 4, 10, 15, 9, 11, 5, 2...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>A group of children is playing in the house and there is no man standing in the background</td>\n",
       "      <td>A group of kids is playing in a yard and an old man is standing in the background</td>\n",
       "      <td>NEUTRAL</td>\n",
       "      <td>0</td>\n",
       "      <td>[&lt;s&gt;, A, group, of, children, is, playing, in, the, house, and, there, is, no, man, standing, in...</td>\n",
       "      <td>[2, 4, 10, 15, 21, 12, 17, 11, 19, 22, 7, 24, 12, 23, 14, 18, 11, 19, 8, 3, 4, 10, 15, 13, 12, 1...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>The young boys are playing outdoors and the man is smiling nearby</td>\n",
       "      <td>The kids are playing outdoors near a man with a smile</td>\n",
       "      <td>ENTAILMENT</td>\n",
       "      <td>1</td>\n",
       "      <td>[&lt;s&gt;, The, young, boys, are, playing, outdoors, and, the, man, is, smiling, nearby, &lt;sep&gt;, The, ...</td>\n",
       "      <td>[2, 25, 32, 9, 26, 17, 28, 7, 19, 14, 12, 30, 1501, 3, 25, 13, 26, 17, 28, 27, 5, 14, 31, 5, 29, 1]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5</td>\n",
       "      <td>The kids are playing outdoors near a man with a smile</td>\n",
       "      <td>A group of kids is playing in a yard and an old man is standing in the background</td>\n",
       "      <td>NEUTRAL</td>\n",
       "      <td>0</td>\n",
       "      <td>[&lt;s&gt;, The, kids, are, playing, outdoors, near, a, man, with, a, smile, &lt;sep&gt;, A, group, of, kids...</td>\n",
       "      <td>[2, 25, 13, 26, 17, 28, 27, 5, 14, 31, 5, 29, 3, 4, 10, 15, 13, 12, 17, 11, 5, 20, 7, 6, 16, 14,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>9</td>\n",
       "      <td>The young boys are playing outdoors and the man is smiling nearby</td>\n",
       "      <td>A group of kids is playing in a yard and an old man is standing in the background</td>\n",
       "      <td>NEUTRAL</td>\n",
       "      <td>0</td>\n",
       "      <td>[&lt;s&gt;, The, young, boys, are, playing, outdoors, and, the, man, is, smiling, nearby, &lt;sep&gt;, A, gr...</td>\n",
       "      <td>[2, 25, 32, 9, 26, 17, 28, 7, 19, 14, 12, 30, 1501, 3, 4, 10, 15, 13, 12, 17, 11, 5, 20, 7, 6, 1...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   pair_ID                                                                                  sentence_A                                                                         sentence_B entailment_judgment  entailment_id                                                                                          sentence_AB  \\\n",
       "0        1           A group of kids is playing in a yard and an old man is standing in the background       A group of boys in a yard is playing and a man is standing in the background             NEUTRAL              0  [<s>, A, group, of, kids, is, playing, in, a, yard, and, an, old, man, is, standing, in, the, ba...   \n",
       "1        2  A group of children is playing in the house and there is no man standing in the background  A group of kids is playing in a yard and an old man is standing in the background             NEUTRAL              0  [<s>, A, group, of, children, is, playing, in, the, house, and, there, is, no, man, standing, in...   \n",
       "2        3                           The young boys are playing outdoors and the man is smiling nearby                              The kids are playing outdoors near a man with a smile          ENTAILMENT              1  [<s>, The, young, boys, are, playing, outdoors, and, the, man, is, smiling, nearby, <sep>, The, ...   \n",
       "3        5                                       The kids are playing outdoors near a man with a smile  A group of kids is playing in a yard and an old man is standing in the background             NEUTRAL              0  [<s>, The, kids, are, playing, outdoors, near, a, man, with, a, smile, <sep>, A, group, of, kids...   \n",
       "4        9                           The young boys are playing outdoors and the man is smiling nearby  A group of kids is playing in a yard and an old man is standing in the background             NEUTRAL              0  [<s>, The, young, boys, are, playing, outdoors, and, the, man, is, smiling, nearby, <sep>, A, gr...   \n",
       "\n",
       "                                                                                              word_idx  \n",
       "0  [2, 4, 10, 15, 13, 12, 17, 11, 5, 20, 7, 6, 16, 14, 12, 18, 11, 19, 8, 3, 4, 10, 15, 9, 11, 5, 2...  \n",
       "1  [2, 4, 10, 15, 21, 12, 17, 11, 19, 22, 7, 24, 12, 23, 14, 18, 11, 19, 8, 3, 4, 10, 15, 13, 12, 1...  \n",
       "2  [2, 25, 32, 9, 26, 17, 28, 7, 19, 14, 12, 30, 1501, 3, 25, 13, 26, 17, 28, 27, 5, 14, 31, 5, 29, 1]  \n",
       "3  [2, 25, 13, 26, 17, 28, 27, 5, 14, 31, 5, 29, 3, 4, 10, 15, 13, 12, 17, 11, 5, 20, 7, 6, 16, 14,...  \n",
       "4  [2, 25, 32, 9, 26, 17, 28, 7, 19, 14, 12, 30, 1501, 3, 4, 10, 15, 13, 12, 17, 11, 5, 20, 7, 6, 1...  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the train dataset\n",
    "sick_dataset_train = SickDataset(df_train, vocabulary_size)\n",
    "sick_dataset_train.df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the dev dataset\n",
    "dictionary_train = sick_dataset_train.getDictionary()\n",
    "\n",
    "sick_dataset_dev = SickDataset(df_dev, vocabulary_size, dictionary_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the test dataset\n",
    "sick_dataset_test = SickDataset(df_test, vocabulary_size, dictionary_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>the</td>\n",
       "      <td>man</td>\n",
       "      <td>in</td>\n",
       "      <td>pants</td>\n",
       "      <td>&lt;sep&gt;</td>\n",
       "      <td>Two</td>\n",
       "      <td>dogs</td>\n",
       "      <td>are</td>\n",
       "      <td>fighting</td>\n",
       "      <td>&lt;/s&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>25</td>\n",
       "      <td>32</td>\n",
       "      <td>9</td>\n",
       "      <td>26</td>\n",
       "      <td>17</td>\n",
       "      <td>28</td>\n",
       "      <td>7</td>\n",
       "      <td>19</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1   2      3      4    5     6    7         8     9\n",
       "0  the  man  in  pants  <sep>  Two  dogs  are  fighting  </s>\n",
       "1    2   25  32      9     26   17    28    7        19    14"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(list(zip(sick_dataset_train.getRef(6)[-10:], sick_dataset_train[2][0]))).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "dark"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sick_dataset_train.plotVocabularyCoverage()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pretrained embeddings\n",
    "https://medium.com/@martinpella/how-to-use-pre-trained-word-embeddings-in-pytorch-71ca59249f76  \n",
    "For each word in dataset’s vocabulary, we check if it is on GloVe’s vocabulary. If it do it, we load its pre-trained word vector. Otherwise, we initialize a random vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "EMBEDDINGS_SIZE = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1398 102\n",
      "Downloaded: Pretained Embedding matrix: torch.Size([400000, 50])\n",
      "Adapted:    Pretained Embedding matrix: torch.Size([1502, 50])\n"
     ]
    }
   ],
   "source": [
    "from torchtext import vocab\n",
    "#vocab is shared across all the text fields\n",
    "#CAUTION: GloVe will download all embeddings locally (862 MB).\n",
    "pretrained_emb = vocab.GloVe(name='6B', dim=EMBEDDINGS_SIZE)\n",
    "\n",
    "# 0 is for the padding when using mini-batch (start at one, shift by one)\n",
    "weights_matrix = np.zeros((vocabulary_size + 2, EMBEDDINGS_SIZE)) # do not forget the unk\n",
    "\n",
    "found = 0\n",
    "no_found = 0\n",
    "# build a matrix of weights that will be loaded into the PyTorch embedding layer\n",
    "for word_id in sick_dataset_train.dictionary:\n",
    "    word = sick_dataset_train.dictionary[word_id]\n",
    "    if word in pretrained_emb.stoi:\n",
    "        pretrained_emb_ID = pretrained_emb.stoi[word]\n",
    "        \n",
    "        weights_matrix[word_id+1] = pretrained_emb.vectors[pretrained_emb_ID]\n",
    "        found += 1\n",
    "    else:\n",
    "        weights_matrix[word_id+1] = np.random.normal(scale=0.6, size=(EMBEDDINGS_SIZE, ))\n",
    "        no_found += 1\n",
    "        \n",
    "# UNK\n",
    "weights_matrix[vocabulary_size+1] = np.random.normal(scale=0.6, size=(EMBEDDINGS_SIZE, ))\n",
    "\n",
    "print(found, no_found)\n",
    "        \n",
    "pretrained_emb_vec = torch.tensor(weights_matrix, dtype=torch.float32)\n",
    "print(\"Downloaded: Pretained Embedding matrix: \" +  str(pretrained_emb.vectors.size()))\n",
    "print(\"Adapted:    Pretained Embedding matrix: \" +  str(pretrained_emb_vec.size()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[18, 24]\n",
      "standing\n",
      "tensor([-0.4088,  0.6761,  0.0735, -0.1806,  1.2443, -0.0917,  0.0386,  0.1979,\n",
      "        -0.0458, -1.1083, -0.5975, -0.3853, -0.3361,  0.3328, -0.1278, -0.0295,\n",
      "        -0.1130,  0.0644,  0.1915, -0.9226, -0.2098,  0.3553, -0.1223, -0.5348,\n",
      "         0.4177, -1.4884,  0.2423,  0.5807, -0.2651,  0.1545,  2.7154,  0.3619,\n",
      "         0.0442, -0.1549, -0.6539,  0.1046,  0.1774,  0.1194, -0.4762, -0.1801,\n",
      "        -0.6075, -0.2769, -0.3217,  0.6482,  0.0115, -0.3640, -0.4810, -0.6800,\n",
      "        -0.1294, -0.7417])\n"
     ]
    }
   ],
   "source": [
    "print(sick_dataset_train.dictionary.doc2idx([\"the\", \"The\"]))\n",
    "print(sick_dataset_train.dictionary[17])\n",
    "print(pretrained_emb_vec[17+1])\n",
    "# Glove dim=50 word=the vector[:4] = 0.418 0.24968 -0.41242 0.1217"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# To DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pad_collate(batch):\n",
    "    seqs_labels = np.array(batch)[:,1]\n",
    "    \n",
    "    vectorized_seqs = np.array(batch)[:,0]\n",
    "    seq_lengths = torch.LongTensor([len(x) for x in vectorized_seqs])\n",
    "    \n",
    "    seq_tensor = torch.zeros((len(vectorized_seqs), seq_lengths.max())).long()\n",
    "    for idx, (seq, seq_len) in enumerate(zip(vectorized_seqs, seq_lengths)):\n",
    "        seq_tensor[idx, :seq_len] = torch.LongTensor(seq)\n",
    "        \n",
    "    vectorized_seqs = np.array(seq_tensor)\n",
    "    \n",
    "    return torch.tensor(vectorized_seqs), torch.LongTensor([ x for x in seqs_labels])\n",
    "\n",
    "\n",
    "BATCH_SIZE = 8\n",
    "\n",
    "train_loader = DataLoader(dataset=sick_dataset_train,\n",
    "                          batch_size=BATCH_SIZE, shuffle=True, collate_fn=pad_collate)\n",
    "\n",
    "dev_loader = DataLoader(dataset=sick_dataset_dev,\n",
    "                          batch_size=1, shuffle=False, collate_fn=pad_collate)\n",
    "\n",
    "test_loader = DataLoader(dataset=sick_dataset_test,\n",
    "                          batch_size=1, shuffle=False)\n",
    "\n",
    "# Debug the padding\n",
    "# display([ x for x in enumerate(train_loader)][0]) # has padding (sample of same size padded with 0)\n",
    "# display([ x for x in enumerate(dev_loader)][0]) # no batch == no padding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluation helpers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "from sklearn.metrics import precision_recall_fscore_support\n",
    "\n",
    "import itertools\n",
    "import io\n",
    "from tensorboardX.utils import figure_to_image\n",
    "import matplotlib\n",
    "\n",
    "def confusion_scores(total_labels, total_pred, writer=None):\n",
    "    fig = plt.figure(figsize=(10,10))\n",
    "    classes = SickDataset.text_label\n",
    "    title='Confusion matrix'\n",
    "    \n",
    "    cm = confusion_matrix(total_labels, total_pred, labels=[0, 1, 2])\n",
    "    \n",
    "    plt.rcParams[\"figure.figsize\"] = [10, 10]\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n",
    "    plt.title(title, color='gray', fontsize=24)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, [c.lower() for c in classes], rotation=45 , style='italic', color='gray', fontsize=17)\n",
    "    plt.yticks(tick_marks, [c.lower() for c in classes], color='gray', style='italic', fontsize=17)\n",
    "\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], 'd'),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.ylabel('True label', color='gray', fontsize=19)\n",
    "    plt.xlabel('Predicted label', color='gray', fontsize=19)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    if writer != None:\n",
    "        writer.add_figure('plt/confusion_matrix', fig, 0)\n",
    "\n",
    "\n",
    "def evaluate(model, loader, whileTraining=False, criterion=None, writer=None):\n",
    "    \"\"\"\n",
    "    Displays the confusion_matrix the precision recall fscore\n",
    "    If in whileTrainnig Mode only return the accuracy and loss\n",
    "    \"\"\"\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        total_labels = torch.LongTensor([])\n",
    "        total_pred = torch.LongTensor([])\n",
    "        train_loss_batches = 0\n",
    "        train_loss_batches_count = 0\n",
    "        for batch_idx, (data, target) in enumerate(loader):\n",
    "\n",
    "                data = data.to(device)\n",
    "                target = target.to(device)\n",
    "\n",
    "                output = rnn(data)\n",
    "                \n",
    "                if whileTraining and criterion != None:\n",
    "                    loss = criterion(output, target)\n",
    "                    train_loss_batches +=loss.cpu().detach().numpy()\n",
    "                    train_loss_batches_count += 1\n",
    "\n",
    "                # Get the Accuracy\n",
    "                _, predicted = torch.max(output.data, dim=1)\n",
    "                correct = (predicted == target).sum().item()\n",
    "                \n",
    "                total_labels = torch.cat((total_labels, target.cpu()))\n",
    "                total_pred = torch.cat((total_pred, predicted.cpu()))\n",
    "                \n",
    "                \n",
    "        model.train()\n",
    "        if whileTraining and criterion!=None:\n",
    "            return ((accuracy_score(total_labels.flatten().numpy(), total_pred.flatten().numpy()) * 100), train_loss_batches / train_loss_batches_count)\n",
    "\n",
    "                \n",
    "        confusion_scores(total_labels, total_pred, writer=writer)\n",
    "        \n",
    "        print(\"Accuracy:  {:.4f}\".format(accuracy_score(total_labels, total_pred)))\n",
    "        \n",
    "        # compute per-label precisions, recalls, F1-scores, and supports instead of averaging \n",
    "        metrics = precision_recall_fscore_support(\n",
    "                                        total_labels, total_pred,\n",
    "                                        average=None, labels=[0, 1, 2])\n",
    "        \n",
    "        df = pd.DataFrame(list(metrics), index=['Precision', 'Recall', 'Fscore', 'support'],\n",
    "                                   columns=SickDataset.text_label)\n",
    "        df = df.drop(['support'], axis=0)\n",
    "        display(df.T)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create the RNN Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch import nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RNNClassifier(\n",
      "  (embedding): Embedding(1502, 50, padding_idx=0)\n",
      "  (rnn): GRU(50, 20, batch_first=True, bidirectional=True)\n",
      "  (fc1): Linear(in_features=40, out_features=3, bias=True)\n",
      "  (softmax): Softmax()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class RNNClassifier(nn.Module):\n",
    "    # Our model\n",
    "\n",
    "    def __init__(self, input_voc_size, embedding_size, hidden_size):\n",
    "        super(RNNClassifier, self).__init__()\n",
    "        \n",
    "        self.input_voc_size = input_voc_size\n",
    "        self.embedding_size = embedding_size\n",
    "        self.hidden_size = hidden_size\n",
    "        self.rnn_out_size = hidden_size * 2\n",
    "\n",
    "        \n",
    "        self.num_classes = 3\n",
    "        \n",
    "        # Add the padding token (0) (+1 to voc_size)\n",
    "        # Pads the output with the embedding vector at padding_idx whenever it encounters the index..\n",
    "        self.embedding = nn.Embedding(input_voc_size+1, embedding_size, padding_idx=0)\n",
    "        # Load the pretrained embeddings\n",
    "        # self.embedding.weight = nn.Parameter(pretrained_emb_vec) \n",
    "        # embeddings fine-tuning\n",
    "        self.embedding.weight.requires_grad = False\n",
    "        \n",
    "        self.rnn = nn.GRU(\n",
    "              input_size=embedding_size,\n",
    "              hidden_size=hidden_size,\n",
    "              batch_first=True,\n",
    "              bidirectional=True,\n",
    "        )\n",
    "        \n",
    "        self.fc1 = nn.Linear(self.rnn_out_size, self.num_classes)\n",
    "        self.softmax = nn.Softmax(dim=1)\n",
    "        \n",
    "    # input shape: B x S (input size)\n",
    "    def forward(self, x):\n",
    "        \n",
    "        vprint(\"\\nsize input\", x.size())\n",
    "        batch_size = x.size(0)\n",
    "        \n",
    "        # Initialize hidden (num_layers * num_directions, batch_size, hidden_size)\n",
    "        h_0 = torch.zeros(2, batch_size, self.hidden_size)\n",
    "        vprint(\"size hidden init\", h_0.size())\n",
    "        \n",
    "        # When creating new variables inside a model (like the hidden state in an RNN/GRU/LSTM),\n",
    "        # make sure to also move them to the device (GPU or CPU).\n",
    "        h_0 = h_0.to(device)\n",
    "\n",
    "        # Embedding B x S -> B x S x I (embedding size)\n",
    "        emb = self.embedding(x)\n",
    "        vprint(\"size Embedding\", emb.size())\n",
    "        \n",
    "        # Propagate embedding through RNN\n",
    "        # Input: (batch, seq_len, embedding_size)\n",
    "        # h_0: (num_layers * num_directions, batch, hidden_size)\n",
    "        out, hidden = self.rnn(emb, h_0)\n",
    "        \n",
    "        vprint(\"size hidden\", hidden.size())\n",
    "        \n",
    "        rnn_out = torch.cat((hidden[0], hidden[1]), 1)\n",
    "        vprint(\"size rnn out\", rnn_out.size())\n",
    "        \n",
    "        \n",
    "        # Use the last layer output as FC's input\n",
    "        layout_fc1 = self.fc1(rnn_out)\n",
    "        vprint(\"size layout fc1\", layout_fc1.size())\n",
    "        \n",
    "        fc_output = self.softmax(layout_fc1)\n",
    "        \n",
    "        return fc_output    \n",
    "    \n",
    "# Add the unknown token (+1 to voc_size)\n",
    "rnn = RNNClassifier(vocabulary_size+1, EMBEDDINGS_SIZE, 20)\n",
    "rnn.to(device)\n",
    "print(rnn)\n",
    "\n",
    "# Set loss and optimizer function\n",
    "# CrossEntropyLoss = LogSoftmax + NLLLoss\n",
    "weights = [1-((sick_dataset_train.df['entailment_id'] == i).sum() / len(sick_dataset_train)) for i in range(3)]\n",
    "class_weights = torch.FloatTensor(weights).to(device)\n",
    "criterion = torch.nn.CrossEntropyLoss(weight=class_weights)\n",
    "\n",
    "optimizer = torch.optim.Adam(rnn.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorboardX import SummaryWriter\n",
    "writer = SummaryWriter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import errno\n",
    "\n",
    "def force_symlink(file1, file2):\n",
    "    if os.path.exists(file2):\n",
    "        os.remove(file2)\n",
    "    os.symlink(file1, file2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training the Model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [  1/40] | Step [ 2248/4500 (100%)] | Loss 1.116 | Accuracy 56.07% @ Loss_dev 0.985 | Accuracy_dev 56.00%\n",
      "Epoch [  2/40] | Step [ 2248/4500 (100%)] | Loss 1.179 | Accuracy 56.53% @ Loss_dev 0.974 | Accuracy_dev 56.80%\n",
      "Epoch [  3/40] | Step [ 2248/4500 (100%)] | Loss 0.988 | Accuracy 58.69% @ Loss_dev 0.928 | Accuracy_dev 59.40%\n",
      "Epoch [  4/40] | Step [ 2248/4500 (100%)] | Loss 1.072 | Accuracy 59.69% @ Loss_dev 0.924 | Accuracy_dev 60.40%\n",
      "Epoch [  5/40] | Step [ 2248/4500 (100%)] | Loss 0.748 | Accuracy 62.11% @ Loss_dev 0.925 | Accuracy_dev 60.40%\n",
      "Epoch [  6/40] | Step [ 2248/4500 (100%)] | Loss 0.934 | Accuracy 63.80% @ Loss_dev 0.932 | Accuracy_dev 58.80%\n",
      "Epoch [  7/40] | Step [ 2248/4500 (100%)] | Loss 1.198 | Accuracy 65.51% @ Loss_dev 0.951 | Accuracy_dev 56.80%\n",
      "Epoch [  8/40] | Step [ 2248/4500 (100%)] | Loss 0.773 | Accuracy 66.31% @ Loss_dev 0.933 | Accuracy_dev 59.60%\n",
      "Epoch [  9/40] | Step [ 2248/4500 (100%)] | Loss 0.829 | Accuracy 67.44% @ Loss_dev 0.940 | Accuracy_dev 58.40%\n",
      "Epoch [ 10/40] | Step [ 2248/4500 (100%)] | Loss 0.942 | Accuracy 68.38% @ Loss_dev 0.911 | Accuracy_dev 63.80%\n",
      "Epoch [ 11/40] | Step [ 2248/4500 (100%)] | Loss 1.016 | Accuracy 69.33% @ Loss_dev 0.908 | Accuracy_dev 63.40%\n",
      "Epoch [ 12/40] | Step [ 2248/4500 (100%)] | Loss 0.944 | Accuracy 69.60% @ Loss_dev 0.914 | Accuracy_dev 61.80%\n",
      "Epoch [ 13/40] | Step [ 2248/4500 (100%)] | Loss 0.717 | Accuracy 70.96% @ Loss_dev 0.918 | Accuracy_dev 62.60%\n",
      "Epoch [ 14/40] | Step [ 2248/4500 (100%)] | Loss 0.932 | Accuracy 72.13% @ Loss_dev 0.944 | Accuracy_dev 57.40%\n",
      "Epoch [ 15/40] | Step [ 2248/4500 (100%)] | Loss 0.742 | Accuracy 73.58% @ Loss_dev 0.929 | Accuracy_dev 60.40%\n",
      "Epoch [ 16/40] | Step [ 2248/4500 (100%)] | Loss 0.963 | Accuracy 73.73% @ Loss_dev 0.933 | Accuracy_dev 59.60%\n",
      "Epoch [ 17/40] | Step [ 2248/4500 (100%)] | Loss 0.559 | Accuracy 74.93% @ Loss_dev 0.918 | Accuracy_dev 61.00%\n",
      "Epoch [ 18/40] | Step [ 2248/4500 (100%)] | Loss 1.211 | Accuracy 74.96% @ Loss_dev 0.921 | Accuracy_dev 60.20%\n",
      "Epoch [ 19/40] | Step [ 2248/4500 (100%)] | Loss 0.782 | Accuracy 76.20% @ Loss_dev 0.927 | Accuracy_dev 61.20%\n",
      "Epoch [ 20/40] | Step [ 2248/4500 (100%)] | Loss 1.024 | Accuracy 76.89% @ Loss_dev 0.937 | Accuracy_dev 60.60%\n",
      "Epoch [ 21/40] | Step [ 2248/4500 (100%)] | Loss 0.572 | Accuracy 77.20% @ Loss_dev 0.944 | Accuracy_dev 59.00%\n",
      "Epoch [ 22/40] | Step [ 2248/4500 (100%)] | Loss 0.783 | Accuracy 77.51% @ Loss_dev 0.922 | Accuracy_dev 61.40%\n",
      "Epoch [ 23/40] | Step [ 2248/4500 (100%)] | Loss 1.257 | Accuracy 78.80% @ Loss_dev 0.937 | Accuracy_dev 59.60%\n",
      "Epoch [ 24/40] | Step [ 2248/4500 (100%)] | Loss 1.075 | Accuracy 78.51% @ Loss_dev 0.923 | Accuracy_dev 61.60%\n",
      "Epoch [ 25/40] | Step [ 2248/4500 (100%)] | Loss 0.854 | Accuracy 79.40%  @ Loss_dev 0.923 | Accuracy_dev 61.60%\n",
      "Epoch [ 26/40] | Step [ 2248/4500 (100%)] | Loss 0.552 | Accuracy 79.47% @ Loss_dev 0.928 | Accuracy_dev 61.40%\n",
      "Epoch [ 27/40] | Step [ 2248/4500 (100%)] | Loss 0.553 | Accuracy 78.91% @ Loss_dev 0.939 | Accuracy_dev 61.00%\n",
      "Epoch [ 28/40] | Step [ 2248/4500 (100%)] | Loss 0.769 | Accuracy 80.13% @ Loss_dev 0.931 | Accuracy_dev 60.80%\n",
      "Epoch [ 29/40] | Step [ 2248/4500 (100%)] | Loss 0.774 | Accuracy 80.24% @ Loss_dev 0.928 | Accuracy_dev 61.20%\n",
      "Epoch [ 30/40] | Step [ 2248/4500 (100%)] | Loss 0.554 | Accuracy 80.84%  @ Loss_dev 0.923 | Accuracy_dev 62.20%\n",
      "Epoch [ 31/40] | Step [ 2248/4500 (100%)] | Loss 0.557 | Accuracy 81.60% @ Loss_dev 0.929 | Accuracy_dev 60.60%\n",
      "Epoch [ 32/40] | Step [ 2248/4500 (100%)] | Loss 0.554 | Accuracy 81.60% @ Loss_dev 0.919 | Accuracy_dev 62.00%\n",
      "Epoch [ 33/40] | Step [ 2248/4500 (100%)] | Loss 0.756 | Accuracy 81.56% @ Loss_dev 0.923 | Accuracy_dev 62.20%\n",
      "Epoch [ 34/40] | Step [ 2248/4500 (100%)] | Loss 0.553 | Accuracy 81.87% @ Loss_dev 0.932 | Accuracy_dev 60.80%\n",
      "Epoch [ 35/40] | Step [ 2248/4500 (100%)] | Loss 0.552 | Accuracy 82.73% @ Loss_dev 0.925 | Accuracy_dev 61.00%\n",
      "Epoch [ 36/40] | Step [ 2248/4500 (100%)] | Loss 0.551 | Accuracy 82.71% @ Loss_dev 0.922 | Accuracy_dev 62.60%\n",
      "Epoch [ 37/40] | Step [ 2248/4500 (100%)] | Loss 0.558 | Accuracy 83.27% @ Loss_dev 0.919 | Accuracy_dev 62.60%\n",
      "Epoch [ 38/40] | Step [ 2248/4500 (100%)] | Loss 0.553 | Accuracy 82.78% @ Loss_dev 0.916 | Accuracy_dev 62.40%\n",
      "Epoch [ 39/40] | Step [ 2248/4500 (100%)] | Loss 0.597 | Accuracy 83.31% @ Loss_dev 0.928 | Accuracy_dev 61.80%\n",
      "Epoch [ 40/40] | Step [ 2248/4500 (100%)] | Loss 0.557 | Accuracy 83.56% @ Loss_dev 0.937 | Accuracy_dev 59.60%\n",
      "Learning finished!\n",
      "CPU times: user 3min 36s, sys: 3.87 s, total: 3min 40s\n",
      "Wall time: 3min 40s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Train the model\n",
    "\n",
    "num_epochs=40\n",
    "\n",
    "iter = 0\n",
    "iter_batch = 0\n",
    "best_accuracy_dev = 0.0\n",
    "\n",
    "rnn.train()\n",
    "for epoch in range(num_epochs):\n",
    "    total_correct = 0\n",
    "    total_target = 0\n",
    "    train_loss_batches = 0\n",
    "    train_loss_batches_count = 0\n",
    "    for batch_idx, (data, target) in enumerate(train_loader):\n",
    "        \n",
    "        data = data.to(device)\n",
    "        target = target.to(device)\n",
    "        \n",
    "        output = rnn(data)\n",
    "        \n",
    "        vprint(output)\n",
    "        loss = criterion(output, target)\n",
    "        \n",
    "        \n",
    "        train_loss_batches += loss.cpu().detach().numpy()\n",
    "        train_loss_batches_count += 1\n",
    "        \n",
    "        rnn.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        # Get the Accuracy\n",
    "        _, predicted = torch.max(output.data, dim=1)\n",
    "        correct = (predicted == target).sum().item()\n",
    "        \n",
    "        total_correct += correct\n",
    "        total_target += target.size(0)\n",
    "        \n",
    "        if batch_idx % 200 == 0 or batch_idx % 200 == 1 or batch_idx == len(train_loader)-1:\n",
    "            print('\\rEpoch [{:3}/{}] | Step [{:5}/{} ({:3.0f}%)] | Loss {:.3f} | Accuracy {:.2f}%'.format(\n",
    "                    epoch+1, num_epochs,\n",
    "                    batch_idx * len(data), \n",
    "                    len(train_loader.dataset),\n",
    "                    100. * batch_idx / len(train_loader), \n",
    "                    loss.item(), \n",
    "                    (total_correct / total_target) * 100), end=' ')\n",
    "            \n",
    "            writer.add_scalar('data/loss/_train_only', train_loss_batches / train_loss_batches_count, iter_batch)\n",
    "            iter_batch += 1\n",
    "            \n",
    "        if Verbose:\n",
    "            break\n",
    "            \n",
    "    accuracy_dev, loss_dev = evaluate(rnn, dev_loader, criterion=criterion, whileTraining=True)\n",
    "    print(\"@ Loss_dev {:.3f} | Accuracy_dev {:.2f}%\".format(loss_dev, accuracy_dev))\n",
    "    \n",
    "    if best_accuracy_dev < accuracy_dev:\n",
    "        best_accuracy_dev = accuracy_dev\n",
    "        file = 'checkpoint.pth.' + str(epoch) + '.acc.' + str(round(accuracy_dev,2)) + '.tar'\n",
    "        torch.save({\n",
    "            'epoch': epoch,\n",
    "            'model_state_dict': rnn.state_dict(),\n",
    "            'loss': loss,\n",
    "            }, file)\n",
    "        force_symlink(file, 'checkpoint.pth.best.tar')\n",
    "\n",
    "    writer.add_scalars('data/loss/evol', {'train': train_loss_batches / train_loss_batches_count,\n",
    "                                         'dev': loss_dev}, iter)\n",
    "    iter += 1\n",
    "            \n",
    "            \n",
    "\n",
    "\n",
    "print(\"Learning finished!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluate the model on dev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> loaded checkpoint epoch 9\n"
     ]
    }
   ],
   "source": [
    "checkpoint = torch.load('checkpoint.pth.best.tar')\n",
    "rnn.load_state_dict(checkpoint['model_state_dict'])\n",
    "print(\"=> loaded checkpoint epoch {}\"\n",
    "      .format(checkpoint['epoch']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.6380\n"
     ]
    },
    {
     "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>Precision</th>\n",
       "      <th>Recall</th>\n",
       "      <th>Fscore</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>NEUTRAL</th>\n",
       "      <td>0.700375</td>\n",
       "      <td>0.663121</td>\n",
       "      <td>0.681239</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ENTAILMENT</th>\n",
       "      <td>0.503497</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>0.501742</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CONTRADICTION</th>\n",
       "      <td>0.666667</td>\n",
       "      <td>0.810811</td>\n",
       "      <td>0.731707</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               Precision    Recall    Fscore\n",
       "NEUTRAL         0.700375  0.663121  0.681239\n",
       "ENTAILMENT      0.503497  0.500000  0.501742\n",
       "CONTRADICTION   0.666667  0.810811  0.731707"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.93 s, sys: 712 ms, total: 2.64 s\n",
      "Wall time: 1.75 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "evaluate(rnn, dev_loader, writer=writer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluate the model on test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 0 ns, sys: 0 ns, total: 0 ns\n",
      "Wall time: 8.34 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# evaluate(rnn, test_loader)"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}