annotation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pylab as plt\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.naive_bayes import BernoulliNB\n",
    "from sklearn.svm import LinearSVC\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.linear_model import Perceptron\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.linear_model import RidgeClassifier\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
    "from sklearn.model_selection import KFold, cross_val_score\n",
    "from sklearn.metrics import cohen_kappa_score\n",
    "\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from gensim.models.doc2vec import Doc2Vec, TaggedDocument\n",
    "\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk.corpus import stopwords\n",
    "\n",
    "import multiprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training data preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "data = pd.read_csv('./data/train_data.csv')\n",
    "label = pd.read_csv('./data/train_label.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>desc</th>\n",
       "      <th>tweet</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>none</td>\n",
       "      <td>mariotti did your ancestors have to apply thro...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>usmc veteran love god wife family dog and coun...</td>\n",
       "      <td>rule of law all the liberals including her wan...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>none</td>\n",
       "      <td>rt japanmissionun thank you unicef unhcr nyoff...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>we ve been referring people to law firms since...</td>\n",
       "      <td>know a good law firm in stirling immigration c...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>i love life i love my family i love people</td>\n",
       "      <td>wall street ally with a skepticism of immigrat...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                desc  \\\n",
       "0                                               none   \n",
       "1  usmc veteran love god wife family dog and coun...   \n",
       "2                                               none   \n",
       "3  we ve been referring people to law firms since...   \n",
       "4         i love life i love my family i love people   \n",
       "\n",
       "                                               tweet  label  \n",
       "0  mariotti did your ancestors have to apply thro...      0  \n",
       "1  rule of law all the liberals including her wan...      0  \n",
       "2  rt japanmissionun thank you unicef unhcr nyoff...      0  \n",
       "3  know a good law firm in stirling immigration c...      0  \n",
       "4  wall street ally with a skepticism of immigrat...      0  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['label'] = label['label']\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "desc     27\n",
       "tweet     0\n",
       "label     0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "desc     0\n",
       "tweet    0\n",
       "label    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = data.dropna().reset_index(drop = True)\n",
    "data.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3929, 3)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = data['desc'] + ' ' + data['tweet']\n",
    "Y = data['label']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3929,), (3929,))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape, Y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classification data praparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "_classification_data = pd.read_csv('./data/test_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(819, 2)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_classification_data = _classification_data.dropna().reset_index(drop = True)\n",
    "_classification_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "classification_data = _classification_data['text']\n",
    "classification_labels = _classification_data['label']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing feature extraction models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize(text):\n",
    "    return [word for word in word_tokenize(text.lower()) if word not in stopwords.words('english')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1min 5s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "vectorizer = TfidfVectorizer(tokenizer = tokenize)\n",
    "vectorized_data = vectorizer.fit_transform(X)\n",
    "classification_data = vectorizer.transform(classification_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1min 33s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "tagged_data = [TaggedDocument(words = tokenize(_d), tags=[str(i)]) for i, _d in enumerate(X)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "cores = multiprocessing.cpu_count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 6min 43s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "d2v_dm = Doc2Vec(tagged_data, dm=1, min_count=20, window=2, size=300, sample=6e-5, alpha=0.03, min_alpha=0.0007, negative=20, workers=cores-1)\n",
    "d2v_dbow = Doc2Vec(tagged_data, dm=0, min_count=20, window=2, size=300, sample=6e-5, alpha=0.03, min_alpha=0.0007, negative=20, workers=cores-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing methods to evaluate and store results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "results = dict()\n",
    "cross_val = dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def eval(clf_name, feat, y_test, predictions):\n",
    "    scores = dict()\n",
    "    \n",
    "    if clf_name not in results:\n",
    "        results[clf_name] = {'accuracy': [],\n",
    "                             'macro_precision': [], 'macro_recall': [], 'macro_f1': [],\n",
    "                             'micro_precision': [], 'micro_recall': [], 'micro_f1': []}\n",
    "    \n",
    "    results[clf_name]['accuracy'].append(accuracy_score(y_test, predictions))\n",
    "\n",
    "    results[clf_name]['macro_precision'].append(precision_score(y_test, predictions, average='macro'))\n",
    "    results[clf_name]['macro_recall'].append(recall_score(y_test, predictions, average='macro'))\n",
    "    results[clf_name]['macro_f1'].append(f1_score(y_test, predictions, average='macro'))\n",
    "\n",
    "    results[clf_name]['micro_precision'].append(precision_score(y_test, predictions, average='micro'))\n",
    "    results[clf_name]['micro_recall'].append(recall_score(y_test, predictions, average='micro'))\n",
    "    results[clf_name]['micro_f1'].append(f1_score(y_test, predictions, average='micro'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def cross(clf, clf_name, feat, X_train, Y_train):\n",
    "    kf = KFold(n_splits=10, random_state = 42, shuffle = True)\n",
    "    scores = cross_val_score(clf, X_train, Y_train, cv = kf)\n",
    "    \n",
    "    if clf_name not in cross_val:\n",
    "        cross_val[clf_name] = {feat: scores}\n",
    "    else:\n",
    "        cross_val[clf_name].update({feat: scores})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pred(clf_name, predictions):\n",
    "    preds[clf_name] = predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "classification_acc = dict()\n",
    "classification_pre = dict()\n",
    "classification_rec = dict()\n",
    "classification_f1 = dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classify(clf, clf_name): \n",
    "    predictions = clf.predict(classification_data)\n",
    "    \n",
    "    acc = accuracy_score(classification_labels, predictions)\n",
    "    pre = precision_score(classification_labels, predictions, average='macro')\n",
    "    rec = recall_score(classification_labels, predictions, average='macro')\n",
    "    f1 = f1_score(classification_labels, predictions, average='macro')\n",
    "    \n",
    "    classification_acc[clf_name] = acc\n",
    "    classification_pre[clf_name] = pre\n",
    "    classification_rec[clf_name] = rec\n",
    "    classification_f1[clf_name] = f1\n",
    "    \n",
    "    pred(clf_name, predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing methods for training and classification purpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def split(X, Y):\n",
    "    return train_test_split(X, Y, test_size = .4, shuffle = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def resample(d, l):\n",
    "    sm = SMOTE(random_state=42, ratio=1.0)\n",
    "    return sm.fit_sample(d, l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def train_tfidf(clf, clf_name, X, Y):\n",
    "    X_train, X_test, Y_train, Y_test = split(X, Y)\n",
    "    X_train, Y_train = resample(X_train, Y_train)\n",
    "    \n",
    "    clf.fit(X_train, Y_train)\n",
    "    predictions = clf.predict(X_test)\n",
    "    \n",
    "    cross(clf, clf_name, feats[0], X_train, Y_train)\n",
    "    eval(clf_name, feats[0], Y_test, predictions)\n",
    "    \n",
    "    # In former runs, we identified that TF-IDF gives best results compared to PV-DM and PV-DBOW. Therefore, we will only perform classification using TF-IDF method.\n",
    "    classify(clf, clf_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def train_d2v(model, feat, clf, clf_name, X, Y):\n",
    "    X_train, X_test, Y_train, Y_test = split(X, Y)\n",
    "    \n",
    "    x_train = []\n",
    "    y_train = []\n",
    "    x_test = []\n",
    "    y_test = []\n",
    "\n",
    "    for i in range(X_train.shape[0]):\n",
    "        x_train.append(model[str(i)])\n",
    "        y_train.append(Y_train[i])\n",
    "    \n",
    "    for i in range(X_test.shape[0]):\n",
    "        x_test.append(model[str(i + X_train.shape[0])])\n",
    "        y_test.append(Y_test[i + X_train.shape[0]])\n",
    "        \n",
    "    x_train, y_train = resample(x_train, y_train)\n",
    "    clf.fit(x_train, y_train)\n",
    "    predictions = clf.predict(x_test)\n",
    "    \n",
    "    cross(clf, clf_name, feat, x_train, y_train)\n",
    "    eval(clf_name, feat, y_test, predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training and classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfs = [BernoulliNB(), LinearSVC(), SGDClassifier(), Perceptron(), LogisticRegression(), RidgeClassifier()]\n",
    "clf_names = ['Naive Bayes', 'Linear SVC', 'Stochastic Gradient Descent', 'Perceptron', 'Logistic Regression', 'Ridge Regression']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "feats = ['TF-IDF', 'PV-DM', 'PV-DBOW']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 51.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for i in range(len(clfs)):\n",
    "    train_tfidf(clfs[i], clf_names[i], vectorized_data, Y)\n",
    "    train_d2v(d2v_dm, feats[1], clfs[i], clf_names[i], X, Y)\n",
    "    train_d2v(d2v_dbow, feats[2], clfs[i], clf_names[i], X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Just printing and ploting everything we have got!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classifier: Naive Bayes\n",
      "\n",
      "\t\t\tTF-IDF\t\tPV-DM\t\tPV-DBOW\n",
      " ----------------------------------------------------------------\n",
      "accuracy            :\t0.890585\t0.529262\t0.141858\n",
      "macro_precision     :\t0.770645\t0.501690\t0.497901\n",
      "macro_recall        :\t0.849891\t0.503517\t0.499922\n",
      "macro_f1            :\t0.801227\t0.439869\t0.126114\n",
      "micro_precision     :\t0.890585\t0.529262\t0.141858\n",
      "micro_recall        :\t0.890585\t0.529262\t0.141858\n",
      "micro_f1            :\t0.890585\t0.529262\t0.141858\n",
      "\n",
      "Classifier: Linear SVC\n",
      "\n",
      "\t\t\tTF-IDF\t\tPV-DM\t\tPV-DBOW\n",
      " ----------------------------------------------------------------\n",
      "accuracy            :\t0.921120\t0.347328\t0.181298\n",
      "macro_precision     :\t0.836249\t0.490092\t0.544810\n",
      "macro_recall        :\t0.831054\t0.482573\t0.517044\n",
      "macro_f1            :\t0.833620\t0.329832\t0.174466\n",
      "micro_precision     :\t0.921120\t0.347328\t0.181298\n",
      "micro_recall        :\t0.921120\t0.347328\t0.181298\n",
      "micro_f1            :\t0.921120\t0.347328\t0.181298\n",
      "\n",
      "Classifier: Stochastic Gradient Descent\n",
      "\n",
      "\t\t\tTF-IDF\t\tPV-DM\t\tPV-DBOW\n",
      " ----------------------------------------------------------------\n",
      "accuracy            :\t0.922392\t0.298346\t0.861323\n",
      "macro_precision     :\t0.846286\t0.493672\t0.430662\n",
      "macro_recall        :\t0.816399\t0.490700\t0.500000\n",
      "macro_f1            :\t0.830313\t0.292817\t0.462748\n",
      "micro_precision     :\t0.922392\t0.298346\t0.861323\n",
      "micro_recall        :\t0.922392\t0.298346\t0.861323\n",
      "micro_f1            :\t0.922392\t0.298346\t0.861323\n",
      "\n",
      "Classifier: Perceptron\n",
      "\n",
      "\t\t\tTF-IDF\t\tPV-DM\t\tPV-DBOW\n",
      " ----------------------------------------------------------------\n",
      "accuracy            :\t0.907761\t0.138677\t0.861323\n",
      "macro_precision     :\t0.806302\t0.069338\t0.430662\n",
      "macro_recall        :\t0.809830\t0.500000\t0.500000\n",
      "macro_f1            :\t0.808050\t0.121788\t0.462748\n",
      "micro_precision     :\t0.907761\t0.138677\t0.861323\n",
      "micro_recall        :\t0.907761\t0.138677\t0.861323\n",
      "micro_f1            :\t0.907761\t0.138677\t0.861323\n",
      "\n",
      "Classifier: Logistic Regression\n",
      "\n",
      "\t\t\tTF-IDF\t\tPV-DM\t\tPV-DBOW\n",
      " ----------------------------------------------------------------\n",
      "accuracy            :\t0.903308\t0.332697\t0.169847\n",
      "macro_precision     :\t0.791326\t0.483743\t0.552231\n",
      "macro_recall        :\t0.864974\t0.472155\t0.514246\n",
      "macro_f1            :\t0.820993\t0.317708\t0.160600\n",
      "micro_precision     :\t0.903308\t0.332697\t0.169847\n",
      "micro_recall        :\t0.903308\t0.332697\t0.169847\n",
      "micro_f1            :\t0.903308\t0.332697\t0.169847\n",
      "\n",
      "Classifier: Ridge Regression\n",
      "\n",
      "\t\t\tTF-IDF\t\tPV-DM\t\tPV-DBOW\n",
      " ----------------------------------------------------------------\n",
      "accuracy            :\t0.919211\t0.333333\t0.174300\n",
      "macro_precision     :\t0.828839\t0.483980\t0.554762\n",
      "macro_recall        :\t0.837644\t0.472524\t0.516831\n",
      "macro_f1            :\t0.833149\t0.318227\t0.165874\n",
      "micro_precision     :\t0.919211\t0.333333\t0.174300\n",
      "micro_recall        :\t0.919211\t0.333333\t0.174300\n",
      "micro_f1            :\t0.919211\t0.333333\t0.174300\n"
     ]
    }
   ],
   "source": [
    "for c in results:\n",
    "    print('\\nClassifier: {}'.format(c))\n",
    "    print('\\n\\t\\t\\t{}\\t\\t{}\\t\\t{}\\n'.format(feats[0], feats[1], feats[2]), '-' * 64)\n",
    "    for s in results[c]:\n",
    "        print('{:20s}:\\t{:f}\\t{:f}\\t{:f}'.format(s, results[c][s][0], results[c][s][1], results[c][s][2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bar_plot(clf_name, scores):\n",
    "    index = np.arange(len(feats))\n",
    "    plt.barh(index, scores, color=['royalblue', 'cornflowerblue', 'lightsteelblue'])\n",
    "    plt.xlabel('Recall', fontsize = 10)\n",
    "    plt.ylabel('Feature extraction method', fontsize = 10)\n",
    "    plt.yticks(index, feats, fontsize = 10)\n",
    "    plt.gcf().subplots_adjust(left = 0.25)\n",
    "    plt.title(clf_name)\n",
    "    plt.savefig('_'.join(clf_name.split()).lower() + '_acc.png')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for c in results:\n",
    "    clf_name = c\n",
    "    scores = [results[c]['macro_recall'][0], results[c]['macro_recall'][1], results[c]['macro_recall'][2]]\n",
    "    bar_plot(clf_name, scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def fold_plot(clf_name):\n",
    "    plt.xlabel('Fold as test set')\n",
    "    plt.ylim(0.4, 1)\n",
    "    plt.ylabel('Score')\n",
    "    plt.plot(np.arange(1, 11), cross_val[clf_name]['TF-IDF'], color='blue')\n",
    "    plt.plot(np.arange(1, 11), cross_val[clf_name]['PV-DM'], color='red', linestyle='dashed')\n",
    "    plt.plot(np.arange(1, 11), cross_val[clf_name]['PV-DBOW'], color='green', linestyle='dotted')\n",
    "    plt.legend(['TF-IDF', 'PV-DM', 'PV-DBOW'], loc='best')\n",
    "    plt.title(clf_name)\n",
    "    plt.savefig('_'.join(clf_name.split()).lower() + '_fold.png')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl8FeXZ//HPRVgCBNlBVkFQEBAQUkRATdXHBzcsVAsUi7hRf7ZWbCmKK7VS17ovjyiIVRRcKFpFUetCK6Ag+yLIJoRF9gAmkO36/TEnQxKyATk5Ab7v12temeWemeucJHPNfc/MPebuiIiIAFSIdQAiIlJ+KCmIiEhISUFEREJKCiIiElJSEBGRkJKCiIiElBRERCSkpCDHFDNba2ZpZrbXzH40s5fNLCHWceWIxHdBrOMQKYySghyLLnP3BKAL8DPgrkNZ2cwqRiWqcr5vEVBSkGOYu28APgQ6mFlNMxtrZpvMbIOZ3W9mcQBmNsTMvjKzx81sBzAqMv8GM1tmZnvMbKmZdYnMb2xm75jZVjNbY2Z/yNmnmY0ys7fNbFJkvblm1imy7FWgOfCvSE1mhJm1MDM3s+vMbB3wWaRsHzNbYma7zOwLMzst1z7WmtlwM1toZimRfcWXyZcqxzwlBTlmmVkz4GJgHvAKkAm0Bs4ALgSuz1X8TGA10AAYbWZXEiSHwcAJQB9gu5lVAP4FLACaAOcDw8zsf3Nt63LgLaAO8DowxcwquftvgHVEajLu/nCudc4FTgP+18xOBd4AhgH1gakEiaRyrvK/AnoDLYGOwJDD+5ZE8lJSkGPRFDPbBfwX+BJ4CbgIGObuP7n7FuBxYECudTa6+9PununuaQQJ42F3n+2Ble7+A0FzVH13v8/d0919NfBivm196+5vu3sG8BgQD3QvJuZRkdjSgP7AB+7+SWQbjwJVgR65yj/l7hvdfQdBkup8GN+TyEHUfinHol+4+6c5E2bWDagEbDKznNkVgPW51sk9DtAMWFXAtk8CGkeSTo444D8Fbcvds80sGWhcTMy5998Y+CHfNtYT1ExybM41nlqC7YuUiJKCHA/WA/uBeu6eWUiZ/N0FrwdaFbKtNe5+ShH7a5YzEmluagpsLGQ/Be1/I3B6rm1YZJsbitinSKlQ85Ec89x9E/Ax8HczO8HMKphZKzM7t4jVXgKGm1lXC7Q2s5OAb4DdZnabmVU1szgz62BmP8u1blcz6xe5k2gYQUKaFVn2I3ByMSG/CVxiZuebWSXgT5FtzDjkDy9yiJQU5HgxGKgMLAV2Am8DjQor7O5vAaMJLhTvAaYAddw9C7iMoA1/DbCNIIHUzLX6uwTXBXYCvwH6Ra4NADwA3BW5q2h4IfteDlwFPB3Z/mUEF6fTD/1jixwa00t2REqPmY0CWrv7VbGOReRwqKYgIiKhqCUFMxtnZlvMbHEhy83MnjKzlZGHcLpEKxYRESmZqDUfmdk5wF7gH+7eoYDlFwM3EzxcdCbwpLufGZVgRESkRKJWU3D36cCOIopcTpAw3N1nAbXMrNALfyIiEn2xfE6hCXkf2EmOzNuUv6CZDQWGAlSvXr1r27ZtyyRAEZFjxbfffrvN3esXVy6WScEKmFdgW5a7jwHGACQmJvqcOXOiGZeIyDHHzH4ovlRs7z5KJteTn+R96lNERGIglknhPWBw5C6k7kBK5MlTERGJkag1H5nZG0ASUC/SIdi9BJ2S4e7/R9Ad8MXASoIOva6JViwiIiXhDunpsH9/3p9Vq0LdulCpUqwjjL6oJQV3H1jMcgd+F639i8jRJzsbdu2CbduCYc+evAfowsZLa3lGRtHx1awJ9eodPNStW/D8OnUgLq5svrvSol5SRSQq3CEl5cABPmfYvv3geTnDjh1BYjhUVaocGCpXLni8alWoVavw5QWNV64cDKmpB8e6aRMsWhSMp6YWHJcZ1K5deNIoKLHUrg0VYtiwr6QgIsVyD87aS3Jgz1m2fTtkFtJRecWKeQ+IHToUfIA84YTiD94VKwYH31hKTT34OynoO1q3DubODcb37y94WxUqBDWMgr6Pfv2gW7fofhYlBZFjnDvs2xcc1HfvDn7mH88/vWvXwQe1wppW4uLyngm3aQM9ehR9VlyjRuwP5KWpWrVgaNas+LIQ/E4Kqn0UlFBWrYKvvw7GTzlFSUFKwc6dsGYNrF4d/FyzBtauDZY1aQKNGx/8s3792FZhj3fZ2fDTTwUfsIs6mBdWNiurZPutXj04YOe0nZ98cnAQKqoNvWZN/a0cKrPgu65eHU46qWTruB9e09qhUlI4BqSlBQf53Af93ENKSt7ytWtDy5bB+Lx58OOPwR9cbpUqQaNGBSeM3D9r1CiTj3jUKuqMsKDmhR07ggP53r0H/04KUqFC8Ds44YTgZ87QuHHe6YLK5J9OSDj6LooeT8zK5vdz3CSFHTuCg2POP0LlyrGOqOQyM2H9+oIP+GvWwObNectXrRoc9Fu2hF69DoznDDVr5i2fkREkhg0bYOPGg38uXQqffBIcrPJLSCg6aTRpAieeeHR930VJSyu+TT3/QX/fvoK3lb/tuFUr+NnPgr/R4g7gOdNVqx5bzTASe8dNUhg7FkaMODBduXLJzp6Km65RI2hLPJJ/THfYsqXwM/116/JW/+PigrbLk0+GSy45+KDfsOGhxVOpEjRtGgxF2bs3SBIFJY4NG+C//w3G0wt4P1iDBgUnjsaNgwNbrGVlBc1sxV1ILewuEzhwgK9bF5o3hy5dir7TpFYtnZlL+XPUvXntcPs+WrIEZs8+tDbZQ63ClzSRpKfnPeivXXvwwaZhwwMH+ZNPznvQb9YsuOOiPHIPDqi5k0VBCWTLllhHWrRDvR+9du3y+zsRATCzb909sdhyx0tSOBzZ2cHB+lAu7BU1nfv2vBNOyHugz33gb9EiqH0cy9LTg2avwmoWZS3nfvKcA//x8OSqHF9KmhR0blOEChWCNvOEhCPflntwX/KePUGTQe3ax3dbcOXKQRNL8+axjkREclNSKCNmEB8fDCIi5ZXuLhYRkZCSgoiIhJQUREQkpKQgIiIhJQUREQkpKYiISEhJQUREQkoKIiISUlIQEZGQkoKIiISUFEREJKSkICIiISUFEREJKSmIiEhISUFEREJKCiIiEopqUjCz3ma23MxWmtntBSw/ycz+bWYLzewLMyvm1fEiIhJNUUsKZhYHPAtcBLQDBppZu3zFHgX+4e4dgfuAB6IVj4iIFC+aNYVuwEp3X+3u6cBE4PJ8ZdoB/46Mf17AchERKUPRTApNgPW5ppMj83JbAPwyMt4XqGFmdaMYk4iIFCGaScEKmOf5pocD55rZPOBcYAOQedCGzIaa2Rwzm7N169bSj1RERIDoJoVkoFmu6abAxtwF3H2ju/dz9zOAOyPzUvJvyN3HuHuiuyfWr18/iiGLiBzfopkUZgOnmFlLM6sMDADey13AzOqZWU4MI4FxUYxHRESKEbWk4O6ZwO+BacAy4E13X2Jm95lZn0ixJGC5ma0AGgKjoxWPiIgUz9zzN/OXb4mJiT5nzpxYhyEiclQxs2/dPbG4cnqiWUREQkoKIiISUlIQEZGQkoKIiISUFEREJKSkICIiISUFEREJKSmIiEhISUFEREJKCiIiElJSEBGRkJKCiIiElBRERCSkpCAiIiElBRERCSkpiIhISElBRERCSgoiIhJSUhARkZCSgoiIhJQUREQkpKQgIiIhJQUREQkpKYiISEhJQUREQkoKIiISUlIQEZGQkoKIiISimhTMrLeZLTezlWZ2ewHLm5vZ52Y2z8wWmtnF0YxHRESKFrWkYGZxwLPARUA7YKCZtctX7C7gTXc/AxgAPBeteEREpHjRrCl0A1a6+2p3TwcmApfnK+PACZHxmsDGKMYjIiLFiGZSaAKszzWdHJmX2yjgKjNLBqYCNxe0ITMbamZzzGzO1q1boxGriIgQ3aRgBczzfNMDgfHu3hS4GHjVzA6Kyd3HuHuiuyfWr18/CqGKiAhENykkA81yTTfl4Oah64A3Adx9JhAP1ItiTCIiUoRoJoXZwClm1tLMKhNcSH4vX5l1wPkAZnYaQVJQ+5CISIxELSm4eybwe2AasIzgLqMlZnafmfWJFPsTcIOZLQDeAIa4e/4mJhERKSMVo7lxd59KcAE597x7co0vBXpGMwYRESk5PdEsIiIhJQUREQkpKYiISEhJQUREQkoKIiISUlIQEZFQVG9JFREpTkZGBsnJyezbty/WoRwT4uPjadq0KZUqVTqs9ZUURCSmkpOTqVGjBi1atMCsoC7TpKTcne3bt5OcnEzLli0PaxtqPhKRmNq3bx9169ZVQigFZkbdunWPqNalpCAiMaeEUHqO9LtUUhARkZCuKYjIcW379u2cf/75AGzevJm4uDhy3tuyYMECOnXqFJadMmUKLVq0yLP+kCFDuPTSS7niiitISkpi06ZNVKlShfT0dC644ALuv/9+atWqBUBcXBynn356kduLNSUFETmu1a1bl/nz5wMwatQoEhISGD58OAAJCQnhspKaMGECiYmJpKenM3LkSC6//HK+/PJLAKpWrXrI2ytraj4SEYmCypUr8/DDD7Nu3ToWLFgQ63BKTDUFESk3hg2D0j6R7twZnnji8NZNS0ujc+fOALRs2ZJ//vOfh7R+XFwcnTp14rvvvqNTp05HvL2yoKQgIlKI0mjuyf3esKOh+UhJQUTKjcM9oy9L11xzDfPmzaNx48ZMnTq1yLJZWVksWrSI0047rYyiO3JKCiIih+Dll18uUbmMjAzuvPNOmjVrRseOHaMcVelRUhARKUWDBg2iSpUq7N+/nwsuuIB333031iEdEsvd3lVkQbNewCnu/rKZ1QcS3H1NVKMrQGJios+ZM6esdysiUbJs2bKjqnnlaFDQd2pm37p7YnHrluiWVDO7F7gNGBmZVQl47RDjFBGRcq6kzyn0BfoAPwG4+0agRrSCEhGR2ChpUkj3oJ3JAcysevRCEhGRWClpUnjTzF4AapnZDcCnwIvRC0tERGKhRHcfufujZvY/wG6gDXCPu38S1chERKTMFZsUzCwOmObuFwBKBCIix7Bim4/cPQtINbOaZRCPiEiZi4uLo3PnznTo0IErr7yS1NRUkpKSmDZtWp5yTzzxBDfddNNB648aNYomTZrQuXNnTjnlFPr168fSpUvD5UlJSTRv3jxPlxe/+MUvSEhIiN6HOkwlvaawD1hkZmPN7KmcobiVzKy3mS03s5VmdnsByx83s/mRYYWZ7TrUDyAicqRy+iRavHgxlStX5v/+7/8YOHAgEydOzFNu4sSJDBw4sMBt3HrrrcyfP5/vv/+e/v37c95557F169Zwea1atfjqq68A2LVrF5s2bYreBzoCJU0KHwB3A9OBb3MNhYo0Oz0LXAS0AwaaWbvcZdz9Vnfv7O6dgaeByYcWvohI6Tr77LNZuXIlV1xxBe+//z779+8HYO3atWzcuJFevXoVu43+/ftz4YUX8vrrr4fzBgwYECaZyZMn069fv+h8gCNU0gvNr5hZZeDUyKzl7p5RzGrdgJXuvhrAzCYClwNLCyk/ELi3JPGIyDEsKengeb/6Fdx0E6SmwsUXH7x8yJBg2LYNrrgi77IvvijxrjMzM/nwww/p3bs3devWpVu3bnz00UdcfvnlTJw4kf79+5f4HchdunThu+++C6fPP/98brjhBrKyspg4cSJjxozhr3/9a4ljKyslfaI5Cfie4Mz/OWCFmZ1TzGpNgPW5ppMj8wra/klAS+CzQpYPNbM5ZjYnd3VMRKQ05LznIDExkebNm3PdddcB5GlCKqrpqCD5uxCKi4ujV69eTJo0ibS0tHL3Gs4cJe0Q7+/Ahe6+HMDMTgXeALoWsU5B6bSwjpYGAG9HLmofvJL7GGAMBH0flTBmETkaFXVmX61a0cvr1TukmkGOwt5z8Itf/II//vGPzJ07l7S0NLp06QLAnXfeyQcffABQ6PsR5s2bR2Ji3q6GBgwYQN++fRk1atQhx1hWSnpNoVJOQgBw9xUE/R8VJRlolmu6KbCxkLIDCJKMiEi5kZCQQFJSEtdee22eWsLo0aOZP39+oQnhnXfe4eOPPz6oZnH22WczcuTIQ6pxlLWS1hTmmNlY4NXI9CCKudAMzAZOMbOWwAaCA/+v8xcyszZAbWBmCWMRESkzAwcOpF+/fgfdiZTf448/zmuvvcZPP/1Ehw4d+Oyzz6hfv36eMmbG8OHDoxnuEStR19lmVgX4HdCLoFloOvCcu+8vZr2LgSeAOGCcu482s/uAOe7+XqTMKCDe3Q+6ZbUg6jpb5NiirrNL35F0nV3SmkJF4El3fyyy8TigSnEruftUYGq+effkmx5VwhhERCTKSnpN4d9A1VzTVQk6xRMRkWNISZNCvLvvzZmIjFeLTkgiIhIrJU0KP5lZl5wJM0sE0qITkoiIxEpJrykMA94ys40Ezxo0BvpHLSoREYmJImsKZvYzMzvR3WcDbYFJQCbwEbCmDOITEZEyVFzz0QtAemT8LOAOgq4udhJ5wlhE5GhXFl1nt2nThs6dO3PaaacxZsyBw2dKSgqDBw+mVatWtGrVisGDB5OSkgJA3759mTJlSli2TZs23H///eH0L3/5SyZPLt1+RItLCnHuviMy3h8Y4+7vuPvdQOtSjUREJEbKouvsCRMmMH/+fL766ituu+020tOD8+3rrruOk08+mVWrVrFq1SpatmzJ9ddfD0CPHj2YMWMGANu3bychIYGZMw885ztz5kx69OhRqt9FsUnBzHKuO5xP3g7rSno9QkTkqBGtrrNz7N27l+rVqxMXF8fKlSv59ttvufvuu8Pl99xzD3PmzGHVqlX07NkzTAozZszg0ksvZevWrbg7a9asoWrVqpx44oml9MkDxSWFN4AvzexdgruN/gNgZq2BlFKNREQESBqfxPj54wHIyMogaXwSry18DYDUjFSSxicxafEkAFL2pZA0PonJy4ImlG2p20gan8S/lv8LgM17Nx/SvnO6zj799NPzdJ0NHHHX2YMGDaJjx460adOGu+++m7i4OJYuXUrnzp2Ji4sLy+U0ZS1ZsoSuXbuyePFi0tPTmTFjBmeddRZt2rRh2bJlzJgxg549ex7S5yuJIpOCu48G/gSMB3r5gT4xKgA3l3o0IiIxUBZdZ0+YMIGFCxeybt06Hn30UX744QfcvcAkkzO/SpUqtG/fnrlz5zJr1izOPPNMzjrrLGbMmMGMGTNKvekIStAE5O6zCpi3otQjEREBvhjyRTheKa5Snulqlarlma4ZXzPPdL1q9fJMn5hQsqaVsuo6G6B+/fp06dKFr7/+mi5dujBv3jyys7OpUCE4R8/OzmbBggVh30U9evRg+vTp7Nmzh9q1a9O9e3eeeeYZ5s2bx4033liiz3coSvrwmojIcae0u84GSE1NZd68ebRq1YrWrVtzxhln5Lmj6P7776dLly60bh3cy9OzZ09eeOEFOnXqBEDHjh2ZNWsW69ato3379qX5cQElBRGRIg0cOJAFCxYwYMCAIss9/vjj4S2pr7322kFdZw8aNIjOnTvTtWtXhgwZQteuwTvKxo4dy4oVK2jdujWtWrVixYoVjB07NlyvR48erF69mrPOOguAihUr0qBBAxITE8PaRWkqUdfZ5Ym6zhY5tqjr7NJ3JF1nq6YgIiIhJQUREQkpKYhIzB1tzdjl2ZF+l0oKIhJT8fHxbN++XYmhFLg727dvJz4+/rC3oa4qRCSmmjZtSnJycp5+guTwxcfH07Rp08NeX0lBRGKqUqVKtGzZMtZhSISaj0REJKSkICIiISUFEREJKSmIiEhISUFEREJKCiIiElJSEBGRUFSTgpn1NrPlZrbSzG4vpMyvzGypmS0xs4NfaCoichxbtnUZS7YsKbP9Re3hNTOLA54F/gdIBmab2XvuvjRXmVOAkUBPd99pZg2iFY+IyNHolo9uYcX2FXx/8/dUiqsU9f1F84nmbsBKd18NYGYTgcuBpbnK3AA86+47Adx9SxTjERE56rza91XW7FpTJgkBott81ARYn2s6OTIvt1OBU83sKzObZWa9C9qQmQ01szlmNkf9o4jI8SB5dzLuTsOEhnRv2r3M9hvNpGAFzMvfDWJF4BQgCRgIvGRmtQ5ayX2Muye6e2Lu19uJiByLtqVuI3FMIrd/WuCl2KiKZvNRMtAs13RTYGMBZWa5ewawxsyWEySJ2VGMS0SkXKtTtQ7Dewznf1v9b5nvO5o1hdnAKWbW0swqAwOA9/KVmQL8HMDM6hE0J62OYkwiIuVaVnYWFawCw3sM5/SGp5f5/qOWFNw9E/g9MA1YBrzp7kvM7D4z6xMpNg3YbmZLgc+BP7v79mjFJCJSni36cRHtn2vPgs0LYhZDVN+n4O5Tgan55t2Ta9yBP0YGEZHjWnpWOvWq1aNRjUYxi0Ev2RERKSe6Nu7Kf675D2YF3adTNtTNhYhIjE39fiqjp48mKzsrpgkBlBRERGLuw+8/5M2lb5KRnRHrUNR8JCISa09d9BQp+1OIrxgf61BUUxARiZUp301h456NmBm14g96bjcmlBRERGJgz/49XPfedTF5arkoaj4SEYmBGlVqMOPaGdSpWifWoeShmoKISBlbujXoLLpNvTbUr16++nNTUhARKUOfrv6U9s+1Z8p3U2IdSoGUFEREylCv5r148PwHuaj1RbEOpUC6piAiUgayPZvM7EziK8ZzW6/bYh1OoVRTEBEpA0/OepKzxp7FzrSdsQ6lSEoKIiJloFWdVnRq2KncPI9QGDUfiYiUgT5t+tCnTZ/iC8aYagoiIlE04pMR/GPBP2IdRompplDWUlJg1SqoVg3atg3mLV0K+/blLVejBpxySjC+eDGkp+ddXqsWnHxyML5gAWRl5V1epw60aBGMz5sHnu/12PXrQ7NmiEj07M/cz9cbvsbz//+VY3Y0BQuQmJjoc+bMiXUYh2b3bnjvPXjzTZg2LTjAn3kmzJoVLO/YERYtyrvOBRfAJ58E4y1bwtq1eZf37QuTJwfj9erB9nwvrBs8GF55JRiPj4f9+/Mu/93v4JlngmSxezfUrHnEH1NEDpaVnUW2Z1MprlJM4zCzb909sbhyqilES2pqUBsAGDoUJk2Cpk3h97+HXr2CA3mOp54KDsy51c/1lOOLLwbby+3EEw+Mv/bawTWJpk0PjL/9NmRn512eU4v44gvo0yeI649/zLtfETks2Z7NYzMf47ddf0uNKjWIIy7WIZWYagqlae9e+OCDoEYwdWpw9t+6NcybR3rqHrZ3aEWjmk2Coul7SaicEOOAgRUr4N57g6RVtSrcdBMMHw4NG8Y6MpGj1oz1Mzj75bMZf/l4ftPpN7EOByh5TUEXmkvDmjVw5ZXQoAEMGAAzZ7Jr6GAW7F4RLD/jDHotHc6Qf10LBGcR7Z9rXz56Rzz1VHjjDViyBPr1g8ceC5q28l+jEJES69GsBwtuXMBVHa+KdSiHTEnhcKSlwTvvBNcHAGrWZMOir5h643nw5Zewfj039NrB5dNvClcZ0XMEN3e7GQguPg3tMpRzTzoXgJR9KQx8ZyALNi8o848SOu00ePVV+O47eP55iIuDzEy45x5Yvz52cYkcRVIzUsP/4w4NOsT81ZqHxd2PqqFr164eE2lp7v/8p/vAge7Vq/uaWviz13TwzKxMd3e/89M7PO4vcb5n/x53d5+1fpb/e/W/PTs7u9hNz1w/0+s/XN9nrZ/l7u7rdq3zWetnlWjdqJo5071iRfdKldx/+1v3NWtiG49IOXfbJ7d5lb9W8eSU5FiHchBgjpfgGKtrCkXJygrOmIEf+pzDK7v/w29X1abhxVfyalJtBq94iEX/bxEdGnRg7a617EzbSceGHYmrcOgXlTKyMqhYoSJmxl2f3cUD/32AjX/cSMOEhmRkZcTuzoUffoCHHoKxY4OL1YMHwxNPBLfMikge21O389HKjxjUcVCsQzlISa8pKCnkl54OH3/M5nde4aFd73PVg1Pp2ubnfPPuc3Sf/3um9n+P3m0vJWVfCrv27eKkWieVeggp+1KYmTyT3q17AzDwnYGkZqTy7oB3S31fJZacDA8/DF99BbNnQ4UKsGePkoMIsHv/bmpUrlGum4t0ofkQ/bRsAUP+3Jo3e9WCyy6jyocfM6ZjJos3zAOgy2VD2XHbDnq3vRSAmvE1o5IQcradkxAAujfpTs9mPcPpEZ+M4PM1n0dl34Vq2jS4dfabbw4khFat4KqrYNmyso1FpBzJ9mz6TepH/7f7xzqUUnHcJYWcmpGnp9P/6XO57/XfAlAtripz09awqXsH+OADaq/bSsq9aVx93h8BqFihYsw6srql+y2M6DkCgB1pO3h14avM2xwkq8zsTGasn1F2T0xGmtPIyoJrroEpU6B9++Cuq8WLyyYGOebt3r+bR756hPdXvB/rUIplGH3b9uXiUy6OdSil4rhqPho8+SrSNq7jrYVtYfJkrj57O22aduKOp+cHBdLToXLlUow2OjKzM8nIyqBqpap8+P2HXPz6xbw/8H0uOfWS4EJRWVZht22Dxx+Hp58Oag/ffQdt2pTd/g9XVhasXAkLFzJ+739Z27I2o5JGwSuvsLjSThqcfDoN2nYNuhORqMv2bJ6b/Rwta7XkklMvITUjlVoP1uKlPi8xuNNgUval8PL8l/n16b+mQfUGsQ73qFTS5qOo3ikE9AaWAyuB2wtYPgTYCsyPDNcXt80jufvowV8397+ci3tCgvuvf+0+ZUpwV9FRbM/+Pf6P+f/w/Zn73d39ma+f8TNfPNNT9qWUbSDbt7uPHXtg+oUX3GfPLtsYCpOaemD8zjt9xbmn+5udK7sHnXz4Rb+r5ddOuTZYXrOmn/p7/Je/CpZ5rVp+x53d/e0lbwfLX3zRMz/4l/uyZUf9306sTVg4wcfNHRdOt3qylV/3+gD3yZPdR470HTdfH96B98+pjzmj8JnrZri7++Y9m33D7g0xiTvH3v17/efjf+6fr/k8pnGUFCW8+yiaCSEOWAWcDFQGFgDt8pUZAjxzKNs9oltSJ00K/uByHySOMa8vfN0HvD0gnB43d5xPXjrfuEQjAAARwElEQVS5bINITXU/8cTgz+vii4NbW8vK6tXuEye633GH+yWXuDdr5lnNm/k3yd8Ey6+91v9wQ1OPvzfOU8e+4P7tt56y68cDt//u2OGffvS8z/jHaPdHHvHsm/6fn3x/fR/x8Qj33bs9y/Cat+N/PSdIGtmNTvTxjwzy77d/HySJcePcP//cfe1a98zMsvvcR4EPv//QH/7vw+H0xeP/x3uN6xVMPPCA72jeIEzUXrGie/fu7jm/l8REX1EHz25Q3/2SS/zuUed4xb/E+Y7UHe7unpWdVdYfx1ftWOXtnm3nn63+rMz3fTjKQ1I4C5iWa3okMDJfmbJNCsehri909b4T+4bTi39cXDb/QCkp7n/7m3vdusGf2YUXui9dWnrb37YtOPg+8YT79de7Z2QE82+6yR08rUqcp5/e3v3Xv/YXRvdzRuHLti5z9+A5kHW71h3S7rKys9yzsz1t3Wq/65WrfdoLI9zvu883XzfAGYU/OetJ9yVLfEc83usafFqr4MC2r3VL//71ZzwjK8N961b3N95wnzXL/ccfDxzwjlFfJ3/tt31yW5Bw9+71W1+60hv95QTP7H+le8uWvqsKnv3jj0HhsWPdf/Mb96eeCk4i8p+4zZ7t/swz7oMHu592mq+oi7983YFjwaDbWvsV953u/tlnwd9eGcl5TuloUB6SwhXAS7mmf5M/AUSSwiZgIfA20Ky47SopHJrMrEzf+tNWd3ff9tM2r3RfJb/383vd3T0jK8N379sd3QD27HF/+GH3xo3dV64M5u3dW/L1MzLclyxx/+mnYPqNN9ybNDlwRgnu9eu7r4sc5Jcv9wVfTPLqo6v7u9+96+7um/Zs8gkLJ0Tls2ZlZ/mqHat8y94t7hkZvnr+5372Y6f7p0/f6j5ypM8ecqEzCn9n6Tvu06b56lr4Hefha2rhXr26Z7dv5/7VV8HGfvgheEDym2/cN2w46moay7ct9z9//GffuWuz+zff+AuPDvRq91cNHuQaO9Z3V8YzDffmzd1/+Uv3Bx8MkvvhSElxX78+GN+zxx+6tLbff3bk78HMbxpUy6c8d0uwPCurVJv61qes97988RdPz0wvtW2WhfKQFK4sICk8na9MXaBKZPxG4LNCtjUUmAPMad68ebS+s2NeWkaaT1g4wZdvW+7uwVPXjMI//P5Dd3ffuHujv7P0Hd+Vtqv0d55zJu/ufuml7mef7f7JJwefLW/Y4P7YY+5Dhrh36eJepUrwZ/rpp8HyL790v+qqINFMm+a+aZOnpaf6ea+c50/MfMLd3fdn7vebp97sCzYvKP3PcYh+3Pujj5s7zjfu3uieluYffPysx42q4PP/PsJ92DD/5+Bu3ujB+kEt5sUXfVk9/LXT8b2VcK9Qwfc2P9H3LJwTnG3/97/u998fNFFNm+a+aFFwLSdGNY7Nezb7PZ/d40u3LHVPTvYv/nC5V77bfPrJce7gqRXx/a9Erhls3Oj+/vtBDSlatmxxnzrVd4+6w9vcVt0fef437u6eMX+uj02M8+1ndgyezH/pJfcFC/L+TR6Cx2Y85tVHV/dVO1aVZvRRVx6SQrHNR/nKxwEpxW1XNYXSs3bnWr//y/uDA5a7v7bgNWcUvvjHxe7u/sWaL3zoe0ODs2D30ul2Izs7aCJo3Dj48zvzTPfevYNrPe7uc+YE8xs2DJqchg93f/VV982b82zmka8e8b9N/1s4feWbV/qL37545PGVgf2Z+8Nmh5nrZ/qQKUOCRJyS4k++NdwZhW979hH3u+7yv//hZ84ofGfaTvcHH/RXOuHnDcb3xQVnxdOb4099Ojpo3ho3zjcP+oWvG36D+9//HtSqpk8PzpRLQer+n/yBKcP9s5fudL/1Vt94XjevMMp8/Lzx7j/+6Bk1a/hP55/jPmKE+1tvBddVYpSwsrOzwzP5z2a87ozC//mrju41a/ruyvj2qrh/8EFQeNky9wkT3FesKHG8P+z6IVqhR015SAoVgdVAy1wXmtvnK9Mo13hfYFZx21VSiJ7U9FSfvWF2+M80bu44r/tQXf8pPWi6eeSrR7zFEy3C6ZXbV/rybcsPL1mkpbk/95x727bunToFBzB39/T0gxKAe9A+nVMTcHcf8PYA7zep36Hvt5zbs3+PL9+2PLzuM3vDbH/4vw+H3/HL34zxc57r5tnTp7tPmuR/+luSVxtdLVj5oYd8WP+aXmNkkDAc/N7zK3jSy0nB8ltu8Um9m/nfrz7V/Zpr3O+805c9/1dfsmVJsDwlJW+T1YYN/vSUO/yNRW+4Z2Z6ZuMTvfZt+N0/J6jBde/uu1969kD5Uko+pS07O9vnbpzraRlp7llZ/uz793jFUXH+ww8LgwIPPBB+X16rlvsFF7iPHHnQtYmFmxf62p1rY/AJSkfMk0IQAxcDKyJ3Id0ZmXcf0Ccy/gCwJJIwPgfaFrdNJYWylfuA/9537/mN/7oxnB763lCv81CdsMykxZNK7Wx9z/49PmXZlPDgeNe/7/Lqo6uHHQ4eTRf4oikzK9O3p24Pp2dvmO2vL5zgvmOH++LF/vzrf/Tr3r0uWPjMMz74D838tD/FBzW1ChW87zXVvP2z7YPl//M/PvAK897XVXFv1Mgd/Ge3Jnj/t/oHy//6V9/9/JPuc+cGyfsotWTLEn/wPw+G07dN+7P/cswFnj1mjPvQoe5nnBHctr4/uM3b77vPszt19MRbqnqHW+M9q1NH96SkAxscNiw4sck9XHLJgeU33HDw8l/96sDyQYMOXj5kyIHlffsG80aMOKLPXdKkENU3r7n7VGBqvnn35BofSdCsJOVU7gfhLmtzGZe1uSycHtZ9GH3a9AnLTFg0gc17N3N9l+sBGPqvoVSrVI0nej8BwOa9m6lfrX6hHQb+uPdHEionUL1ydSYvm8zVU67m6+u/pluTbtx61q3c3ut2qleuDnBYnQ4ei+IqxFGnap1wOrFxIomNI88n1a7Nje3/fqDw737HK/yOrOwseDQOsrK45/v/kBIf+R1ffz1nLTb27t4OF7SDrl357GedSOiRFCy/6y6OhZ6u2tVvR7v67cLp2tXqUr9Ra+zSG+CGGxg9fTQd657GZTkPslasiLVoyaSNDdhWMZ0KLWrnfX1tgwYH3mSYI/ebEU888eDljRsfGG/UKHhBV2HrN24cdEZZRm9FPK6eaJbocnf2pO/hhConAHDrR7dStVJV/nb+3wBo+0xbTm94Om9d+RYAry96nfb129PpxE4s3rKYjs935NW+rzKo4yB27dvF/M3z6dW8FxUr6K2xUjYysjJo+2xb+rbty6MXPoq788qCV7i609XlurO7ktA7mqXMmVmYEAAe7/14nuV3nn0n9asHZzuZ2Zlc++613NztZjqd2Il29dvxwPkP0L1pdwBqxdciqUVSmcUuAlAprhLf3/w9aRlpACzesphr3r2GrT9t5c89/xzj6MqGagoSE+7O5r2bAWhUo1GMoxEpWLZnM3vDbFrXaU3danVjHc4RUU1ByjUzUzKQcq+CVeDMpmfGOowyddx1nS0iIoVTUhARkZCSgoiIhJQUREQkpKQgIiIhJQUREQkpKYiISEhJQUREQkoKIiISUlIQEZGQkoKIiISUFEREJKSkICIiISUFEREJKSmIiEhISUFEREJKCiIiElJSEBGRkJKCiIiElBRERCSkpCAiIiElBRERCSkpiIhISElBRERCUU0KZtbbzJab2Uozu72IcleYmZtZYjTjERGRokUtKZhZHPAscBHQDhhoZu0KKFcD+APwdbRiERGRkolmTaEbsNLdV7t7OjARuLyAcn8FHgb2RTEWEREpgYpR3HYTYH2u6WTgzNwFzOwMoJm7v29mwwvbkJkNBYZGJvea2fLSDraM1QO2xTqIckTfxwH6LvLS95HXkXwfJ5WkUDSTghUwz8OFZhWAx4EhxW3I3ccAY0otshgzsznurusnEfo+DtB3kZe+j7zK4vuIZvNRMtAs13RTYGOu6RpAB+ALM1sLdAfe08VmEZHYiWZSmA2cYmYtzawyMAB4L2ehu6e4ez13b+HuLYBZQB93nxPFmEREpAhRSwrungn8HpgGLAPedPclZnafmfWJ1n6PEsdMU1gp0fdxgL6LvPR95BX178PcvfhSIiJyXNATzSIiElJSEBGRkJJCGTKzZmb2uZktM7MlZnZLrGOKNTOLM7N5ZvZ+rGOJNTOrZWZvm9l3kb+Rs2IdUyyZ2a2R/5PFZvaGmcXHOqayYmbjzGyLmS3ONa+OmX1iZt9HftaOxr6VFMpWJvAndz+N4Bbc3xXU9cdx5haCGxEEngQ+cve2QCeO4+/FzJoQdH+T6O4dgDiCOxiPF+OB3vnm3Q78291PAf4dmS51SgplyN03ufvcyPgegn/6JrGNKnbMrClwCfBSrGOJNTM7ATgHGAvg7unuviu2UcVcRaCqmVUEqpH3OadjmrtPB3bkm3058Epk/BXgF9HYt5JCjJhZC+AMju+OAJ8ARgDZsQ6kHDgZ2Aq8HGlOe8nMqsc6qFhx9w3Ao8A6YBOQ4u4fxzaqmGvo7psgOMEEGkRjJ0oKMWBmCcA7wDB33x3reGLBzC4Ftrj7t7GOpZyoCHQBnnf3M4CfiFLzwNEg0l5+OdASaAxUN7OrYhvV8UFJoYyZWSWChDDB3SfHOp4Y6gn0iXRxMhE4z8xei21IMZUMJLt7Ts3xbYIkcby6AFjj7lvdPQOYDPSIcUyx9qOZNQKI/NwSjZ0oKZQhMzOCNuNl7v5YrOOJJXcf6e5NI12cDAA+c/fj9kzQ3TcD682sTWTW+cDSGIYUa+uA7mZWLfJ/cz7H8YX3iPeAqyPjVwPvRmMn0ewlVQ7WE/gNsMjM5kfm3eHuU2MYk5QfNwMTIn2FrQauiXE8MePuX5vZ28Bcgrv25nEcdXlhZm8ASUA9M0sG7gUeBN40s+sIkuaVUdm3urkQEZEcaj4SEZGQkoKIiISUFEREJKSkICIiISUFEREJKSnIUcnMssxsfq6hRRFlkwrrhdXM1ppZvVKMK8nMDushKzNrYWa/LqU4hplZtdLYlhxflBTkaJXm7p1zDWtjHVBEEof/5G0LoFSSAjCMoBM5kUOipCDHDDOLN7OXzWxRpFO5nxdQpq6ZfRxZ/gJghWzreTObE+nP/y+55j9oZkvNbKGZPZpvnRbAjcCtkdrL2WZW38zeMbPZkaFnpOy5uWo588ysBsHDSWdH5t2ab9uNzGx6ZNliMzs7Mv9CM5tpZnPN7C0zSzCzPxD0F/S5mX1+BF+pHI/cXYOGo24AsoD5keGfkXl/Al6OjLcleOoznuDs/f3I/KeAeyLjlwAO1Ctg+3UiP+OAL4COQB1gOQce+qxVwHqjgOG5pl8HekXGmxN0cQLwL6BnZDyBoHeBMM4Ctvsn4M5cMdUA6gHTgeqR+bfl+mxrC/pcGjQUN6ibCzlapbl753zzegFPA7j7d2b2A3BqvjLnAP0iZT4ws52FbP9XZjaU4GDdCGhH0BfRPuAlM/sAKMnb4i4A2gXd9wBwQqRW8BXwmJlNACa7e3KuMgWZDYyLdKg4xd3nm9m5kbi+iqxbGZhZgphECqWkIMeSIo+quRTZt4uZtQSGAz9z951mNh6Id/dMM+tG0DnbAOD3wHnF7KsCcJa7p+Wb/2AksVwMzDKzC4oM2H26mZ1DULt51cweAXYCn7j7wGJiECkxXVOQY8l0YBCAmZ1K0FyzvIgyFwEFvef2BIL3GaSYWUPgokj5BKCmBx0YDgPy11QA9hA07eT4mCB5ENlG58jPVu6+yN0fAuYQNHflX5dc651E8P6JFwl62u0CzAJ6mlnrSJlqkc9dUBwiJaKkIMeS54A4M1sETAKGuPv+fGX+ApxjZnOBCwmuO+Th7gsIeuVcAowjaOqB4CD7vpktBL4Ebs2/LsG1gr45F5qJvGc4cmF6KcGFaIBhkQvGC4A04ENgIZBpZgvyX2gmuN4w38zmAb8EnnT3rcAQ4I1ITLMIkgsEPYp+qAvNcqjUS6qIiIRUUxARkZCSgoiIhJQUREQkpKQgIiIhJQUREQkpKYiISEhJQUREQv8fgcMp+KaPBysAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for c in cross_val:\n",
    "    fold_plot(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification evaluation:\n",
      "\t\t\t\t\tAccuracy\tPrecision\tRecall\t\tF1\n",
      " ------------------------------------------------------------------------------------------------\n",
      "Naive Bayes             \t:\t0.881563\t0.754572\t0.806196\t0.776165\n",
      "Linear SVC              \t:\t0.905983\t0.800778\t0.820381\t0.810072\n",
      "Stochastic Gradient Descent\t:\t0.905983\t0.803446\t0.805674\t0.804553\n",
      "Perceptron              \t:\t0.890110\t0.769227\t0.811161\t0.787579\n",
      "Logistic Regression     \t:\t0.880342\t0.756912\t0.849608\t0.790105\n",
      "Ridge Regression        \t:\t0.901099\t0.790040\t0.821221\t0.804301\n"
     ]
    }
   ],
   "source": [
    "print('Classification evaluation:\\n\\t\\t\\t\\t\\tAccuracy\\tPrecision\\tRecall\\t\\tF1\\n', '-' * 96)\n",
    "for clf in clf_names:\n",
    "    print('{:24s}\\t:\\t{:f}\\t{:f}\\t{:f}\\t{:f}'.format(clf, classification_acc[clf], classification_pre[clf], classification_rec[clf], classification_f1[clf]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculating Cohen-Kappa score between actual and predicted classification labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classifier\t\t\t\tC-K Score\n",
      " ------------------------------------------------\n",
      "Naive Bayes             \t:\t0.553387\n",
      "Linear SVC              \t:\t0.620237\n",
      "Stochastic Gradient Descent\t:\t0.609108\n",
      "Perceptron              \t:\t0.575750\n",
      "Logistic Regression     \t:\t0.583388\n",
      "Ridge Regression        \t:\t0.608862\n"
     ]
    }
   ],
   "source": [
    "print('Classifier\\t\\t\\t\\tC-K Score\\n', '-' * 48)\n",
    "for c in clf_names:\n",
    "    p = preds[c].tolist()\n",
    "    ck = cohen_kappa_score(classification_labels, p)\n",
    "    print('{:24s}\\t:\\t{:f}'.format(c, ck))"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}