logistic_regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#FF8800\"> Load data & generate features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = pd.read_csv(\"datasets/train_data.tsv\", \n",
    "                       sep = \"\\t\",\n",
    "                       usecols = [\"label\",\"label_binary\",\"text\"]\n",
    "                      )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(15928, 3)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>label</th>\n",
       "      <th>label_binary</th>\n",
       "      <th>text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1417</th>\n",
       "      <td>No_Propaganda</td>\n",
       "      <td>No_Propaganda</td>\n",
       "      <td>that he had information from anonymous sources...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11978</th>\n",
       "      <td>No_Propaganda</td>\n",
       "      <td>No_Propaganda</td>\n",
       "      <td>financially by George Soros’s money, Ford’s la...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6407</th>\n",
       "      <td>Name_Calling,Labeling</td>\n",
       "      <td>Propaganda</td>\n",
       "      <td>a very principled individual</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       label   label_binary  \\\n",
       "1417           No_Propaganda  No_Propaganda   \n",
       "11978          No_Propaganda  No_Propaganda   \n",
       "6407   Name_Calling,Labeling     Propaganda   \n",
       "\n",
       "                                                    text  \n",
       "1417   that he had information from anonymous sources...  \n",
       "11978  financially by George Soros’s money, Ford’s la...  \n",
       "6407                        a very principled individual  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(train_df.shape)\n",
    "train_df.sample(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### The training data, which was created in generate_data.ipynb, contains +15,900 samples with binary and multi-class labels. Here we'll focus on multi-class classification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import textstat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df[\"sent_count\"] = train_df.apply(lambda x: textstat.sentence_count(x[\"text\"]), axis = 1) # number of sentences in span\n",
    "train_df[\"flesch_reading\"] = train_df.apply(lambda x: textstat.flesch_reading_ease(x[\"text\"]), axis = 1) # Flesch reading ease score, higher is easier to read\n",
    "train_df[\"difficult_words\"] = train_df.apply(lambda x: textstat.difficult_words(x[\"text\"]), axis = 1) # count of words with 2 or more syllables, seems like low threshold\n",
    "train_df[\"read_index\"] = train_df.apply(lambda x: textstat.automated_readability_index(x[\"text\"]), axis = 1) # approximates the grade level needed to comprehend the text\n",
    "train_df[\"syllable_count\"] = train_df.apply(lambda x: textstat.syllable_count(x[\"text\"]), axis = 1) # count of the number of syllables in the given text\n",
    "train_df[\"text_standard\"] = train_df.apply(lambda x: textstat.text_standard(x[\"text\"], float_output = True), axis = 1) # combines a number of readability scores, the estimated school grade level to understand text\n",
    "train_df[\"text_len\"] = train_df.apply(lambda x: len(x[\"text\"]), axis = 1) # the length of the text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>label_binary</th>\n",
       "      <th>No_Propaganda</th>\n",
       "      <th>Propaganda</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>sent_count</th>\n",
       "      <td>1.2</td>\n",
       "      <td>1.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>flesch_reading</th>\n",
       "      <td>67.2</td>\n",
       "      <td>44.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>difficult_words</th>\n",
       "      <td>3.2</td>\n",
       "      <td>2.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>read_index</th>\n",
       "      <td>8.3</td>\n",
       "      <td>10.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>syllable_count</th>\n",
       "      <td>18.8</td>\n",
       "      <td>12.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>text_standard</th>\n",
       "      <td>7.8</td>\n",
       "      <td>7.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>text_len</th>\n",
       "      <td>75.0</td>\n",
       "      <td>48.3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "label_binary     No_Propaganda  Propaganda\n",
       "sent_count                 1.2         1.1\n",
       "flesch_reading            67.2        44.5\n",
       "difficult_words            3.2         2.2\n",
       "read_index                 8.3        10.7\n",
       "syllable_count            18.8        12.6\n",
       "text_standard              7.8         7.9\n",
       "text_len                  75.0        48.3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text_stats = round(train_df.groupby(\"label_binary\").mean(),1)\n",
    "text_stats.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Based on research into related work it appears that creating some linguistic features from the sample text may help with the classification task.\n",
    "> ### <span style=\"color:#8800ff\"> In fact, we can see that texts featuring propaganda are shorter (text_len), more difficult to read (flesch_reading, lower is harder to understand), and contain fewer syllables (syllable_count) than texts without propaganda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_cols = ['text', 'sent_count', 'flesch_reading',\n",
    "                'difficult_words', 'read_index', 'syllable_count',\n",
    "                'text_standard','text_len']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#FF8800\"> Train test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    train_df[feature_cols], \n",
    "    train_df[\"label\"], \n",
    "    train_size = 0.7, \n",
    "    random_state = 3, \n",
    "    shuffle = True, \n",
    "    stratify = train_df[\"label\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Here we're creating a training and testing split from just the training data so we can perform grid search and tune the hyperparameters.\n",
    "> ### We're using a standard 70-30 training testing split, shuffling the samples, and stratifying the samples so the training and testing data contain similar proportions of the labels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#FF8800\"> Transform features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_vectorizer = TfidfVectorizer(\n",
    "    strip_accents = \"unicode\", \n",
    "    lowercase = True,\n",
    "    stop_words = \"english\", \n",
    "    analyzer = \"word\", \n",
    "    token_pattern = \"[a-z]+\", \n",
    "    smooth_idf = True, \n",
    "    ngram_range=(1,3)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### We want to create a tf-idf statistic based on the text in the samples in order to utilize insights related to how informative words are based on how frequently they are used 1) in the corpus overall and 2) in a particular sample.\n",
    "> ### TfidfVectorizer will generate a sparse matrix.\n",
    "> ### We're employing smoothing so each token is counted at least once in the vocabulary. This is more relevant when we apply the tfidf created here to the testing data we split out earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.compose import ColumnTransformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "column_trans = ColumnTransformer([('tfidf', word_vectorizer, 'text')], remainder = \"passthrough\")\n",
    "train_transformed = column_trans.fit_transform(X_train[feature_cols])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### <span style=\"color:#8800ff\"> ColumnTransformer is useful here since it allows us to apply the tf-idf vectorizer to the sample text and \"pass-through\" the other features so we end up with a complete and coherent sparse matrix. If we didn't use \"passthrough\" in ColumnTransformer then we would have to map the columns of the other features onto the SciPy Compressed Sparse Row Matrix ourselves which is a bit challenging due to its structure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#FF8800\"> Perform grid search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.linear_model import LogisticRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "logistic_regression = LogisticRegression(n_jobs = -1)\n",
    "\n",
    "param_grid = [{\n",
    "        \"penalty\":[\"l2\",\"none\"],\n",
    "        \"C\":[10000,1000,1],\n",
    "        \"fit_intercept\": [True, False],\n",
    "        \"class_weight\": [None, \"balanced\"],\n",
    "        \"solver\": [\"lbfgs\",\"liblinear\"] #! running this with other solvers like \"sag\" or \"newton-cg\" will result in a wait of several hours\n",
    "}]\n",
    "\n",
    "grid_search = GridSearchCV(\n",
    "    estimator = logistic_regression,\n",
    "    param_grid = param_grid,\n",
    "    cv = 10\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bryan/Documents/Code/python-environments/SI630/lib/python3.6/site-packages/sklearn/linear_model/_logistic.py:1539: UserWarning: 'n_jobs' > 1 does not have any effect when 'solver' is set to 'liblinear'. Got 'n_jobs' = 8.\n",
      "  \" = {}.\".format(effective_n_jobs(self.n_jobs)))\n",
      "/home/bryan/Documents/Code/python-environments/SI630/lib/python3.6/site-packages/sklearn/svm/_base.py:947: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
      "  \"the number of iterations.\", ConvergenceWarning)\n",
      "/home/bryan/Documents/Code/python-environments/SI630/lib/python3.6/site-packages/sklearn/linear_model/_logistic.py:1505: UserWarning: Setting penalty='none' will ignore the C and l1_ratio parameters\n",
      "  \"Setting penalty='none' will ignore the C and l1_ratio \"\n",
      "/home/bryan/Documents/Code/python-environments/SI630/lib/python3.6/site-packages/sklearn/model_selection/_validation.py:536: FitFailedWarning: Estimator fit failed. The score on this train-test partition for these parameters will be set to nan. Details: \n",
      "ValueError: penalty='none' is not supported for the liblinear solver\n",
      "\n",
      "  FitFailedWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 2h 3min 36s, sys: 1h 44min 54s, total: 3h 48min 30s\n",
      "Wall time: 1h 29min 54s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=10, error_score=nan,\n",
       "             estimator=LogisticRegression(C=1.0, class_weight=None, dual=False,\n",
       "                                          fit_intercept=True,\n",
       "                                          intercept_scaling=1, l1_ratio=None,\n",
       "                                          max_iter=100, multi_class='auto',\n",
       "                                          n_jobs=-1, penalty='l2',\n",
       "                                          random_state=None, solver='lbfgs',\n",
       "                                          tol=0.0001, verbose=0,\n",
       "                                          warm_start=False),\n",
       "             iid='deprecated', n_jobs=None,\n",
       "             param_grid=[{'C': [10000, 1000, 1],\n",
       "                          'class_weight': [None, 'balanced'],\n",
       "                          'fit_intercept': [True, False],\n",
       "                          'penalty': ['l2', 'none'],\n",
       "                          'solver': ['lbfgs', 'liblinear']}],\n",
       "             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,\n",
       "             scoring=None, verbose=0)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "grid_search.fit(train_transformed, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1, class_weight='balanced', dual=False, fit_intercept=True,\n",
       "                   intercept_scaling=1, l1_ratio=None, max_iter=100,\n",
       "                   multi_class='auto', n_jobs=-1, penalty='l2',\n",
       "                   random_state=None, solver='liblinear', tol=0.0001, verbose=0,\n",
       "                   warm_start=False)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid_search.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### We can access various attributes of the grid search we just performed including the best performing estimator above.\n",
    "> ### Since we didn't provide an argument for the 'scoring' parameter in GridSearchCV it defaulted to the estimator's scoring method which for a multi-class classification task is subset accuracy which requires that \"the set of labels predicted for a sample must exactly match the corresponding set of labels in y_true.\" This is a fairly rigid approach. Other options are \"f1\", \"f1_micro\", \"precision\", \"jaccard\", and many others. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#FF8800\"> Best logistic regression model\n",
    "> ### Based on a more extensive grid search I performed previously I opted to use the model parameterized below.\n",
    "> ### Here we'll fit the best logistic regression model on all of the training data and evaluate it on the data from the dev dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_lr = LogisticRegression(C = 10000, class_weight = 'balanced', dual = False,\n",
    "                   fit_intercept = True, intercept_scaling = 1, l1_ratio = None,\n",
    "                   max_iter = 100, multi_class = 'auto', penalty = 'l2',\n",
    "                   random_state = 234, solver = 'liblinear', tol = 0.0001, verbose = 0,\n",
    "                   warm_start = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_train_transformed = column_trans.fit_transform(train_df[feature_cols]) # transform all of training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=10000, class_weight='balanced', dual=False,\n",
       "                   fit_intercept=True, intercept_scaling=1, l1_ratio=None,\n",
       "                   max_iter=100, multi_class='auto', n_jobs=None, penalty='l2',\n",
       "                   random_state=234, solver='liblinear', tol=0.0001, verbose=0,\n",
       "                   warm_start=False)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_lr.fit(all_train_transformed, train_df[\"label\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Here we fit our logistic regression model on all of the training data after applying the same TfidfVectorizer through the same ColumnTransformer defined above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load dev data\n",
    "dev_df = pd.read_csv(\"datasets/dev_data.tsv\", \n",
    "                       sep = \"\\t\",\n",
    "                       usecols = [\"label\",\"label_binary\",\"text\"]\n",
    "                      )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2850, 3)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>label</th>\n",
       "      <th>label_binary</th>\n",
       "      <th>text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>883</th>\n",
       "      <td>No_Propaganda</td>\n",
       "      <td>No_Propaganda</td>\n",
       "      <td>AT&amp;T Stadium pic.twitter.com/lu5VsGQByv — Alli...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1678</th>\n",
       "      <td>Exaggeration,Minimisation</td>\n",
       "      <td>Propaganda</td>\n",
       "      <td>will be remembered in history as the day</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1623</th>\n",
       "      <td>Name_Calling,Labeling</td>\n",
       "      <td>Propaganda</td>\n",
       "      <td>NSA whistleblower</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          label   label_binary  \\\n",
       "883               No_Propaganda  No_Propaganda   \n",
       "1678  Exaggeration,Minimisation     Propaganda   \n",
       "1623      Name_Calling,Labeling     Propaganda   \n",
       "\n",
       "                                                   text  \n",
       "883   AT&T Stadium pic.twitter.com/lu5VsGQByv — Alli...  \n",
       "1678           will be remembered in history as the day  \n",
       "1623                                  NSA whistleblower  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(dev_df.shape)\n",
    "dev_df.sample(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### The dev data, which was also created in generate_data.ipynb, contains +2,800 samples with binary and multi-class labels. We'll only need the values from dev_df[\"label\"]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev_df[\"sent_count\"] = dev_df.apply(lambda x: textstat.sentence_count(x[\"text\"]), axis=1)\n",
    "dev_df[\"flesch_reading\"] = dev_df.apply(lambda x: textstat.flesch_reading_ease(x[\"text\"]), axis=1)\n",
    "dev_df[\"difficult_words\"] = dev_df.apply(lambda x: textstat.difficult_words(x[\"text\"]), axis=1)\n",
    "dev_df[\"read_index\"] = dev_df.apply(lambda x: textstat.automated_readability_index(x[\"text\"]), axis=1)\n",
    "dev_df[\"syllable_count\"] = dev_df.apply(lambda x: textstat.syllable_count(x[\"text\"]), axis=1)\n",
    "dev_df[\"text_standard\"] = dev_df.apply(lambda x: textstat.text_standard(x[\"text\"], float_output=True), axis=1)\n",
    "\n",
    "dev_df[\"text_len\"] = dev_df.apply(lambda x: len(x[\"text\"]), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev_transformed = column_trans.transform(dev_df[feature_cols]) #must use same transform call for dev data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr_y_pred = best_lr.predict(dev_transformed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = list(best_lr.classes_)\n",
    "cm = confusion_matrix(dev_df[\"label\"], lr_y_pred, labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Below is a function from user Calvin Duy Canh Tran on Stack Overflow to plot a confusion matrix with any number of labels. The confusion_matrix function above outputs an unwieldly np.ndarray which I would rather not wrestle with especially given the 15 classes involved. You can check out the original post on SO here: https://stackoverflow.com/a/50386871/1576558."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(cm,\n",
    "                          target_names,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=None,\n",
    "                          normalize=True):\n",
    "    \"\"\"\n",
    "    given a sklearn confusion matrix (cm), make a nice plot\n",
    "\n",
    "    Arguments\n",
    "    ---------\n",
    "    cm:           confusion matrix from sklearn.metrics.confusion_matrix\n",
    "\n",
    "    target_names: given classification classes such as [0, 1, 2]\n",
    "                  the class names, for example: ['high', 'medium', 'low']\n",
    "\n",
    "    title:        the text to display at the top of the matrix\n",
    "\n",
    "    cmap:         the gradient of the values displayed from matplotlib.pyplot.cm\n",
    "                  see http://matplotlib.org/examples/color/colormaps_reference.html\n",
    "                  plt.get_cmap('jet') or plt.cm.Blues\n",
    "\n",
    "    normalize:    If False, plot the raw numbers\n",
    "                  If True, plot the proportions\n",
    "\n",
    "    Usage\n",
    "    -----\n",
    "    plot_confusion_matrix(cm           = cm,                  # confusion matrix created by\n",
    "                                                              # sklearn.metrics.confusion_matrix\n",
    "                          normalize    = True,                # show proportions\n",
    "                          target_names = y_labels_vals,       # list of names of the classes\n",
    "                          title        = best_estimator_name) # title of graph\n",
    "\n",
    "    Citiation\n",
    "    ---------\n",
    "    http://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html\n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    accuracy = np.trace(cm) / np.sum(cm).astype('float')\n",
    "    misclass = 1 - accuracy\n",
    "\n",
    "    if cmap is None:\n",
    "        cmap = plt.get_cmap('Purples')\n",
    "\n",
    "    plt.figure(figsize=(20, 10))\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "\n",
    "    if target_names is not None:\n",
    "        tick_marks = np.arange(len(target_names))\n",
    "        plt.xticks(tick_marks, target_names, rotation=90)\n",
    "        plt.yticks(tick_marks, target_names)\n",
    "\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "\n",
    "    thresh = cm.max() / 1.5 if normalize else cm.max() / 2\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        if normalize:\n",
    "            plt.text(j, i, \"{:0.4f}\".format(cm[i, j]),\n",
    "                     horizontalalignment=\"center\",\n",
    "                     color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "        else:\n",
    "            plt.text(j, i, \"{:,}\".format(cm[i, j]),\n",
    "                     horizontalalignment=\"center\",\n",
    "                     color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(cm = cm, target_names = labels, normalize = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### A confusion matrix visualizes the accuracy of the predictions. If a classifer had 100% accuracy then only the diagonal would contain values greater than zero. In this plot the darker purple the cell the higher the count.\n",
    "> ### <span style=\"color:#8800ff\"> The plot above shows the performance of the best logistic regression model on the dev data after fitting it on all of the training data. Comparing this matrix to the one from dummy_classifier.ipynb it may be difficult to note significant differences although there are a number of them. For instance, comparing the two matrices along the diagonal we have No_Propaganda 1,643 vs. 1,108, Loaded_Language 216 vs. 45, and Name_Calling,Labeling 74 vs. 8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import classification_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                    precision    recall  f1-score   support\n",
      "\n",
      "               Appeal_to_Authority       0.00      0.00      0.00        14\n",
      "          Appeal_to_fear-prejudice       0.18      0.14      0.15        44\n",
      "    Bandwagon,Reductio_ad_hitlerum       1.00      0.40      0.57         5\n",
      "           Black-and-White_Fallacy       0.00      0.00      0.00        22\n",
      "         Causal_Oversimplification       0.00      0.00      0.00        18\n",
      "                             Doubt       0.08      0.09      0.09        66\n",
      "         Exaggeration,Minimisation       0.15      0.12      0.13        68\n",
      "                       Flag-Waving       0.46      0.52      0.49        87\n",
      "                   Loaded_Language       0.57      0.67      0.61       324\n",
      "             Name_Calling,Labeling       0.44      0.40      0.42       183\n",
      "                     No_Propaganda       0.89      0.92      0.90      1789\n",
      "                        Repetition       0.16      0.08      0.11       144\n",
      "                           Slogans       0.15      0.05      0.08        40\n",
      "       Thought-terminating_Cliches       0.05      0.24      0.09        17\n",
      "Whataboutism,Straw_Men,Red_Herring       0.19      0.10      0.13        29\n",
      "\n",
      "                          accuracy                           0.71      2850\n",
      "                         macro avg       0.29      0.25      0.25      2850\n",
      "                      weighted avg       0.69      0.71      0.70      2850\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(dev_df[\"label\"], lr_y_pred, target_names=labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### We can evaluate the label-specific precision, recall, and f1 score results for the logistic regression model. This is a more precise way of viewing the information contained in the plot above.\n",
    "> ### <span style=\"color:#8800ff\"> Overall, the logistic regression model performed much better than the dummy classifier. However, it still struggled with Appeal_to_Authority, Black-and-White_Fallacy, and Causal_Oversimplification failing to correctly predict any of the 54 instances between them. Although the model was able to correctly predict labels from classes of similar sizes like Bandwagon,Reductio_ad_hitlerum and Whataboutism,Straw_Men,Red_Herring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.71"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "round(f1_score(dev_df[\"label\"], lr_y_pred, average = 'micro'),2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### <span style=\"color:#8800ff\"> Finally, we can quantify the overall performance of the model using the micro f1 score. The logistic regression model we created and evaluated above is a significant improvement over our baseline model but we have another model still to go: the BERT-based model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#FF8800\"> END"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}