tips_pred_3.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": [
    "Embeddings must be generated for the instances in `df_train`, `df_validation` and `df_test`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 14,
   "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": 15,
   "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": [
    "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": 16,
   "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": [
    "### 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": 17,
   "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": 18,
   "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": 19,
   "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": 20,
   "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": 21,
   "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": 22,
   "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": 23,
   "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": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top regularization: 2.0\n",
      "Top accuracy: 0.6451248701621279\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": 25,
   "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": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Accuracy: 65.16%\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": 27,
   "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": 28,
   "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>2054</td>\n",
       "      <td>198</td>\n",
       "      <td>373</td>\n",
       "      <td>694</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lpt</th>\n",
       "      <td>137</td>\n",
       "      <td>6822</td>\n",
       "      <td>1678</td>\n",
       "      <td>1343</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slpt</th>\n",
       "      <td>81</td>\n",
       "      <td>1772</td>\n",
       "      <td>6107</td>\n",
       "      <td>1975</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ulpt</th>\n",
       "      <td>371</td>\n",
       "      <td>1386</td>\n",
       "      <td>1562</td>\n",
       "      <td>6652</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Predicted ilpt  Predicted lpt  Predicted slpt  Predicted ulpt\n",
       "ilpt            2054            198             373             694\n",
       "lpt              137           6822            1678            1343\n",
       "slpt              81           1772            6107            1975\n",
       "ulpt             371           1386            1562            6652"
      ]
     },
     "execution_count": 28,
     "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": 29,
   "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.674872</td>\n",
       "      <td>0.646065</td>\n",
       "      <td>0.658008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>micro</td>\n",
       "      <td>0.651559</td>\n",
       "      <td>0.651559</td>\n",
       "      <td>0.651559</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Averaging  Precision    Recall    FScore\n",
       "0     macro   0.674872  0.646065  0.658008\n",
       "1     micro   0.651559  0.651559  0.651559"
      ]
     },
     "execution_count": 29,
     "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": [
    "#### Support Vector Machine V2 ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tune hyperparameters and retrieve measures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top regularization: 3.0\n",
      "Top accuracy: 0.6495054870613738\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(2, 3, 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": 31,
   "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": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Accuracy: 65.53%\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": 33,
   "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": 34,
   "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>2075</td>\n",
       "      <td>188</td>\n",
       "      <td>365</td>\n",
       "      <td>691</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lpt</th>\n",
       "      <td>142</td>\n",
       "      <td>6909</td>\n",
       "      <td>1614</td>\n",
       "      <td>1315</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slpt</th>\n",
       "      <td>99</td>\n",
       "      <td>1753</td>\n",
       "      <td>6079</td>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ulpt</th>\n",
       "      <td>382</td>\n",
       "      <td>1373</td>\n",
       "      <td>1520</td>\n",
       "      <td>6696</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Predicted ilpt  Predicted lpt  Predicted slpt  Predicted ulpt\n",
       "ilpt            2075            188             365             691\n",
       "lpt              142           6909            1614            1315\n",
       "slpt              99           1753            6079            2004\n",
       "ulpt             382           1373            1520            6696"
      ]
     },
     "execution_count": 34,
     "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": 35,
   "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.676261</td>\n",
       "      <td>0.650224</td>\n",
       "      <td>0.661105</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>micro</td>\n",
       "      <td>0.655293</td>\n",
       "      <td>0.655293</td>\n",
       "      <td>0.655293</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Averaging  Precision    Recall    FScore\n",
       "0     macro   0.676261  0.650224  0.661105\n",
       "1     micro   0.655293  0.655293  0.655293"
      ]
     },
     "execution_count": 35,
     "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": [
    "#### Support Vector Machine V3 ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tune hyperparameters and retrieve measures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top regularization: 4.0\n",
      "Top accuracy: 0.6505441900374836\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(3, 4, 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": 37,
   "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": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Accuracy: 65.79%\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": 39,
   "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": 40,
   "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>2087</td>\n",
       "      <td>195</td>\n",
       "      <td>355</td>\n",
       "      <td>682</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lpt</th>\n",
       "      <td>147</td>\n",
       "      <td>6966</td>\n",
       "      <td>1584</td>\n",
       "      <td>1283</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slpt</th>\n",
       "      <td>100</td>\n",
       "      <td>1766</td>\n",
       "      <td>6063</td>\n",
       "      <td>2006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ulpt</th>\n",
       "      <td>394</td>\n",
       "      <td>1337</td>\n",
       "      <td>1511</td>\n",
       "      <td>6729</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Predicted ilpt  Predicted lpt  Predicted slpt  Predicted ulpt\n",
       "ilpt            2087            195             355             682\n",
       "lpt              147           6966            1584            1283\n",
       "slpt             100           1766            6063            2006\n",
       "ulpt             394           1337            1511            6729"
      ]
     },
     "execution_count": 40,
     "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": 41,
   "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.677482</td>\n",
       "      <td>0.652981</td>\n",
       "      <td>0.663257</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>micro</td>\n",
       "      <td>0.657883</td>\n",
       "      <td>0.657883</td>\n",
       "      <td>0.657883</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Averaging  Precision    Recall    FScore\n",
       "0     macro   0.677482  0.652981  0.663257\n",
       "1     micro   0.657883  0.657883  0.657883"
      ]
     },
     "execution_count": 41,
     "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
}