tips_pred_2.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": [
    "### 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": 11,
   "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": 12,
   "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": 13,
   "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": 14,
   "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": 15,
   "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": 16,
   "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": 17,
   "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": 18,
   "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": 19,
   "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": 20,
   "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": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top regularization: 1.7777777777777777\n",
      "Top accuracy: 0.6080281753736397\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(1, 2, 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": 22,
   "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": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Accuracy: 62.12%\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": 24,
   "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": 25,
   "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>2072</td>\n",
       "      <td>259</td>\n",
       "      <td>322</td>\n",
       "      <td>663</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lpt</th>\n",
       "      <td>214</td>\n",
       "      <td>6649</td>\n",
       "      <td>1730</td>\n",
       "      <td>1391</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slpt</th>\n",
       "      <td>107</td>\n",
       "      <td>2058</td>\n",
       "      <td>5700</td>\n",
       "      <td>2071</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ulpt</th>\n",
       "      <td>427</td>\n",
       "      <td>1621</td>\n",
       "      <td>1714</td>\n",
       "      <td>6203</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Predicted ilpt  Predicted lpt  Predicted slpt  Predicted ulpt\n",
       "ilpt            2072            259             322             663\n",
       "lpt              214           6649            1730            1391\n",
       "slpt             107           2058            5700            2071\n",
       "ulpt             427           1621            1714            6203"
      ]
     },
     "execution_count": 25,
     "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": 26,
   "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>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.641385</td>\n",
       "      <td>0.621741</td>\n",
       "      <td>0.630179</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>micro</td>\n",
       "      <td>0.621186</td>\n",
       "      <td>0.621186</td>\n",
       "      <td>0.621186</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Averaging  Precision    Recall    FScore\n",
       "0     macro   0.641385  0.621741  0.630179\n",
       "1     micro   0.621186  0.621186  0.621186"
      ]
     },
     "execution_count": 26,
     "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": 27,
   "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": 28,
   "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": 29,
   "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": 30,
   "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": 31,
   "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": 32,
   "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": 33,
   "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": 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: 1.0\n",
      "Top accuracy: 0.6268117578001535\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": 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 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": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Accuracy: 64.45%\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": 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>2011</td>\n",
       "      <td>218</td>\n",
       "      <td>410</td>\n",
       "      <td>677</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lpt</th>\n",
       "      <td>137</td>\n",
       "      <td>6836</td>\n",
       "      <td>1719</td>\n",
       "      <td>1292</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slpt</th>\n",
       "      <td>60</td>\n",
       "      <td>1778</td>\n",
       "      <td>6170</td>\n",
       "      <td>1928</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ulpt</th>\n",
       "      <td>350</td>\n",
       "      <td>1503</td>\n",
       "      <td>1730</td>\n",
       "      <td>6382</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Predicted ilpt  Predicted lpt  Predicted slpt  Predicted ulpt\n",
       "ilpt            2011            218             410             677\n",
       "lpt              137           6836            1719            1292\n",
       "slpt              60           1778            6170            1928\n",
       "ulpt             350           1503            1730            6382"
      ]
     },
     "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": 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>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.670924</td>\n",
       "      <td>0.638141</td>\n",
       "      <td>0.651542</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>micro</td>\n",
       "      <td>0.644529</td>\n",
       "      <td>0.644529</td>\n",
       "      <td>0.644529</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Averaging  Precision    Recall    FScore\n",
       "0     macro   0.670924  0.638141  0.651542\n",
       "1     micro   0.644529  0.644529  0.644529"
      ]
     },
     "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"
   ]
  }
 ],
 "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
}