tips_pred_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tips Prediction #\n",
    "\n",
    "In this library, we will explore the data which we retrieved from *LifeProTips*, *ShittyLifeProTips*, *UnethicalLifeProTips* and *IllegalLifeProTips*.\n",
    "Afterwards, we will make some predictions to determine which subreddit a certain post belongs to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import everything in case we just want to run particular cells\n",
    "import json\n",
    "import math\n",
    "import pandas as pd\n",
    "import re\n",
    "from string import punctuation\n",
    "from nltk.stem import SnowballStemmer\n",
    "from nltk.corpus import stopwords\n",
    "import numpy as np\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.metrics import precision_recall_fscore_support\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.svm import SVC\n",
    "from gensim.models import Word2Vec, KeyedVectors\n",
    "from gensim.scripts.glove2word2vec import glove2word2vec\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Load and split ##\n",
    "\n",
    "Let's start by loading the posts into memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "posts = {}\n",
    "\n",
    "# Import LifeProTips\n",
    "with open('tips/lifeprotips_dump_1.json', 'r') as lptf:\n",
    "    posts['lpt'] = json.load(lptf)\n",
    "\n",
    "# Import ShittyLifeProTips\n",
    "with open('tips/shittylifeprotips_dump_1.json', 'r') as slptf:\n",
    "    posts['slpt'] = json.load(slptf)\n",
    "    \n",
    "# Import UnethicalLifeProTips\n",
    "with open('tips/unethicallifeprotips_dump_1.json', 'r') as ulptf:\n",
    "    posts['ulpt'] = json.load(ulptf)\n",
    "\n",
    "# Import IllegalLifeProTips\n",
    "with open('tips/illegallifeprotips_dump_1.json', 'r') as ilptf:\n",
    "    posts['ilpt'] = json.load(ilptf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's remove any duplicate from the posts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "for subreddit in posts:\n",
    "    obs_ids = [] # observed ids\n",
    "    unique_posts = [] # unique posts\n",
    "    for post in posts[subreddit]: # every post is a dictionary\n",
    "        if post['id'] not in obs_ids:\n",
    "            obs_ids.append(post['id'])\n",
    "            unique_posts.append(post)\n",
    "    posts[subreddit] = unique_posts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the amount of unique posts we retrieved per subreddit $\\rightarrow$ No duplicates!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30000 posts retrieved from lpt\n",
      "30000 posts retrieved from slpt\n",
      "30000 posts retrieved from ulpt\n",
      "10000 posts retrieved from ilpt\n"
     ]
    }
   ],
   "source": [
    "for (s, a) in posts.items():\n",
    "    print('{} posts retrieved from {}'.format(len(a), s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason why there are only 10k posts from *IllegalLifeProTips* is because the community is relatively young compared to the rest of subreddits. It was founded two years ago while the other three appeared years before.\n",
    "\n",
    "---\n",
    "\n",
    "Now, let's shuffle the posts for each subreddit to perform an arbitrary and even train/validation/test division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "for (s, p) in posts.items():\n",
    "    random.shuffle(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will perfom a train/validation/test split as follows:\n",
    "* $4/9$ for training ($2/3$ of $2/3$)\n",
    "* $2/9$ for validation ($1/3$ of $2/3$)\n",
    "* $1/3$ for testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "# Create and empty dictionary to store train, validation and test posts\n",
    "posts_struct = {'train':[], 'validation':[], 'test':[]}\n",
    "\n",
    "# For each subreddit, split\n",
    "for p in posts.values():\n",
    "    # p is the list of posts (each post is a dictionary)\n",
    "    # train + validation is 2/3; test is 1/3\n",
    "    split_index = int(math.ceil((2/3)*len(p)))\n",
    "    p_trainval = p[:split_index]\n",
    "    p_test = p[split_index:]\n",
    "    # Now, out of train+validation, 2/3 go to train and 1/3 to validation\n",
    "    split_index = int(math.ceil((2/3)*len(p_trainval)))\n",
    "    p_train = p_trainval[:split_index]\n",
    "    p_validation = p_trainval[split_index:]\n",
    "    \n",
    "    # Finally, add the posts to their respective parts in the posts_struct dictionary\n",
    "    posts_struct['train'].extend(p_train)\n",
    "    posts_struct['validation'].extend(p_validation)\n",
    "    posts_struct['test'].extend(p_test)\n",
    "\n",
    "# Shuffle the lists\n",
    "for (sep, p) in posts_struct.items():\n",
    "    random.shuffle(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check that we performed a correct split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of instances: 100000\n",
      "Percentage of train instances: 44.446999999999996\n",
      "Percentage of validation instances: 22.220000000000002\n",
      "Percentage of test instances: 33.333\n"
     ]
    }
   ],
   "source": [
    "ins_tot = len(posts_struct['train']) + len(posts_struct['validation']) + len(posts_struct['test'])\n",
    "print('Total number of instances: {}'.format(ins_tot))\n",
    "print('Percentage of train instances: {}'.format((len(posts_struct['train'])/ins_tot)*100))\n",
    "print('Percentage of validation instances: {}'.format((len(posts_struct['validation'])/ins_tot)*100))\n",
    "print('Percentage of test instances: {}'.format((len(posts_struct['test'])/ins_tot)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We just need one more step to perform. Creating `pandas` DataFrames for training, validation and testing will make data handling easier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# DataFrame for training\n",
    "df_train = pd.DataFrame({'instance':[s['title'] for s in posts_struct['train']],\n",
    "                         'label':[s['label'] for s in posts_struct['train']]})\n",
    "\n",
    "# DataFrame for validation\n",
    "df_validation = pd.DataFrame({'instance':[s['title'] for s in posts_struct['validation']],\n",
    "                              'label':[s['label'] for s in posts_struct['validation']]})\n",
    "\n",
    "# DataFrame for testing\n",
    "df_test = pd.DataFrame({'instance':[s['title'] for s in posts_struct['test']],\n",
    "                        'label':[s['label'] for s in posts_struct['test']]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Instance pre-processing ##\n",
    "\n",
    "Define a method to clean the instances<br>\n",
    "**Disclaimer:** we are **not** copying this from Assignment 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean(text, stem_words=True):\n",
    "    \n",
    "    # Empty question\n",
    "    if type(text) != str or text=='':\n",
    "        return ''\n",
    "    \n",
    "    # Make text lowercase\n",
    "    text = text.lower()\n",
    "\n",
    "    # Clean the text\n",
    "    text = re.sub(\"\\'s\", \" \", text) # we have cases like \"Sam is\" or \"Sam's\" (i.e. his) these two cases aren't separable, I choose to compromise are kill \"'s\" directly\n",
    "    text = re.sub(\"\\'t'\", \" not \", text)\n",
    "    text = re.sub(\" whats \", \" what is \", text, flags=re.IGNORECASE)\n",
    "    text = re.sub(\" thats \", \" that is \", text, flags=re.IGNORECASE)\n",
    "    text = re.sub(\"\\'ve\", \" have \", text)\n",
    "    text = re.sub(\"-\", \" \", text)\n",
    "    #you might need more\n",
    "    \n",
    "    # remove comma between numbers, i.e. 15,000 -> 15000\n",
    "    text = re.sub('(?<=[0-9])\\,(?=[0-9])', \"\", text)\n",
    "    \n",
    "    # remove punctuation\n",
    "    for c in punctuation:\n",
    "        text = re.sub(\"\\\\\" + c, \"\", text)\n",
    "        \n",
    "    # split text\n",
    "    n_text = text.split();\n",
    "    \n",
    "    # remove stopwords and subreddit keywords\n",
    "    stops = set(['the', 'to', 'now', 'should', 'just', 'very', 'too', 'again', 'in', 'out', 'on',\n",
    "                 'over', 'at', 'of', 'about'])\n",
    "    #stops = set(stopwords.words('english'))\n",
    "    sub_kwords = set(['lpt', 'ulpt', 'ilpt', 'slpt'])\n",
    "    numbers = set(['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve'])\n",
    "    n_text = [word for word in n_text if word not in stops|sub_kwords|numbers if word.isalpha()]\n",
    "    \n",
    "    # Change numbers and other similar words\n",
    "    #subs = [('one', '1'), ('ii', '2'), ('two', '2'), ('iii', '3'), ('three', '3'), ('iv', '4'), ('four', '4'),\n",
    "    #        ('v', '5'), ('five', '5'), ('vi', '6'), ('six', '6'), ('vii', '7'), ('seven', '7'), ('viii', '8'),\n",
    "    #        ('eight', '8'), ('ix', '9'), ('nine', '9'), ('ten', '10'), ('eleven', '11'), ('twelve', '12')]\n",
    "    #for i, word in enumerate(n_text):\n",
    "    #    for (bad, good) in subs:\n",
    "    #        if word == bad:\n",
    "    #            n_text[i] = good\n",
    "    #            break\n",
    "    \n",
    "    # Return a list of words\n",
    "    return ' '.join(n_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clean the DataFrames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train['instance'] = df_train['instance'].apply(clean)\n",
    "df_validation['instance'] = df_validation['instance'].apply(clean)\n",
    "df_test['instance'] = df_test['instance'].apply(clean)\n",
    "\n",
    "# Drop empty posts\n",
    "df_train = df_train[df_train['instance'] != \"\"]\n",
    "df_train = df_train[df_train['instance'] != \" \"]\n",
    "df_validation = df_validation[df_validation['instance'] != \"\"]\n",
    "df_validation = df_validation[df_validation['instance'] != \" \"]\n",
    "df_test = df_test[df_test['instance'] != \"\"]\n",
    "df_test = df_test[df_test['instance'] != \" \"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Train the ML Models ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### BOW + Naive Bayes ###\n",
    "\n",
    "First, build the BOW representation for training, validation and testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "\n",
    "vectorizer = CountVectorizer()\n",
    "\n",
    "# Generate the vocabulary using all instances\n",
    "vectorizer.fit(np.concatenate((df_train['instance'].values, df_validation['instance'].values,\n",
    "                               df_test['instance'].values), axis=0))\n",
    "\n",
    "# Transform each batch separately and add labels\n",
    "# Train\n",
    "x_train = vectorizer.transform(df_train['instance'].values).toarray()\n",
    "y_train = df_train['label'].values\n",
    "# Validation\n",
    "x_validation = vectorizer.transform(df_validation['instance'].values).toarray()\n",
    "y_validation = df_validation['label'].values\n",
    "# Train+Validation\n",
    "x_tv = np.concatenate((x_train, x_validation), axis=0)\n",
    "y_tv = np.concatenate((y_train, y_validation), axis=0)\n",
    "# Test\n",
    "x_test = vectorizer.transform(df_test['instance'].values).toarray()\n",
    "y_test = df_test['label'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform validation using `MultinomialNB` from `sklearn`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top accuracy: 0.6169241890304509\n",
      "Alpha: 0.5777777777777777\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import precision_recall_fscore_support\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "\n",
    "alphas = np.linspace(0.3,0.8,10)\n",
    "accs = []\n",
    "precs = []\n",
    "recs = []\n",
    "fscores = []\n",
    "\n",
    "top_acc = 0\n",
    "top_alpha = 0\n",
    "for alpha in alphas:\n",
    "    model = MultinomialNB(alpha)\n",
    "    model.fit(x_train, y_train)\n",
    "    acc = model.score(x_validation, y_validation)\n",
    "    accs.append(acc)\n",
    "    measures = precision_recall_fscore_support(y_validation, model.predict(x_validation), average='macro')\n",
    "    precs.append(measures[0])\n",
    "    recs.append(measures[1])\n",
    "    fscores.append(measures[2])\n",
    "    if acc > top_acc:\n",
    "        top_acc = acc\n",
    "        top_alpha = alpha\n",
    "print(\"Top accuracy:\", top_acc)\n",
    "print(\"Alpha:\", top_alpha)\n",
    "\n",
    "# Retrain with whole training set and optimal alpha\n",
    "top_model = MultinomialNB(top_alpha)\n",
    "top_model.fit(x_tv, y_tv);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot measures vs alpha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10,10))\n",
    "\n",
    "# Accuracy vs alpha\n",
    "axes[0][0].plot(alphas, accs, lw=1.5)\n",
    "axes[0][0].set_xlabel(r'$\\alpha$')\n",
    "axes[0][0].set_ylabel('Accuracy')\n",
    "axes[0][0].set_title('Accuracy vs. Alpha for MultinomialNB')\n",
    "\n",
    "# Precision vs alpha\n",
    "axes[0][1].plot(alphas, precs, lw=1.5)\n",
    "axes[0][1].set_xlabel(r'$\\alpha$')\n",
    "axes[0][1].set_ylabel('Precision')\n",
    "axes[0][1].set_title('Precision vs. Alpha for MultinomialNB')\n",
    "\n",
    "# Recall vs alpha\n",
    "axes[1][0].plot(alphas, recs, lw=1.5)\n",
    "axes[1][0].set_xlabel(r'$\\alpha$')\n",
    "axes[1][0].set_ylabel('Recall')\n",
    "axes[1][0].set_title('Recall vs. Alpha for MultinomialNB')\n",
    "\n",
    "# FScore vs alpha\n",
    "axes[1][1].plot(alphas, fscores, lw=1.5)\n",
    "axes[1][1].set_xlabel(r'$\\alpha$')\n",
    "axes[1][1].set_ylabel('FScore')\n",
    "axes[1][1].set_title('FScore vs. Alpha for MultinomialNB')\n",
    "\n",
    "# Adjust layout\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check for accuracy on test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MN Accuracy: 62.70%\n"
     ]
    }
   ],
   "source": [
    "print(\"MN Accuracy: %0.2f%%\" % (100 * top_model.score(x_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute confusion matrix, precision, recall and F-score with micro and macro averaging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "cf = confusion_matrix(y_test, top_model.predict(x_test))\n",
    "\n",
    "measures_macro = list(precision_recall_fscore_support(y_test, top_model.predict(x_test), average='macro'))[:-1]\n",
    "measures_micro = list(precision_recall_fscore_support(y_test, top_model.predict(x_test), average='micro'))[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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>Predicted ilpt</th>\n",
       "      <th>Predicted lpt</th>\n",
       "      <th>Predicted slpt</th>\n",
       "      <th>Predicted ulpt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ilpt</th>\n",
       "      <td>2280</td>\n",
       "      <td>124</td>\n",
       "      <td>213</td>\n",
       "      <td>704</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lpt</th>\n",
       "      <td>347</td>\n",
       "      <td>6041</td>\n",
       "      <td>1871</td>\n",
       "      <td>1715</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slpt</th>\n",
       "      <td>198</td>\n",
       "      <td>1563</td>\n",
       "      <td>6059</td>\n",
       "      <td>2122</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ulpt</th>\n",
       "      <td>607</td>\n",
       "      <td>1085</td>\n",
       "      <td>1840</td>\n",
       "      <td>6443</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Predicted ilpt  Predicted lpt  Predicted slpt  Predicted ulpt\n",
       "ilpt            2280            124             213             704\n",
       "lpt              347           6041            1871            1715\n",
       "slpt             198           1563            6059            2122\n",
       "ulpt             607           1085            1840            6443"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cf_df = pd.DataFrame(cf, columns=['Predicted ilpt', 'Predicted lpt', 'Predicted slpt', 'Predicted ulpt'])\n",
    "cf_df.rename(index={0:'ilpt',1:'lpt',2:'slpt',3:'ulpt'}, inplace=True)\n",
    "cf_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show precision, recall and F-score with averaging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>Averaging</th>\n",
       "      <th>Precision</th>\n",
       "      <th>Recall</th>\n",
       "      <th>FScore</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>macro</td>\n",
       "      <td>0.635828</td>\n",
       "      <td>0.636891</td>\n",
       "      <td>0.635340</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>micro</td>\n",
       "      <td>0.626972</td>\n",
       "      <td>0.626972</td>\n",
       "      <td>0.626972</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Averaging  Precision    Recall    FScore\n",
       "0     macro   0.635828  0.636891  0.635340\n",
       "1     micro   0.626972  0.626972  0.626972"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "measures_macro = ['macro'] + measures_macro\n",
    "measures_micro = ['micro'] + measures_micro\n",
    "measures_df = pd.DataFrame([measures_macro, measures_micro], columns=['Averaging', 'Precision', 'Recall', 'FScore'])\n",
    "measures_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Word2Vec ###\n",
    "\n",
    "We will train a `Word2Vec` model from `gensim` using our entire corpus.\n",
    "\n",
    "First, we define a function to tokenize a list of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize_arr(sentences):\n",
    "    \"\"\"Given a list of sentences, return the list with the tokenized strings (a list itself).\"\"\"\n",
    "    new_sentences = sentences.copy()\n",
    "    for i, sentence in enumerate(new_sentences):\n",
    "        new_sentences[i] = sentence.split()\n",
    "    return new_sentences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate the `sentences` for `Word2Vec` using all corpus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentences = tokenize_arr(np.concatenate((df_train['instance'].values,\n",
    "                                         df_validation['instance'].values,\n",
    "                                         df_test['instance'].values), axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train `Word2Vec` using `sentences`.<br>\n",
    "We must look for good parameter values regarding `min_count`, `size` and `window`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gensim.models import Word2Vec\n",
    "\n",
    "w2v_model = Word2Vec(sentences, min_count=1, size=200, window=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Embeddings must be generated for the instances in `df_train`, `df_validation` and `df_test`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tokenize the submissions in train, validation and test\n",
    "sub_train = tokenize_arr(df_train['instance'].values)\n",
    "sub_validation = tokenize_arr(df_validation['instance'].values)\n",
    "sub_test = tokenize_arr(df_test['instance'].values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define a method to transform a list of tokens into an embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_lists(lol):\n",
    "    \"\"\"Given a list of lists of equal size, sum its elements (like vector sum) and take the average.\"\"\"\n",
    "    result = []\n",
    "    for element in lol[0]: # Create the size of sum array\n",
    "        result.append(0)\n",
    "    for l in lol: # For every sublist\n",
    "        for i, c in enumerate(l): # For every element\n",
    "            result[i] += c\n",
    "    # Average the sum\n",
    "    for i, v in enumerate(result):\n",
    "        result[i] /= len(lol);\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sen2emb(sentence, word_dict):\n",
    "    \"\"\"Transform a tokenized sentence into an embedding by adding the embedding word vectors.\"\"\"\n",
    "    embeddings = []\n",
    "    for token in sentence:\n",
    "        if token in word_dict.vocab:\n",
    "            embeddings.append(word_dict[token].tolist())\n",
    "    embedding = sum_lists(embeddings)\n",
    "    return embedding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate $x$ for training, validation and testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = [sen2emb(sub, w2v_model.wv) for sub in sub_train]\n",
    "x_validation = [sen2emb(sub, w2v_model.wv) for sub in sub_validation]\n",
    "x_tv = np.concatenate((x_train, x_validation), axis=0)\n",
    "x_test = [sen2emb(sub, w2v_model.wv) for sub in sub_test]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate the labels for training, validation and testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = df_train['label'].values\n",
    "y_validation = df_validation['label'].values\n",
    "y_tv = np.concatenate((y_train, y_validation), axis=0)\n",
    "y_test = df_test['label'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform **feature standarization** so that the values of each feature in the data have zero-mean and unit-variance.\n",
    "\n",
    "$$x'=\\frac{x-\\overline{x}}{\\sigma}$$\n",
    "\n",
    "Where $x$ is the original feature vector, $\\overline{x} = average(x)$ is the mean of that feature vector, $\\sigma$ is its standard deviation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def standarize(lol):\n",
    "    \"\"\"Given a list of list, standarize the sublists.\"\"\"\n",
    "    lol_np = np.array(lol)\n",
    "    avg_v = np.mean(lol_np, axis=0)\n",
    "    std_v = np.std(lol_np, axis=0)\n",
    "    return (lol_np - avg_v) / std_v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Standarize $x$ for training, validation and testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = standarize(x_train)\n",
    "x_validation = standarize(x_validation)\n",
    "x_tv = standarize(x_tv)\n",
    "x_test = standarize(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Support Vector Machine ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tune hyperparameters and retrieve measures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/sklearn/metrics/classification.py:1143: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top regularization: 1.0\n",
      "Top accuracy: 0.6066232944790819\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import precision_recall_fscore_support\n",
    "\n",
    "top_accuracy = 0;\n",
    "top_reg = 0;\n",
    "\n",
    "regs = np.linspace(1e-10, 1, 10)\n",
    "accs = []\n",
    "precs = []\n",
    "recs = []\n",
    "fscores = []\n",
    "\n",
    "for reg in regs:\n",
    "    svm_model = SVC(gamma='scale', C=reg)\n",
    "    svm_model.fit(x_train, y_train)\n",
    "    acc = svm_model.score(x_validation, y_validation)\n",
    "    accs.append(acc)\n",
    "    measures = precision_recall_fscore_support(y_validation, svm_model.predict(x_validation), average='macro')\n",
    "    precs.append(measures[0])\n",
    "    recs.append(measures[1])\n",
    "    fscores.append(measures[2])\n",
    "    if acc > top_accuracy:\n",
    "        top_accuracy = acc\n",
    "        top_reg = reg\n",
    "\n",
    "print(\"Top regularization:\", top_reg)\n",
    "print(\"Top accuracy:\", top_accuracy)\n",
    "\n",
    "# Retrain with whole training set and optimal penalty\n",
    "top_model = SVC(gamma='scale', C=top_reg)\n",
    "top_model.fit(x_tv, y_tv);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot measures vs. penalty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10,10))\n",
    "\n",
    "# Accuracy vs regularization\n",
    "axes[0][0].plot(regs, accs, lw=1.5)\n",
    "axes[0][0].set_xlabel('Regularization')\n",
    "axes[0][0].set_ylabel('Accuracy')\n",
    "axes[0][0].set_title('Accuracy vs. Regularization for SVM')\n",
    "\n",
    "# Precision vs regularization\n",
    "axes[0][1].plot(regs, precs, lw=1.5)\n",
    "axes[0][1].set_xlabel('Regularization')\n",
    "axes[0][1].set_ylabel('Precision')\n",
    "axes[0][1].set_title('Precision vs. Regularization for SVM')\n",
    "\n",
    "# Recall vs regularization\n",
    "axes[1][0].plot(regs, recs, lw=1.5)\n",
    "axes[1][0].set_xlabel('Regularization')\n",
    "axes[1][0].set_ylabel('Recall')\n",
    "axes[1][0].set_title('Recall vs. Regularization for SVM')\n",
    "\n",
    "# FScore vs regularization\n",
    "axes[1][1].plot(regs, fscores, lw=1.5)\n",
    "axes[1][1].set_xlabel('Regularization')\n",
    "axes[1][1].set_ylabel('FScore')\n",
    "axes[1][1].set_title('FScore vs. Regularization for SVM')\n",
    "\n",
    "# Adjust layout\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform test on test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Accuracy: 61.81%\n"
     ]
    }
   ],
   "source": [
    "print(\"SVM Accuracy: %0.2f%%\" % (100 * top_model.score(x_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute confusion matrix, precision, recall and F-score with micro and macro averaging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "cf = confusion_matrix(y_test, top_model.predict(x_test))\n",
    "\n",
    "measures_macro = list(precision_recall_fscore_support(y_test, top_model.predict(x_test), average='macro'))[:-1]\n",
    "measures_micro = list(precision_recall_fscore_support(y_test, top_model.predict(x_test), average='micro'))[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show the confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "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>Predicted ilpt</th>\n",
       "      <th>Predicted lpt</th>\n",
       "      <th>Predicted slpt</th>\n",
       "      <th>Predicted ulpt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ilpt</th>\n",
       "      <td>2081</td>\n",
       "      <td>259</td>\n",
       "      <td>322</td>\n",
       "      <td>659</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lpt</th>\n",
       "      <td>221</td>\n",
       "      <td>6519</td>\n",
       "      <td>1798</td>\n",
       "      <td>1436</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slpt</th>\n",
       "      <td>84</td>\n",
       "      <td>2049</td>\n",
       "      <td>5748</td>\n",
       "      <td>2061</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ulpt</th>\n",
       "      <td>417</td>\n",
       "      <td>1617</td>\n",
       "      <td>1760</td>\n",
       "      <td>6181</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Predicted ilpt  Predicted lpt  Predicted slpt  Predicted ulpt\n",
       "ilpt            2081            259             322             659\n",
       "lpt              221           6519            1798            1436\n",
       "slpt              84           2049            5748            2061\n",
       "ulpt             417           1617            1760            6181"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cf_df = pd.DataFrame(cf, columns=['Predicted ilpt', 'Predicted lpt', 'Predicted slpt', 'Predicted ulpt'])\n",
    "cf_df.rename(index={0:'ilpt',1:'lpt',2:'slpt',3:'ulpt'}, inplace=True)\n",
    "cf_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show precision, recall and F-score with averaging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "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>Averaging</th>\n",
       "      <th>Precision</th>\n",
       "      <th>Recall</th>\n",
       "      <th>FScore</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>macro</td>\n",
       "      <td>0.640391</td>\n",
       "      <td>0.619505</td>\n",
       "      <td>0.628553</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>micro</td>\n",
       "      <td>0.618120</td>\n",
       "      <td>0.618120</td>\n",
       "      <td>0.618120</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Averaging  Precision    Recall    FScore\n",
       "0     macro   0.640391  0.619505  0.628553\n",
       "1     micro   0.618120  0.618120  0.618120"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "measures_macro = ['macro'] + measures_macro\n",
    "measures_micro = ['micro'] + measures_micro\n",
    "measures_df = pd.DataFrame([measures_macro, measures_micro], columns=['Averaging', 'Precision', 'Recall', 'FScore'])\n",
    "measures_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic Regression ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tune hyperparameters and retrieve measures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/sklearn/metrics/classification.py:1143: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top regularization: 0.048994974876381915\n",
      "Top accuracy: 0.5622571609288877\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import precision_recall_fscore_support\n",
    "\n",
    "top_accuracy = 0;\n",
    "top_reg = 0;\n",
    "\n",
    "regs = np.linspace(1e-10, 0.05, 200)\n",
    "accs = []\n",
    "precs = []\n",
    "recs = []\n",
    "fscores = []\n",
    "\n",
    "for reg in regs:\n",
    "    lr_model = LogisticRegression(solver='lbfgs', multi_class='multinomial', C=reg, max_iter=5000)\n",
    "    lr_model.fit(x_train, y_train)\n",
    "    acc = lr_model.score(x_validation, y_validation)\n",
    "    accs.append(acc)\n",
    "    measures = precision_recall_fscore_support(y_validation, lr_model.predict(x_validation), average='macro')\n",
    "    precs.append(measures[0])\n",
    "    recs.append(measures[1])\n",
    "    fscores.append(measures[2])\n",
    "    if acc > top_accuracy:\n",
    "        top_accuracy = acc\n",
    "        top_reg = reg\n",
    "\n",
    "print(\"Top regularization:\", top_reg)\n",
    "print(\"Top accuracy:\", top_accuracy)\n",
    "\n",
    "# Retrain with whole training set and optimal penalty\n",
    "top_model = LogisticRegression(solver='lbfgs', multi_class='multinomial', C=top_reg, max_iter=10000)\n",
    "top_model.fit(x_tv, y_tv);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot measures vs. penalty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10,10))\n",
    "\n",
    "# Accuracy vs regularization\n",
    "axes[0][0].plot(regs, accs, lw=1.5)\n",
    "axes[0][0].set_xlabel('Regularization')\n",
    "axes[0][0].set_ylabel('Accuracy')\n",
    "axes[0][0].set_title('Accuracy vs. Regularization for LR')\n",
    "\n",
    "# Precision vs regularization\n",
    "axes[0][1].plot(regs, precs, lw=1.5)\n",
    "axes[0][1].set_xlabel('Regularization')\n",
    "axes[0][1].set_ylabel('Precision')\n",
    "axes[0][1].set_title('Precision vs. Regularization for LR')\n",
    "\n",
    "# Recall vs penalty\n",
    "axes[1][0].plot(regs, recs, lw=1.5)\n",
    "axes[1][0].set_xlabel('Regularization')\n",
    "axes[1][0].set_ylabel('Recall')\n",
    "axes[1][0].set_title('Recall vs. Regularization for LR')\n",
    "\n",
    "# FScore vs regularization\n",
    "axes[1][1].plot(regs, fscores, lw=1.5)\n",
    "axes[1][1].set_xlabel('Regularization')\n",
    "axes[1][1].set_ylabel('FScore')\n",
    "axes[1][1].set_title('FScore vs. Regularization for LR')\n",
    "\n",
    "# Adjust layout\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform test on test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Accuracy: 57.05%\n"
     ]
    }
   ],
   "source": [
    "print(\"LR Accuracy: %0.2f%%\" % (100 * top_model.score(x_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute confusion matrix, precision, recall and F-score with micro and macro averaging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "cf = confusion_matrix(y_test, top_model.predict(x_test))\n",
    "\n",
    "measures_macro = list(precision_recall_fscore_support(y_test, top_model.predict(x_test), average='macro'))[:-1]\n",
    "measures_micro = list(precision_recall_fscore_support(y_test, top_model.predict(x_test), average='micro'))[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show the confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true
   },
   "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>Predicted ilpt</th>\n",
       "      <th>Predicted lpt</th>\n",
       "      <th>Predicted slpt</th>\n",
       "      <th>Predicted ulpt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ilpt</th>\n",
       "      <td>1942</td>\n",
       "      <td>339</td>\n",
       "      <td>273</td>\n",
       "      <td>767</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lpt</th>\n",
       "      <td>215</td>\n",
       "      <td>6012</td>\n",
       "      <td>2080</td>\n",
       "      <td>1667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slpt</th>\n",
       "      <td>126</td>\n",
       "      <td>2285</td>\n",
       "      <td>5295</td>\n",
       "      <td>2236</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ulpt</th>\n",
       "      <td>420</td>\n",
       "      <td>1791</td>\n",
       "      <td>2066</td>\n",
       "      <td>5698</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Predicted ilpt  Predicted lpt  Predicted slpt  Predicted ulpt\n",
       "ilpt            1942            339             273             767\n",
       "lpt              215           6012            2080            1667\n",
       "slpt             126           2285            5295            2236\n",
       "ulpt             420           1791            2066            5698"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cf_df = pd.DataFrame(cf, columns=['Predicted ilpt', 'Predicted lpt', 'Predicted slpt', 'Predicted ulpt'])\n",
    "cf_df.rename(index={0:'ilpt',1:'lpt',2:'slpt',3:'ulpt'}, inplace=True)\n",
    "cf_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show precision, recall and F-score with averaging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "scrolled": true
   },
   "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>Averaging</th>\n",
       "      <th>Precision</th>\n",
       "      <th>Recall</th>\n",
       "      <th>FScore</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>macro</td>\n",
       "      <td>0.597427</td>\n",
       "      <td>0.572837</td>\n",
       "      <td>0.583274</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>micro</td>\n",
       "      <td>0.570487</td>\n",
       "      <td>0.570487</td>\n",
       "      <td>0.570487</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Averaging  Precision    Recall    FScore\n",
       "0     macro   0.597427  0.572837  0.583274\n",
       "1     micro   0.570487  0.570487  0.570487"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "measures_macro = ['macro'] + measures_macro\n",
    "measures_micro = ['micro'] + measures_micro\n",
    "measures_df = pd.DataFrame([measures_macro, measures_micro], columns=['Averaging', 'Precision', 'Recall', 'FScore'])\n",
    "measures_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pretrained Word2Vec ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I will be using **Google's Word2Vec** trained dictionary, which includes word vectors for a vocabulary of 3 million words.<br>\n",
    "Each vector has 300 features.\n",
    "\n",
    "http://mccormickml.com/2016/04/12/googles-pretrained-word2vec-model-in-python/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gensim.models import Word2Vec, KeyedVectors\n",
    "\n",
    "# Let's import the model\n",
    "wv_ptrained = KeyedVectors.load_word2vec_format('pretrained/GoogleNews-vectors-negative300.bin', binary=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even if the pretrained dictionary is large, we discovered that is does not contain some words.<br>\n",
    "Hence, we will redefine the `sen2emb(sentences, word_dict)` function so that it accepts an undefined amount of dictionaries instead of a unique one $\\rightarrow$ `sen2emb(sentences, *word_dicts)`.<br>\n",
    "**Note:** all of them should return vectors with the same amount of dimensions.\n",
    "\n",
    "This way, for every token, we will try to find a vector in the first dictionary. If it is not found, then we will try the second, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sen2emb(sentence, *word_dicts):\n",
    "    \"\"\"Transform a tokenized sentence into an embedding by adding the embedding word vectors.\"\"\"\n",
    "    embeddings = []\n",
    "    for token in sentence:\n",
    "        for word_dict in word_dicts:\n",
    "            if token in word_dict.vocab:\n",
    "                embeddings.append(word_dict[token].tolist())\n",
    "                break\n",
    "    embedding = sum_lists(embeddings)\n",
    "    return embedding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, we need (at least) a backup model. I will be using the **Wikipedia 2014 + Gigaword 5**, which has 300D vectors and 400k vocabulary size.<br>\n",
    "It was extracted from https://nlp.stanford.edu/projects/glove/\n",
    "\n",
    "As a side note, this `.txt` file is in GloVe format. Hence, we need to convert it to `Word2Vec` format.<br>\n",
    "**Note:** loading a `.bin` file is much faster..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gensim.models import Word2Vec, KeyedVectors\n",
    "from gensim.scripts.glove2word2vec import glove2word2vec\n",
    "\n",
    "# Transform into w2v format\n",
    "glove_file = 'pretrained/glove.6B.300d.txt'\n",
    "tmp_file = 'pretrained/w2v_glove.6B.300d.txt'\n",
    "glove2word2vec(glove_file, tmp_file)\n",
    "\n",
    "# Import the backup model\n",
    "wv_backup = KeyedVectors.load_word2vec_format(tmp_file, binary=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also train a new model using all the questions and a vector of length 300, in order to use it as a **last resource**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train the second backup model\n",
    "w2v_model = Word2Vec(sentences, min_count=1, size=300, window=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's generate a new $x$ using the new Word2Vec pretrained models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = [sen2emb(sub, wv_ptrained, wv_backup, w2v_model.wv) for sub in sub_train]\n",
    "x_validation = [sen2emb(sub, wv_ptrained, wv_backup, w2v_model.wv) for sub in sub_validation]\n",
    "x_tv = np.concatenate((x_train, x_validation), axis=0)\n",
    "x_test = [sen2emb(sub, wv_ptrained, wv_backup, w2v_model.wv) for sub in sub_test]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate the labels for training, validation and testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = df_train['label'].values\n",
    "y_validation = df_validation['label'].values\n",
    "y_tv = np.concatenate((y_train, y_validation), axis=0)\n",
    "y_test = df_test['label'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Standarize $x$ for training, validation and testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = standarize(x_train)\n",
    "x_validation = standarize(x_validation)\n",
    "x_tv = standarize(x_tv)\n",
    "x_test = standarize(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic Regression ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tune hyperparameters and retrieve measures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/sklearn/metrics/classification.py:1143: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top regularization: 0.015577889516080402\n",
      "Top accuracy: 0.5729194903767959\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import precision_recall_fscore_support\n",
    "\n",
    "top_accuracy = 0;\n",
    "top_reg = 0;\n",
    "\n",
    "regs = np.linspace(1e-10, 0.05, 200)\n",
    "accs = []\n",
    "precs = []\n",
    "recs = []\n",
    "fscores = []\n",
    "\n",
    "for reg in regs:\n",
    "    lr_model = LogisticRegression(solver='lbfgs', multi_class='multinomial', C=reg, max_iter=5000)\n",
    "    lr_model.fit(x_train, y_train)\n",
    "    acc = lr_model.score(x_validation, y_validation)\n",
    "    accs.append(acc)\n",
    "    measures = precision_recall_fscore_support(y_validation, lr_model.predict(x_validation), average='macro')\n",
    "    precs.append(measures[0])\n",
    "    recs.append(measures[1])\n",
    "    fscores.append(measures[2])\n",
    "    if acc > top_accuracy:\n",
    "        top_accuracy = acc\n",
    "        top_reg = reg\n",
    "\n",
    "print(\"Top regularization:\", top_reg)\n",
    "print(\"Top accuracy:\", top_accuracy)\n",
    "\n",
    "# Retrain with whole training set and optimal penalty\n",
    "top_model = LogisticRegression(solver='lbfgs', multi_class='multinomial', C=top_reg, max_iter=10000)\n",
    "top_model.fit(x_tv, y_tv);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot measures vs. penalty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10,10))\n",
    "\n",
    "# Accuracy vs regularization\n",
    "axes[0][0].plot(regs, accs, lw=1.5)\n",
    "axes[0][0].set_xlabel('Regularization')\n",
    "axes[0][0].set_ylabel('Accuracy')\n",
    "axes[0][0].set_title('Accuracy vs. Regularization for LR')\n",
    "\n",
    "# Precision vs regularization\n",
    "axes[0][1].plot(regs, precs, lw=1.5)\n",
    "axes[0][1].set_xlabel('Regularization')\n",
    "axes[0][1].set_ylabel('Precision')\n",
    "axes[0][1].set_title('Precision vs. Regularization for LR')\n",
    "\n",
    "# Recall vs penalty\n",
    "axes[1][0].plot(regs, recs, lw=1.5)\n",
    "axes[1][0].set_xlabel('Regularization')\n",
    "axes[1][0].set_ylabel('Recall')\n",
    "axes[1][0].set_title('Recall vs. Regularization for LR')\n",
    "\n",
    "# FScore vs regularization\n",
    "axes[1][1].plot(regs, fscores, lw=1.5)\n",
    "axes[1][1].set_xlabel('Regularization')\n",
    "axes[1][1].set_ylabel('FScore')\n",
    "axes[1][1].set_title('FScore vs. Regularization for LR')\n",
    "\n",
    "# Adjust layout\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform test on test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Accuracy: 57.51%\n"
     ]
    }
   ],
   "source": [
    "print(\"LR Accuracy: %0.2f%%\" % (100 * top_model.score(x_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute confusion matrix, precision, recall and F-score with micro and macro averaging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "cf = confusion_matrix(y_test, top_model.predict(x_test))\n",
    "\n",
    "measures_macro = list(precision_recall_fscore_support(y_test, top_model.predict(x_test), average='macro'))[:-1]\n",
    "measures_micro = list(precision_recall_fscore_support(y_test, top_model.predict(x_test), average='micro'))[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show the confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "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>Predicted ilpt</th>\n",
       "      <th>Predicted lpt</th>\n",
       "      <th>Predicted slpt</th>\n",
       "      <th>Predicted ulpt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ilpt</th>\n",
       "      <td>1846</td>\n",
       "      <td>319</td>\n",
       "      <td>246</td>\n",
       "      <td>910</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lpt</th>\n",
       "      <td>195</td>\n",
       "      <td>6088</td>\n",
       "      <td>1903</td>\n",
       "      <td>1788</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slpt</th>\n",
       "      <td>140</td>\n",
       "      <td>2254</td>\n",
       "      <td>5313</td>\n",
       "      <td>2235</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ulpt</th>\n",
       "      <td>400</td>\n",
       "      <td>1744</td>\n",
       "      <td>1979</td>\n",
       "      <td>5852</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Predicted ilpt  Predicted lpt  Predicted slpt  Predicted ulpt\n",
       "ilpt            1846            319             246             910\n",
       "lpt              195           6088            1903            1788\n",
       "slpt             140           2254            5313            2235\n",
       "ulpt             400           1744            1979            5852"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cf_df = pd.DataFrame(cf, columns=['Predicted ilpt', 'Predicted lpt', 'Predicted slpt', 'Predicted ulpt'])\n",
    "cf_df.rename(index={0:'ilpt',1:'lpt',2:'slpt',3:'ulpt'}, inplace=True)\n",
    "cf_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show precision, recall and F-score with averaging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true
   },
   "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>Averaging</th>\n",
       "      <th>Precision</th>\n",
       "      <th>Recall</th>\n",
       "      <th>FScore</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>macro</td>\n",
       "      <td>0.601423</td>\n",
       "      <td>0.571827</td>\n",
       "      <td>0.583754</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>micro</td>\n",
       "      <td>0.575063</td>\n",
       "      <td>0.575063</td>\n",
       "      <td>0.575063</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Averaging  Precision    Recall    FScore\n",
       "0     macro   0.601423  0.571827  0.583754\n",
       "1     micro   0.575063  0.575063  0.575063"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "measures_macro = ['macro'] + measures_macro\n",
    "measures_micro = ['micro'] + measures_micro\n",
    "measures_df = pd.DataFrame([measures_macro, measures_micro], columns=['Averaging', 'Precision', 'Recall', 'FScore'])\n",
    "measures_df"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}