ToxicComment_S13_Group8.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "392124ee",
   "metadata": {},
   "source": [
    "# You're Toxic, I'm Slippin' Under: Toxic Comment Classification Challenge\n",
    "\n",
    "#### STINTSY S13 Group 8\n",
    "- VICENTE, Francheska Josefa\n",
    "- VISTA, Sophia Danielle S."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c2e1db3",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "In digital communities and forums on the internet, users often choose to remain anonymous as real names are not required when conversing with strangers online. With this anonymity comes the freedom to express one's thoughts without fear of being judged or recognized, yet this might also mean that users are free to say abusive sentiments with little to no repercussions. While most online forums and social media sites have various ways to moderate (e.g. moderators and staff that manually review posts and comments, a report button under messages, voting for comments and posts), these methods are not enough to combat the significant number of toxic comments made.\n",
    "\n",
    "With this, ways to automate checking for toxicity in online text should be improved to foster a safe and respectful online environment."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "357a3425",
   "metadata": {},
   "source": [
    "## Toxic Comment Classification Challenge\n",
    "\n",
    "The [`Toxic Comment Classification Challenge`](https://www.kaggle.com/competitions/jigsaw-toxic-comment-classification-challenge/overview) is a Kaggle challenge by the [`Conversation AI team`](https://conversationai.github.io/), which is composed of researchers from both [`Jigsaw`](https://jigsaw.google.com/) and `Google`. This challenge invites participants to build a multi-headed model that can accurately detect the types of toxicity (i.e.,toxic, severe toxic, obscene, threat, insult, and identity hate) better than Perspective’s [current models](https://github.com/conversationai/unintended-ml-bias-analysis).\n",
    "\n",
    "The dataset given contains a large number of Wikipedia comments which have been labeled by human raters for toxic behavior."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3688955",
   "metadata": {},
   "source": [
    "## Requirements and Imports\n",
    "Before starting, the relevant libraries and files in building and training the model should be loaded into the notebook first.\n",
    "\n",
    "### Import\n",
    "Several libraries are required to perform a thorough analysis of the dataset. Each of these libraries will be imported and described below:\n",
    "\n",
    "#### Basic Libraries \n",
    "Import `numpy` and `pandas`.\n",
    "- `numpy` contains a large collection of mathematical functions\n",
    "- `pandas` contains functions that are designed for data manipulation and data analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "286b906d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72d52cee",
   "metadata": {},
   "source": [
    "#### Visualization Libraries \n",
    "- `matplotlib.pyplot` contains functions to create interactive plots\n",
    "- `seaborn` is a library based on matplotlib that allows for data visualization\n",
    "- `wordcloud` contains functions for generating wordclouds from text data\n",
    "\n",
    "**NOTE:** `wordcloud` should be installed using `conda install -c conda-forge wordcloud`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b3c050bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from wordcloud import WordCloud\n",
    "from wordcloud import ImageColorGenerator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c050ac6",
   "metadata": {},
   "source": [
    "#### Natural Language Processing Libraries \n",
    "- `re` is a module that allows the use of regular expressions\n",
    "- `nltk` provides functions for processing text data\n",
    "- `stopwords` is a corpus from NLTK, which includes a compiled list of stopwords\n",
    "- `Counter` is from Python's `collections` module, which is helpful for tokenization\n",
    "- `string` contains functions for string operations\n",
    "- `TFidfVectorizer` converts the given text documents into a matrix, which has TF-IDF features \n",
    "- `CountVectorizer` converts the given text documents into a matrix, which has the counts of the tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7cee8a33",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import nltk\n",
    "from nltk.corpus import stopwords\n",
    "from collections import Counter\n",
    "import string\n",
    "\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ddf662a",
   "metadata": {},
   "source": [
    "#### Machine Learning Libraries\n",
    "The following code block can be used to install **scikit-multilearn** without restarting Jupyter Notebook. The `sys` module is used to access the *executable* function of the interpreter, which would run the installation of scikit-multilearn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5ab258c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: scikit-multilearn in c:\\users\\user\\anaconda3\\lib\\site-packages (0.2.0)\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "!{sys.executable} -m pip install scikit-multilearn"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42208e57",
   "metadata": {},
   "source": [
    "The following libraries are multi-label classification modules that would allow the usage of one model that can classify one instance as more than one class.\n",
    "- `ClassifierChain` chains binary classifiers in a way that its predictions are dependent on the earlier classes\n",
    "- `BinaryRelevance` uses binary classifiers to classify the classes independently\n",
    "- `MultiOutputClassifier` fits one classifier per target class \n",
    "- `OneVsRestClassifier` fits one class against the other classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c353416c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from skmultilearn.problem_transform import ClassifierChain\n",
    "from skmultilearn.problem_transform import BinaryRelevance\n",
    "from sklearn.multioutput import MultiOutputClassifier\n",
    "from sklearn.multiclass import OneVsRestClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "973404ba",
   "metadata": {},
   "source": [
    "The following classes are classifiers that implement different methods of classification.\n",
    "- `RandomForestClassifier` is a class under the ensemble module that trains by fitting using a number of decision trees\n",
    "- `GradientBoostingClassifier` is a class under the ensemble module that optimizes arbitrary differentiable loss functions\n",
    "- `AdaBoostClassifier` is a class under the ensemble module that implements AdaBoost-SAMME\n",
    "- `MultinomialNB` is a class under the Naive Bayes module that allows the classification of discrete features\n",
    "- `LogisticRegression` is a class under the linear models module that implements regularized logistic regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8568a157",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.linear_model import LogisticRegression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e174c469",
   "metadata": {},
   "source": [
    "Meanwhile, the following classes are used for hyperparameter tuning.\n",
    "- `ParameterGrid` is a class that allows the iteration over different combinations of parameter values \n",
    "- `GridSearchCV` is a cross-validation class that allows the exhaustive search over all possible combinations of hyperparameter values\n",
    "- `RandomizedSearchCV` is a cross-validation class that allows a random search over some possible combinations of hyperparameter values\n",
    "- `train_test_split` divides the dataset into two subsets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5973812e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import ParameterGrid\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d822570",
   "metadata": {},
   "source": [
    "And lastly, these classes computes different scores about how well a model works.\n",
    "- `log_loss` computes the Logistic loss given the true values and the predicted values\n",
    "- `f1_score` computes the balanced F-score by comparing the actual classes and the predicted classes\n",
    "- `accuracy_score` computes the accuracy by determining how many classes were correctly predicted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7f01d564",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import log_loss\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "03f9eb11",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "from sklearn.exceptions import ConvergenceWarning\n",
    "warnings.filterwarnings(action='ignore', category = ConvergenceWarning)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b04554b2-f9c5-4075-8e90-35858db2f5aa",
   "metadata": {},
   "source": [
    "### Datasets and Files\n",
    "There are four `.csv` files provided in the competition.\n",
    "- `train.csv` is the training set, which contains comments and their classification (with the use of binary labels)\n",
    "- `test.csv` is the test set, which contains comments and their corresponding IDs\n",
    "- `sample_submission.csv` contains the correct submission format for the competition\n",
    "- `test_labels.csv` was a file added after the competition closed\n",
    "\n",
    "However, to do the task, we would only need to load two of these files: (1) `train.csv`, and (2) `test.csv`. These two `.csv` files will be loaded into the notebook using the [`read_csv`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html) function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1f58f5b0-f288-40c3-b135-c585939721df",
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_csv('data/train.csv')\n",
    "test  = pd.read_csv('data/test.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbc3d52f",
   "metadata": {},
   "source": [
    "## Description of the Dataset\n",
    "\n",
    "To see the the number of rows and columns for the `train` and `test` data, the [`shape`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.shape.html) property of the DataFrame is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "81bd93ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(159571, 8)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b578a0c",
   "metadata": {},
   "source": [
    "The `train` data has 159571 rows (instances) and eight (8) columns (features). An instance in our dataset represents a text and its categories. \n",
    "\n",
    "Next, the [`head`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.head.html) function is called to check the first few rows of the dataset. This will let us quickly check the features of the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5aa66668-ac4a-4abf-946e-22ee24aa6726",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>comment_text</th>\n",
       "      <th>toxic</th>\n",
       "      <th>severe_toxic</th>\n",
       "      <th>obscene</th>\n",
       "      <th>threat</th>\n",
       "      <th>insult</th>\n",
       "      <th>identity_hate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0000997932d777bf</td>\n",
       "      <td>Explanation\\r\\nWhy the edits made under my use...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>000103f0d9cfb60f</td>\n",
       "      <td>D'aww! He matches this background colour I'm s...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>000113f07ec002fd</td>\n",
       "      <td>Hey man, I'm really not trying to edit war. It...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0001b41b1c6bb37e</td>\n",
       "      <td>\"\\r\\nMore\\r\\nI can't make any real suggestions...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0001d958c54c6e35</td>\n",
       "      <td>You, sir, are my hero. Any chance you remember...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 id                                       comment_text  toxic  \\\n",
       "0  0000997932d777bf  Explanation\\r\\nWhy the edits made under my use...      0   \n",
       "1  000103f0d9cfb60f  D'aww! He matches this background colour I'm s...      0   \n",
       "2  000113f07ec002fd  Hey man, I'm really not trying to edit war. It...      0   \n",
       "3  0001b41b1c6bb37e  \"\\r\\nMore\\r\\nI can't make any real suggestions...      0   \n",
       "4  0001d958c54c6e35  You, sir, are my hero. Any chance you remember...      0   \n",
       "\n",
       "   severe_toxic  obscene  threat  insult  identity_hate  \n",
       "0             0        0       0       0              0  \n",
       "1             0        0       0       0              0  \n",
       "2             0        0       0       0              0  \n",
       "3             0        0       0       0              0  \n",
       "4             0        0       0       0              0  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b96e673f",
   "metadata": {},
   "source": [
    "As seen by the function's output, the eight columns are: `id`, `comment_text`, `toxic`, `severe_toxic`, `obscene`, `threat`, `insult`, and `identity_hate`. \n",
    "\n",
    "The first column `id` is an object that contains a unique identifier for the row. This is followed by the `comment_text` column, which holds the text that we need to categorize into the different toxic categories. The next six (6) columns—`toxic`, `severe_toxic`, `obscene`, `threat`, `insult`, and `identity_hate`—are integer columns, with a value of either 0 or 1, which represents `True` or `False`, respectively. These six columns represent the different categories. If the value for a specific column is 1, it means that the `comment_text` can be classified as this category.\n",
    "\n",
    "It is important to note, however, that each `comment_text` can be classified under more than one toxic category (e.g. a comment can fall under both `toxic` and `severe_toxic` as denoted by the multiple values of 1 per row)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7427e85c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(153164, 2)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d722576-8ca6-4d33-aa8c-4558efe35b38",
   "metadata": {},
   "source": [
    "On the other hand, the `test` dataset has 153164 rows and two (2) columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0c88077a-c301-4031-800d-6549c0083f34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>comment_text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>00001cee341fdb12</td>\n",
       "      <td>Yo bitch Ja Rule is more succesful then you'll...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0000247867823ef7</td>\n",
       "      <td>== From RfC == \\r\\n\\r\\n The title is fine as i...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>00013b17ad220c46</td>\n",
       "      <td>\" \\r\\n\\r\\n == Sources == \\r\\n\\r\\n * Zawe Ashto...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>00017563c3f7919a</td>\n",
       "      <td>:If you have a look back at the source, the in...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>00017695ad8997eb</td>\n",
       "      <td>I don't anonymously edit articles at all.</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 id                                       comment_text\n",
       "0  00001cee341fdb12  Yo bitch Ja Rule is more succesful then you'll...\n",
       "1  0000247867823ef7  == From RfC == \\r\\n\\r\\n The title is fine as i...\n",
       "2  00013b17ad220c46  \" \\r\\n\\r\\n == Sources == \\r\\n\\r\\n * Zawe Ashto...\n",
       "3  00017563c3f7919a  :If you have a look back at the source, the in...\n",
       "4  00017695ad8997eb          I don't anonymously edit articles at all."
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "475a74d4",
   "metadata": {},
   "source": [
    "Each instance represents a comment that we have to compute for its probaility for the different categories mentioned. Like the `train` data, the first column is the `id`, which is a unique identifier. After this is the `comment_text`, which holds the text that our model needs as input. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d0ed4bc",
   "metadata": {},
   "source": [
    "## Exploratory Data Analysis (EDA)\n",
    "In order to determine which model would fit our dataset, we would need to explore the given data. \n",
    "\n",
    "**Four exploratory data analysis questions have been identified and formulated:**\n",
    "1. Which words occur most frequently in the `train` data?\n",
    "2. Based on the `train` data, how correlated are the given categories?\n",
    "3. What is the range of `comment_text` character counts?\n",
    "4. In the training data, how many instances does each type of toxic comment have?\n",
    "\n",
    "To answer these questions, we used numerical summaries. Additionally, we used visualization techiniques in order to present and illustrate possible relationships in the data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f729ef9-9208-4f15-bc07-56d4e9cac427",
   "metadata": {},
   "source": [
    "### Which words occur most frequently in the `train` data?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d5a2230",
   "metadata": {},
   "source": [
    "As a preliminary step in answering this question, all of the comments should be processed using tokenization, which is the process of separating pieces of text into words. \n",
    "\n",
    "For this, NLTK's [`RegexpTokenizer`](https://www.nltk.org/api/nltk.tokenize.regexp.html) is used to tokenize the text using RegEx. More specifically, the RegEx used is `\\w+`, which retrieves all words (i.e. words with alphanumeric & underscore characters) from the text. Moreover, stopwords based on NLTK's Stopword corpus and single letters were filtered out of the tokens for a more accurate count of relevant words. \n",
    "\n",
    "It should be noted that tokenization was done for each toxic classification and for all comments as a whole, to contrast the differences of the frequently seen words in each category."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a10e51f4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     C:\\Users\\User\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "nltk.download('stopwords')\n",
    "\n",
    "words = []\n",
    "obscene = []\n",
    "insult = [] \n",
    "toxic = []\n",
    "severe_toxic = [] \n",
    "identity_hate = [] \n",
    "threat = []\n",
    "tokenizer = nltk.RegexpTokenizer(r'\\w+')\n",
    "for index, x in train.iterrows():\n",
    "    text = x ['comment_text']\n",
    "    words += tokenizer.tokenize(text.lower())\n",
    "    \n",
    "    if x ['obscene'] == 1:\n",
    "        obscene += tokenizer.tokenize(text.lower())\n",
    "    if x ['insult'] == 1:\n",
    "        insult += tokenizer.tokenize(text.lower())\n",
    "    if x ['toxic'] == 1:\n",
    "        toxic += tokenizer.tokenize(text.lower())\n",
    "    if x ['severe_toxic'] == 1:\n",
    "        severe_toxic += tokenizer.tokenize(text.lower())\n",
    "    if x ['identity_hate'] == 1:\n",
    "        identity_hate += tokenizer.tokenize(text.lower())\n",
    "    if x ['threat'] == 1:\n",
    "        threat += tokenizer.tokenize(text.lower())\n",
    "        \n",
    "all_words = Counter(words)\n",
    "all_obscene = Counter(obscene)\n",
    "all_insult = Counter(insult)\n",
    "all_toxic = Counter(toxic)\n",
    "all_severe_toxic = Counter(severe_toxic)\n",
    "all_identity_hate = Counter(identity_hate)\n",
    "all_threat = Counter(threat)\n",
    "\n",
    "for stopword in stopwords.words(\"english\"): \n",
    "    all_words.pop(stopword, None)\n",
    "    all_obscene.pop(stopword, None)\n",
    "    all_insult.pop(stopword, None)\n",
    "    all_toxic.pop(stopword, None)\n",
    "    all_severe_toxic.pop(stopword, None)\n",
    "    all_identity_hate.pop(stopword, None)\n",
    "    all_threat.pop(stopword, None)\n",
    "\n",
    "for alpha_char in list(string.ascii_lowercase + string.ascii_uppercase):\n",
    "    all_words.pop(alpha_char, None)\n",
    "    all_obscene.pop(alpha_char, None)\n",
    "    all_insult.pop(alpha_char, None)\n",
    "    all_toxic.pop(alpha_char, None)\n",
    "    all_severe_toxic.pop(alpha_char, None)\n",
    "    all_identity_hate.pop(alpha_char, None)\n",
    "    all_threat.pop(alpha_char, None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a2795b1",
   "metadata": {},
   "source": [
    "To count the tokenized characters, Python's `Counter()` object was used to automatically count the number of tokens in the list of words retrieved above. The output for all the comments, arranged by total count in descending order, is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "09df5a33",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Token (All Comments)          Count\n",
      "article                       57661\n",
      "wikipedia                     48427\n",
      "page                          46460\n",
      "talk                          37094\n",
      "please                        29794\n",
      "would                         29323\n",
      "one                           29179\n",
      "like                          28008\n",
      "see                           21603\n",
      "also                          20641\n",
      "think                         20084\n",
      "know                          19144\n",
      "people                        18468\n",
      "edit                          18288\n",
      "articles                      16712\n",
      "use                           16594\n",
      "time                          15885\n",
      "may                           15611\n",
      "user                          14101\n",
      "thanks                        13904\n"
     ]
    }
   ],
   "source": [
    "print('\\n{}{}'.format('Token (All Comments)'.ljust(30), 'Count'))\n",
    "for value, count in all_words.most_common(20):\n",
    "    print('{}{}'.format(value.ljust(30), count))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12a13de2",
   "metadata": {},
   "source": [
    "Next, the tokens for each toxic category will be shown below, arranged by total count in descending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4f67a2a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Token (Insult)                Count\n",
      "fuck                          7925\n",
      "fucking                       2799\n",
      "suck                          2792\n",
      "nigger                        2781\n",
      "go                            2235\n",
      "ass                           2211\n",
      "fat                           1926\n",
      "faggot                        1867\n",
      "bitch                         1733\n",
      "shit                          1689\n",
      "\n",
      "Token (Obscene)               Count\n",
      "fuck                          9860\n",
      "shit                          3212\n",
      "fucking                       3192\n",
      "suck                          3021\n",
      "ass                           2846\n",
      "nigger                        2727\n",
      "go                            2147\n",
      "wikipedia                     1905\n",
      "bitch                         1795\n",
      "like                          1541\n",
      "\n",
      "Token (Toxic)                 Count\n",
      "fuck                          9934\n",
      "wikipedia                     3678\n",
      "shit                          3622\n",
      "like                          3512\n",
      "nigger                        3300\n",
      "fucking                       3289\n",
      "suck                          3235\n",
      "ass                           2939\n",
      "go                            2865\n",
      "hate                          2631\n",
      "\n",
      "Token (Severe Toxic)          Count\n",
      "fuck                          7303\n",
      "suck                          2535\n",
      "ass                           2114\n",
      "shit                          1884\n",
      "faggot                        1571\n",
      "fucking                       1456\n",
      "go                            1240\n",
      "die                           1156\n",
      "bitch                         1113\n",
      "nigger                        1012\n",
      "\n",
      "Token (Identity Hate)         Count\n",
      "nigger                        2969\n",
      "fat                           1322\n",
      "jew                           1314\n",
      "gay                           918\n",
      "fuck                          880\n",
      "die                           879\n",
      "faggot                        742\n",
      "fucking                       518\n",
      "huge                          430\n",
      "suck                          427\n",
      "\n",
      "Token (Threat)                Count\n",
      "die                           1168\n",
      "ass                           772\n",
      "kill                          504\n",
      "going                         294\n",
      "wikipedia                     200\n",
      "block                         170\n",
      "must                          167\n",
      "fuck                          166\n",
      "jim                           158\n",
      "wales                         157\n"
     ]
    }
   ],
   "source": [
    "print('\\n{}{}'.format('Token (Insult)'.ljust(30), 'Count'))\n",
    "for value, count in all_insult.most_common(10):\n",
    "    print('{}{}'.format(value.ljust(30), count))\n",
    "\n",
    "print('\\n{}{}'.format('Token (Obscene)'.ljust(30), 'Count'))\n",
    "for value, count in all_obscene.most_common(10):\n",
    "    print('{}{}'.format(value.ljust(30), count))\n",
    "    \n",
    "print('\\n{}{}'.format('Token (Toxic)'.ljust(30), 'Count'))\n",
    "for value, count in all_toxic.most_common(10):\n",
    "    print('{}{}'.format(value.ljust(30), count))\n",
    "    \n",
    "print('\\n{}{}'.format('Token (Severe Toxic)'.ljust(30), 'Count'))\n",
    "for value, count in all_severe_toxic.most_common(10):\n",
    "    print('{}{}'.format(value.ljust(30), count))\n",
    "    \n",
    "print('\\n{}{}'.format('Token (Identity Hate)'.ljust(30), 'Count'))\n",
    "for value, count in all_identity_hate.most_common(10):\n",
    "    print('{}{}'.format(value.ljust(30), count))\n",
    "    \n",
    "print('\\n{}{}'.format('Token (Threat)'.ljust(30), 'Count'))\n",
    "for value, count in all_threat.most_common(10):\n",
    "    print('{}{}'.format(value.ljust(30), count))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d4f42ab",
   "metadata": {},
   "source": [
    "For a better visual representation of the frequency of these words, these words may be displayed in a wordcloud. Wordclouds are apt for this task as they give prominence to words based on their frequency.\n",
    "\n",
    "A [`WordCloud()`](https://amueller.github.io/word_cloud/generated/wordcloud.WordCloud.html) object is generated below, using the tokens from all comments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "feb52aeb-ec30-40ce-bc0e-441d57566d48",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "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"
    }
   ],
   "source": [
    "wordcloud = WordCloud(min_word_length = 3, background_color='white')\n",
    "wordcloud.generate_from_frequencies(all_words)\n",
    "plt.imshow(wordcloud, interpolation='bilinear')\n",
    "plt.title('All Data')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66736efb",
   "metadata": {},
   "source": [
    "Next, several [`WordCloud()`](https://amueller.github.io/word_cloud/generated/wordcloud.WordCloud.html) objects are generated using the tokens from each toxic category as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8061fbf3-4360-40b9-ae0a-25f99b0170bd",
   "metadata": {},
   "source": [
    "#### Figure 1. Wordcloud of the Word Frequency of All of the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "733bb09e-196e-49e9-92c4-5d385cac2fe2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "\n",
    "ax2 = fig.add_subplot(231)\n",
    "wordcloud1 = WordCloud(min_word_length = 3, background_color='white')\n",
    "wordcloud1.generate_from_frequencies(all_insult)\n",
    "plt.imshow(wordcloud1)\n",
    "plt.title('Insults')\n",
    "plt.axis('off')\n",
    "\n",
    "ax3 = fig.add_subplot(232)\n",
    "wordcloud2 = WordCloud(min_word_length = 3, background_color='white')\n",
    "wordcloud2.generate_from_frequencies(all_obscene)\n",
    "plt.imshow(wordcloud2)\n",
    "plt.title('Obscene')\n",
    "plt.axis('off')\n",
    "\n",
    "ax4 = fig.add_subplot(233)\n",
    "wordcloud3 = WordCloud(min_word_length = 3, background_color='white')\n",
    "wordcloud3.generate_from_frequencies(all_toxic)\n",
    "plt.imshow(wordcloud3)\n",
    "plt.title('Toxic')\n",
    "plt.axis('off')\n",
    "\n",
    "ax5 = fig.add_subplot(234)\n",
    "wordcloud4 = WordCloud(min_word_length = 3, background_color='white')\n",
    "wordcloud4.generate_from_frequencies(all_severe_toxic)\n",
    "plt.imshow(wordcloud4)\n",
    "plt.title('Severe Toxic')\n",
    "plt.axis('off')\n",
    "\n",
    "ax6 = fig.add_subplot(235)\n",
    "wordcloud5 = WordCloud(min_word_length = 3, background_color='white')\n",
    "wordcloud5.generate_from_frequencies(all_identity_hate)\n",
    "plt.imshow(wordcloud5)\n",
    "plt.title('Identity Hate')\n",
    "plt.axis('off')\n",
    "\n",
    "ax7 = fig.add_subplot(236)\n",
    "wordcloud6 = WordCloud(min_word_length = 3, background_color='white')\n",
    "wordcloud6.generate_from_frequencies(all_threat)\n",
    "plt.imshow(wordcloud6)\n",
    "plt.title('Threats')\n",
    "plt.axis('off')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7679730d-1bea-4952-b19d-7bf807ea715f",
   "metadata": {},
   "source": [
    "#### Figure 2. Wordcloud of the Word Frequency of Each of the Categories"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d83a508e",
   "metadata": {},
   "source": [
    "From the list of frequent words outputted earlier and the wordclouds generated above (Figure 1 and 2), there are several things to note.\n",
    "\n",
    "As expected of comments retrieved from Wikipedia's talk page edits, many of the words relate to Wikipedia itself (`article`, `articles`, `wikipedia`, `talk`, `page`, `edit`) and some words involve collaboration and communication between users for edits (`user`, `would`, `like`, `think`, `know`). Words such as `please` and `thanks` can be seen, indicating that many comments are civil and respectful.\n",
    "\n",
    "However, most of the frequently appearing words coming from comments that fall under the various toxic categories are considered profane. Interestingly enough, specific types of words appear more frequently in some categories compared to others. For example, the category `identity_hate` has a higher frequency of various slurs, `threat` contains words relating to physical harm (e.g. `kill`, `die`), and `obscene` contains indecent words related to sexual acts or parts. Furthermore, the word `fuck` consistently appears as part of the ten most frequently seen words for all categories, even appearing as the most frequent word for `insult`, `obscene`, `toxic`, and `severe_toxic`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c11d083-6baa-4a10-b22f-d132ed340d1f",
   "metadata": {},
   "source": [
    "### Based on the `train` data, how correlated are the given categories?\n",
    "Since this challenge mainly focuses on determining the probability of a comment belonging to a specific category, we want to explore the correlations among the different categories. The correlation of each of the categories is computed using Pandas' [`corr`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.corr.html) function. \n",
    "\n",
    "It should be noted that since there are only two values—0 and 1—possible for each of the categories, we would not have to worry for outliers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "17fd8d79-8a32-4b36-8f88-c94602782841",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>toxic</th>\n",
       "      <th>severe_toxic</th>\n",
       "      <th>obscene</th>\n",
       "      <th>threat</th>\n",
       "      <th>insult</th>\n",
       "      <th>identity_hate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>toxic</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.308619</td>\n",
       "      <td>0.676515</td>\n",
       "      <td>0.157058</td>\n",
       "      <td>0.647518</td>\n",
       "      <td>0.266009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>severe_toxic</th>\n",
       "      <td>0.308619</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.403014</td>\n",
       "      <td>0.123601</td>\n",
       "      <td>0.375807</td>\n",
       "      <td>0.201600</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>obscene</th>\n",
       "      <td>0.676515</td>\n",
       "      <td>0.403014</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.141179</td>\n",
       "      <td>0.741272</td>\n",
       "      <td>0.286867</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>threat</th>\n",
       "      <td>0.157058</td>\n",
       "      <td>0.123601</td>\n",
       "      <td>0.141179</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.150022</td>\n",
       "      <td>0.115128</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>insult</th>\n",
       "      <td>0.647518</td>\n",
       "      <td>0.375807</td>\n",
       "      <td>0.741272</td>\n",
       "      <td>0.150022</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.337736</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>identity_hate</th>\n",
       "      <td>0.266009</td>\n",
       "      <td>0.201600</td>\n",
       "      <td>0.286867</td>\n",
       "      <td>0.115128</td>\n",
       "      <td>0.337736</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  toxic  severe_toxic   obscene    threat    insult  \\\n",
       "toxic          1.000000      0.308619  0.676515  0.157058  0.647518   \n",
       "severe_toxic   0.308619      1.000000  0.403014  0.123601  0.375807   \n",
       "obscene        0.676515      0.403014  1.000000  0.141179  0.741272   \n",
       "threat         0.157058      0.123601  0.141179  1.000000  0.150022   \n",
       "insult         0.647518      0.375807  0.741272  0.150022  1.000000   \n",
       "identity_hate  0.266009      0.201600  0.286867  0.115128  0.337736   \n",
       "\n",
       "               identity_hate  \n",
       "toxic               0.266009  \n",
       "severe_toxic        0.201600  \n",
       "obscene             0.286867  \n",
       "threat              0.115128  \n",
       "insult              0.337736  \n",
       "identity_hate       1.000000  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correlation = train.corr()\n",
    "correlation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "924c8305-1960-496e-89dc-ac5f5acf579f",
   "metadata": {},
   "source": [
    "Since it is hard to determine the correlation of the categories using just numbers, we can visualize these numbers using a [`heatmap`](https://seaborn.pydata.org/generated/seaborn.heatmap.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "95ba26d6-1184-46cd-8962-c6ef530a8b4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure (figsize = (5, 5))\n",
    "sns.heatmap (data = correlation, xticklabels = correlation.columns.values, yticklabels = correlation.columns.values, cmap = 'viridis', annot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8af50cf8-3806-484c-a3da-c0154b1e72a3",
   "metadata": {},
   "source": [
    "#### Figure 3. Correlation Heatmap of the categories\n",
    "From Figure 3, we can see that there is a low correlation between `threat` and all of the other categories. Additionally, `insult` and `obscene` has the highest correlation among the categories with a 0.74 or 74% correlation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd9a8579-c857-4463-93d0-c6d5b179982d",
   "metadata": {},
   "source": [
    "### What is the range of `comment_text` character counts?\n",
    "\n",
    "Determining the range of the length of the string `comment_text` could help us in determining on how long are the words, phrases or sentences our model needs to handle. The length of the longest string can be determined through the use of the [`len`](https://pandas.pydata.org/docs/reference/api/pandas.Series.str.len.html) and [`describe`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.describe.html) functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "84f44217-e374-4c16-b83c-6174ddf55975",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    159571.000000\n",
       "mean        396.593961\n",
       "std         594.387869\n",
       "min           6.000000\n",
       "25%          97.000000\n",
       "50%         207.000000\n",
       "75%         438.000000\n",
       "max        5000.000000\n",
       "Name: comment_text, dtype: float64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train['comment_text'].str.len().describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56223e52-dd9a-4a22-9ec2-f1d656d0e274",
   "metadata": {},
   "source": [
    "From this, we can see that there is at least one string in the `comment_text` column with a length of 5000. This is far from the mean length, which is only 396.\n",
    "\n",
    "To effectively analyze the length of the comments, we can sort our data frame (i.e., using the [`sort_values`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.sort_values.html) function) based on the length of the `comment_text` column, from the longest to the shortest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "590a6582-ad80-40c9-84a4-a26d82159424",
   "metadata": {
    "tags": []
   },
   "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>id</th>\n",
       "      <th>comment_text</th>\n",
       "      <th>toxic</th>\n",
       "      <th>severe_toxic</th>\n",
       "      <th>obscene</th>\n",
       "      <th>threat</th>\n",
       "      <th>insult</th>\n",
       "      <th>identity_hate</th>\n",
       "      <th>string_length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>131729</th>\n",
       "      <td>c0e076f0011acaa6</td>\n",
       "      <td>\"FFFFF UUUUUU CCCCCC KKKKKK ===== YOU! F UU C ...</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>5000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>133254</th>\n",
       "      <td>c8f01ac90c4adc27</td>\n",
       "      <td>FUCK YOU ALL!!  FUCK YOU ALL!!  FUCK YOU ALL!!...</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>5000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4174</th>\n",
       "      <td>0b2055f13934a41e</td>\n",
       "      <td>ii CAN STILL POST WITH THIS COMPUTER...I SAID ...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>5000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>56834</th>\n",
       "      <td>97e695cfd71944ed</td>\n",
       "      <td>i CAN STILL POST WITH THIS COMPUTER...I SAID B...</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>5000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>156437</th>\n",
       "      <td>ce2d7821188dd30f</td>\n",
       "      <td>HUGE FAGGOT HUGE FAGGOT HUGE FAGGOT HUGE FAGGO...</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>5000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>118850</th>\n",
       "      <td>7b3d18857df782cf</td>\n",
       "      <td>FUCK YOU</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>121074</th>\n",
       "      <td>87c06f935f2c6559</td>\n",
       "      <td>you suck</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>109985</th>\n",
       "      <td>4c5cde3ab1a618c9</td>\n",
       "      <td>{{unbloc</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>52442</th>\n",
       "      <td>8c4c53001134f290</td>\n",
       "      <td>14:53,</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>137062</th>\n",
       "      <td>dd5ac2c49ec34efa</td>\n",
       "      <td>~ J.Lo</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>159571 rows × 9 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                      id                                       comment_text  \\\n",
       "131729  c0e076f0011acaa6  \"FFFFF UUUUUU CCCCCC KKKKKK ===== YOU! F UU C ...   \n",
       "133254  c8f01ac90c4adc27  FUCK YOU ALL!!  FUCK YOU ALL!!  FUCK YOU ALL!!...   \n",
       "4174    0b2055f13934a41e  ii CAN STILL POST WITH THIS COMPUTER...I SAID ...   \n",
       "56834   97e695cfd71944ed  i CAN STILL POST WITH THIS COMPUTER...I SAID B...   \n",
       "156437  ce2d7821188dd30f  HUGE FAGGOT HUGE FAGGOT HUGE FAGGOT HUGE FAGGO...   \n",
       "...                  ...                                                ...   \n",
       "118850  7b3d18857df782cf                                           FUCK YOU   \n",
       "121074  87c06f935f2c6559                                           you suck   \n",
       "109985  4c5cde3ab1a618c9                                           {{unbloc   \n",
       "52442   8c4c53001134f290                                             14:53,   \n",
       "137062  dd5ac2c49ec34efa                                             ~ J.Lo   \n",
       "\n",
       "        toxic  severe_toxic  obscene  threat  insult  identity_hate  \\\n",
       "131729      1             1        1       0       1              0   \n",
       "133254      1             1        1       0       1              0   \n",
       "4174        1             0        1       0       1              0   \n",
       "56834       1             1        1       0       1              0   \n",
       "156437      1             1        1       0       1              1   \n",
       "...       ...           ...      ...     ...     ...            ...   \n",
       "118850      1             1        1       0       1              0   \n",
       "121074      1             0        1       0       1              0   \n",
       "109985      0             0        0       0       0              0   \n",
       "52442       0             0        0       0       0              0   \n",
       "137062      0             0        0       0       0              0   \n",
       "\n",
       "        string_length  \n",
       "131729           5000  \n",
       "133254           5000  \n",
       "4174             5000  \n",
       "56834            5000  \n",
       "156437           5000  \n",
       "...               ...  \n",
       "118850              8  \n",
       "121074              8  \n",
       "109985              8  \n",
       "52442               6  \n",
       "137062              6  \n",
       "\n",
       "[159571 rows x 9 columns]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arranged_index  = train['comment_text'].str.len().sort_values(ascending = False).index\n",
    "arranged_length = train.reindex (arranged_index)\n",
    "\n",
    "length = train['comment_text'].str.len().sort_values(ascending = False)\n",
    "arranged_length ['string_length'] = length\n",
    "arranged_length"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d8ceb10-1c2d-4a76-838f-50d89026928f",
   "metadata": {},
   "source": [
    "As we can see, there are several rows with a string length of 5000. From the five comments shown, we can see that it is mostly made up of uppercase characters and copypasted words.\n",
    "\n",
    "Additionally, we can see that there are **42 rows** that has a string length of 5000 for the `comment_text` column. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "42013730-6cfd-4b57-b0ae-f6925726e376",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(arranged_length [arranged_length ['string_length'] == 5000])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae4a1181-d2b8-4e8f-9985-1df4e5816de8",
   "metadata": {},
   "source": [
    "Through the use of a [`box`](https://matplotlib.org/3.5.0/api/_as_gen/matplotlib.pyplot.box.html) plot, we can see how dispersed our data is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8bf680ff-a224-4aff-bf7f-6525775597c1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "arranged_length ['string_length'].plot.box(grid='True', figsize=(5, 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6588de3-c4a1-4bd0-898b-8b94b4e1efac",
   "metadata": {},
   "source": [
    "#### Figure 4. Box Plot of the Length of `comment_text`\n",
    "Using Figure 4, we can see that there are outliers in the length of the `comment_text` as there are comments with lengths that are higher than the upper whisker. Additionally, this boxplot visually complements what we have learned in the output of the [`describe`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.describe.html) function: 50% of the length of the `comment_text` column can be found within the range of 97 and 438, with an Interquartile range (IQR) of 341."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab0d3b50",
   "metadata": {},
   "source": [
    "### In the training data, how many instances does each type of toxic comment have?\n",
    "Last, we can get the number of instances that are classified as a specific type of toxic comment. This can help us determine if the classes are balanced or imbalanced in terms of instances.\n",
    "\n",
    "For this, we will first get the classes of our train data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "fbb9d329",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['toxic', 'severe_toxic', 'obscene', 'threat', 'insult',\n",
       "       'identity_hate'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes = train.columns[2: ]\n",
    "classes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2487847d",
   "metadata": {},
   "source": [
    "Afterwards, per class, we would be counting the number of rows with **1** as a value. This is because **1** means that the `comment_text` of that row is classified as this class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e0987b30",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['toxic', 15294],\n",
       " ['severe_toxic', 1595],\n",
       " ['obscene', 8449],\n",
       " ['threat', 478],\n",
       " ['insult', 7877],\n",
       " ['identity_hate', 1405]]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = []\n",
    "for class_ in classes:\n",
    "    data.append([class_, sum(train [class_] == 1)])\n",
    "    \n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bdf8309",
   "metadata": {},
   "source": [
    "The resulting array would be converted into a dataframe. Then, it would be sorted in descending order so that the class with the highest count could be determined smoothly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a5e1a971",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Class</th>\n",
       "      <th>Count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>toxic</td>\n",
       "      <td>15294</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>obscene</td>\n",
       "      <td>8449</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>insult</td>\n",
       "      <td>7877</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>severe_toxic</td>\n",
       "      <td>1595</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>identity_hate</td>\n",
       "      <td>1405</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>threat</td>\n",
       "      <td>478</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           Class  Count\n",
       "0          toxic  15294\n",
       "2        obscene   8449\n",
       "4         insult   7877\n",
       "1   severe_toxic   1595\n",
       "5  identity_hate   1405\n",
       "3         threat    478"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.DataFrame(data, columns=['Class', 'Count'])\n",
    "data = data.sort_values(by = ['Count'], ascending = False)\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01e5e9ec",
   "metadata": {},
   "source": [
    "As the count per class is stored in a dataframe, we could easily visualize this using a [`bar`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.bar.html) graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "bfdfaf22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='Class'>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "data.plot.bar(x = 'Class', y = 'Count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e59e41e5",
   "metadata": {},
   "source": [
    "#### Figure 5. Bar Graph of the Count of Instances per Class\n",
    "Using Figure 5, **toxic** was determined as the class with the highest number of instances in the train set, with 15294 instances. This is followed by **obscene** (8449), **insult** (7877), **severe_toxic** (1595),  **identity_hate** (1405), and then, **threat** (478).\n",
    "\n",
    "From this, we determined that the instances per class is not balanced, which is why we have to make sure that the models would weigh the class weights based on this fact."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bec66c5f",
   "metadata": {},
   "source": [
    "## Data Pre-Processing and Cleaning\n",
    "For the data cleaning, we would check if the test and train data: (1) has the correct data type, (2) has **NaN** values, and (3) has duplicate rows. \n",
    "\n",
    "Once we have checked and fixed these errors, we would employ some common NLP text preprocessing techniques. We would first convert all alphabetical characters into lowercase, expand contractions, and remove all non-word characters. These techniques will help remove noise and enable the various vectorizers (e.g., **TF-IDF** (Term Frequency–Inverse Document Frequency) vectorizer) to effectively vectorize the text data. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23d430df",
   "metadata": {},
   "source": [
    "### Data Types of the Variables\n",
    "For both `train` and `test` data, we are expecting that the `id` and the `comment_text` columns are object types as these columns are made up of alphanumeric characters. \n",
    "\n",
    "For the succeeding columns of the `train` data, these columns should be the integers 0 and 1, as these serve as boolean flags  that indicate the classification of the `comment_text`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f433b619",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "id               object\n",
       "comment_text     object\n",
       "toxic             int64\n",
       "severe_toxic      int64\n",
       "obscene           int64\n",
       "threat            int64\n",
       "insult            int64\n",
       "identity_hate     int64\n",
       "dtype: object"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f5394a39",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "id              object\n",
       "comment_text    object\n",
       "dtype: object"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74129f24",
   "metadata": {},
   "source": [
    "Moreover, we should also verify if all values under the boolean values are indeed 0s and 1s. This can be done by using the `unique` function to see all unique values; this should be an array containing only 0 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "58aacd8d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "toxic [0 1]\n",
      "severe_toxic [0 1]\n",
      "obscene [0 1]\n",
      "threat [0 1]\n",
      "insult [0 1]\n",
      "identity_hate [0 1]\n"
     ]
    }
   ],
   "source": [
    "for class_ in classes:\n",
    "    print(class_, train[class_].unique())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c115b51e",
   "metadata": {},
   "source": [
    "As the data types of the column are what we expected, we do not need to perform any cleaning here."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e9cd239",
   "metadata": {},
   "source": [
    "### Checking for `NaN`\n",
    "Additionally, we also need to check if there are rows with **NaN** value for any of the columns. This is because having a **NaN** value for any of the columns are not allowed as it might affect the learning or prediction of our model.\n",
    "\n",
    "The combination of the [`isna`](https://pandas.pydata.org/docs/reference/api/pandas.isna.html) and [`sum`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.sum.html) functions would allow us to see how many rows have **NaN** values for each of the columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "dcbadc5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "id               0\n",
       "comment_text     0\n",
       "toxic            0\n",
       "severe_toxic     0\n",
       "obscene          0\n",
       "threat           0\n",
       "insult           0\n",
       "identity_hate    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "c7876a60",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "id              0\n",
       "comment_text    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.isna().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bd46199",
   "metadata": {},
   "source": [
    "With this, we are sure that all of the rows have values for each of the columns."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72139524",
   "metadata": {},
   "source": [
    "### Checking for Duplicate Rows\n",
    "Then, we also have to check if there are rows that are duplicated. In the case that there are duplicated rows, they should be dropped as it might bias the models towards these duplicated rows.\n",
    "\n",
    "We can check for duplicates using the [`duplicated`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.duplicated.html) function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "badd5719",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>comment_text</th>\n",
       "      <th>toxic</th>\n",
       "      <th>severe_toxic</th>\n",
       "      <th>obscene</th>\n",
       "      <th>threat</th>\n",
       "      <th>insult</th>\n",
       "      <th>identity_hate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [id, comment_text, toxic, severe_toxic, obscene, threat, insult, identity_hate]\n",
       "Index: []"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train [train.duplicated()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d388a559",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>comment_text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [id, comment_text]\n",
       "Index: []"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test [test.duplicated()]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cc30ca8",
   "metadata": {},
   "source": [
    "Since we are now certain that there are no duplicates, we can now proceed with cleaning the content of the `comment_text` column."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82025dcc",
   "metadata": {},
   "source": [
    "### Expanding the Contractions\n",
    "In Natural Language Processing, the `contractions` is one of the libraries that is used to expand contractions. However, even though this library worked for the train data, an *IndexError* was raised in the testing data. Upon researching, this stemmed from the fact that the `fix` function of this library can only handle UTF-8 characters. Due to this, a function that can handle this expansion was created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "7b634bf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def expand_contractions (comment_text):\n",
    "    comment_text = re.sub(r\"won\\'t\", \"will not\", comment_text)\n",
    "    comment_text = re.sub(r\"can\\'t\", \"can not\", comment_text)\n",
    "\n",
    "    comment_text = re.sub(r\"n\\'t\", \" not\", comment_text)\n",
    "    comment_text = re.sub(r\"\\'re\", \" are\", comment_text)\n",
    "    comment_text = re.sub(r\"what's\", \" is\", comment_text)\n",
    "    comment_text = re.sub(r\"\\'s\", \" \", comment_text) # to remove 's in possessive noun's\n",
    "    comment_text = re.sub(r\"\\'d\", \" would\", comment_text)\n",
    "    comment_text = re.sub(r\"\\'ll\", \" will\", comment_text)\n",
    "    comment_text = re.sub(r\"\\'t\", \" not\", comment_text)\n",
    "    comment_text = re.sub(r\"\\'ve\", \" have\", comment_text)\n",
    "    comment_text = re.sub(r\"\\'m\", \" am\", comment_text)\n",
    "    return comment_text.strip ()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf097694",
   "metadata": {},
   "source": [
    "The `comment_text` column of both the `train` and `test` data would be mapped to the words returned by this function. Take note that the value of the `comment_text` column would be converted into lowercase in order to lessen the vocabulary, which in turn would lower the dimension of the TF-IDF vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "71784bb0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>comment_text</th>\n",
       "      <th>toxic</th>\n",
       "      <th>severe_toxic</th>\n",
       "      <th>obscene</th>\n",
       "      <th>threat</th>\n",
       "      <th>insult</th>\n",
       "      <th>identity_hate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0000997932d777bf</td>\n",
       "      <td>explanation\\r\\nwhy the edits made under my use...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>000103f0d9cfb60f</td>\n",
       "      <td>d'aww! he matches this background colour i am ...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>000113f07ec002fd</td>\n",
       "      <td>hey man, i am really not trying to edit war. i...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0001b41b1c6bb37e</td>\n",
       "      <td>\"\\r\\nmore\\r\\ni can not make any real suggestio...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0001d958c54c6e35</td>\n",
       "      <td>you, sir, are my hero. any chance you remember...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159566</th>\n",
       "      <td>ffe987279560d7ff</td>\n",
       "      <td>\":::::and for the second time of asking, when ...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159567</th>\n",
       "      <td>ffea4adeee384e90</td>\n",
       "      <td>you should be ashamed of yourself \\r\\n\\r\\nthat...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159568</th>\n",
       "      <td>ffee36eab5c267c9</td>\n",
       "      <td>spitzer \\r\\n\\r\\numm, theres no actual article ...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159569</th>\n",
       "      <td>fff125370e4aaaf3</td>\n",
       "      <td>and it looks like it was actually you who put ...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159570</th>\n",
       "      <td>fff46fc426af1f9a</td>\n",
       "      <td>\"\\r\\nand ... i really do not think you underst...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>159571 rows × 8 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                      id                                       comment_text  \\\n",
       "0       0000997932d777bf  explanation\\r\\nwhy the edits made under my use...   \n",
       "1       000103f0d9cfb60f  d'aww! he matches this background colour i am ...   \n",
       "2       000113f07ec002fd  hey man, i am really not trying to edit war. i...   \n",
       "3       0001b41b1c6bb37e  \"\\r\\nmore\\r\\ni can not make any real suggestio...   \n",
       "4       0001d958c54c6e35  you, sir, are my hero. any chance you remember...   \n",
       "...                  ...                                                ...   \n",
       "159566  ffe987279560d7ff  \":::::and for the second time of asking, when ...   \n",
       "159567  ffea4adeee384e90  you should be ashamed of yourself \\r\\n\\r\\nthat...   \n",
       "159568  ffee36eab5c267c9  spitzer \\r\\n\\r\\numm, theres no actual article ...   \n",
       "159569  fff125370e4aaaf3  and it looks like it was actually you who put ...   \n",
       "159570  fff46fc426af1f9a  \"\\r\\nand ... i really do not think you underst...   \n",
       "\n",
       "        toxic  severe_toxic  obscene  threat  insult  identity_hate  \n",
       "0           0             0        0       0       0              0  \n",
       "1           0             0        0       0       0              0  \n",
       "2           0             0        0       0       0              0  \n",
       "3           0             0        0       0       0              0  \n",
       "4           0             0        0       0       0              0  \n",
       "...       ...           ...      ...     ...     ...            ...  \n",
       "159566      0             0        0       0       0              0  \n",
       "159567      0             0        0       0       0              0  \n",
       "159568      0             0        0       0       0              0  \n",
       "159569      0             0        0       0       0              0  \n",
       "159570      0             0        0       0       0              0  \n",
       "\n",
       "[159571 rows x 8 columns]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train ['comment_text'] = train ['comment_text'].map (lambda text : expand_contractions (text.lower ()))\n",
    "train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7b12f3a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>comment_text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>00001cee341fdb12</td>\n",
       "      <td>yo bitch ja rule is more succesful then you wi...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0000247867823ef7</td>\n",
       "      <td>== from rfc == \\r\\n\\r\\n the title is fine as i...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>00013b17ad220c46</td>\n",
       "      <td>\" \\r\\n\\r\\n == sources == \\r\\n\\r\\n * zawe ashto...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>00017563c3f7919a</td>\n",
       "      <td>:if you have a look back at the source, the in...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>00017695ad8997eb</td>\n",
       "      <td>i do not anonymously edit articles at all.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153159</th>\n",
       "      <td>fffcd0960ee309b5</td>\n",
       "      <td>. \\r\\n i totally agree, this stuff is nothing ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153160</th>\n",
       "      <td>fffd7a9a6eb32c16</td>\n",
       "      <td>== throw from out field to home plate. == \\r\\n...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153161</th>\n",
       "      <td>fffda9e8d6fafa9e</td>\n",
       "      <td>\" \\r\\n\\r\\n == okinotorishima categories == \\r\\...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153162</th>\n",
       "      <td>fffe8f1340a79fc2</td>\n",
       "      <td>\" \\r\\n\\r\\n == \"\"one of the founding nations of...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153163</th>\n",
       "      <td>ffffce3fb183ee80</td>\n",
       "      <td>\" \\r\\n :::stop already. your bullshit is not w...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>153164 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                      id                                       comment_text\n",
       "0       00001cee341fdb12  yo bitch ja rule is more succesful then you wi...\n",
       "1       0000247867823ef7  == from rfc == \\r\\n\\r\\n the title is fine as i...\n",
       "2       00013b17ad220c46  \" \\r\\n\\r\\n == sources == \\r\\n\\r\\n * zawe ashto...\n",
       "3       00017563c3f7919a  :if you have a look back at the source, the in...\n",
       "4       00017695ad8997eb         i do not anonymously edit articles at all.\n",
       "...                  ...                                                ...\n",
       "153159  fffcd0960ee309b5  . \\r\\n i totally agree, this stuff is nothing ...\n",
       "153160  fffd7a9a6eb32c16  == throw from out field to home plate. == \\r\\n...\n",
       "153161  fffda9e8d6fafa9e  \" \\r\\n\\r\\n == okinotorishima categories == \\r\\...\n",
       "153162  fffe8f1340a79fc2  \" \\r\\n\\r\\n == \"\"one of the founding nations of...\n",
       "153163  ffffce3fb183ee80  \" \\r\\n :::stop already. your bullshit is not w...\n",
       "\n",
       "[153164 rows x 2 columns]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test ['comment_text'] = test ['comment_text'].map (lambda text : expand_contractions (text.lower ()))\n",
    "test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e80e080b",
   "metadata": {},
   "source": [
    "However, from the current `test` and `train` data, we can see that if we make use of TF-IDF on terms above, we would still see problems with whitespaces (e.g., new line characters, tab characters) and non-alphanumeric characters (e.g., equals sign, ellipses, repeated punctuation marks)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0945a9c9",
   "metadata": {},
   "source": [
    "### Removing Non-word Characters\n",
    "To remove the problem regarding white spaces and non-alphanumeric characters, we would be utilizing regular expressions to easily remove these two types of characters. To do this easily, we defined a function that would return a string that only has alphanumeric characters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "1e4b7207",
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_other_chars (comment_text):\n",
    "    comment_text = re.sub ('\\W', ' ', comment_text)\n",
    "    comment_text = re.sub ('\\s+', ' ', comment_text)\n",
    "    comment_text = re.sub(r'\\b\\d+\\b', '', comment_text)\n",
    "    return comment_text.strip ()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9090d377",
   "metadata": {},
   "source": [
    "Next, we would apply this function to the `comment_text` column of both the `train` and `test` data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "4883321d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>comment_text</th>\n",
       "      <th>toxic</th>\n",
       "      <th>severe_toxic</th>\n",
       "      <th>obscene</th>\n",
       "      <th>threat</th>\n",
       "      <th>insult</th>\n",
       "      <th>identity_hate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0000997932d777bf</td>\n",
       "      <td>explanation why the edits made under my userna...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>000103f0d9cfb60f</td>\n",
       "      <td>d aww he matches this background colour i am s...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>000113f07ec002fd</td>\n",
       "      <td>hey man i am really not trying to edit war it ...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0001b41b1c6bb37e</td>\n",
       "      <td>more i can not make any real suggestions on im...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0001d958c54c6e35</td>\n",
       "      <td>you sir are my hero any chance you remember wh...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159566</th>\n",
       "      <td>ffe987279560d7ff</td>\n",
       "      <td>and for the second time of asking when your vi...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159567</th>\n",
       "      <td>ffea4adeee384e90</td>\n",
       "      <td>you should be ashamed of yourself that is a ho...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159568</th>\n",
       "      <td>ffee36eab5c267c9</td>\n",
       "      <td>spitzer umm theres no actual article for prost...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159569</th>\n",
       "      <td>fff125370e4aaaf3</td>\n",
       "      <td>and it looks like it was actually you who put ...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159570</th>\n",
       "      <td>fff46fc426af1f9a</td>\n",
       "      <td>and i really do not think you understand i cam...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>159571 rows × 8 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                      id                                       comment_text  \\\n",
       "0       0000997932d777bf  explanation why the edits made under my userna...   \n",
       "1       000103f0d9cfb60f  d aww he matches this background colour i am s...   \n",
       "2       000113f07ec002fd  hey man i am really not trying to edit war it ...   \n",
       "3       0001b41b1c6bb37e  more i can not make any real suggestions on im...   \n",
       "4       0001d958c54c6e35  you sir are my hero any chance you remember wh...   \n",
       "...                  ...                                                ...   \n",
       "159566  ffe987279560d7ff  and for the second time of asking when your vi...   \n",
       "159567  ffea4adeee384e90  you should be ashamed of yourself that is a ho...   \n",
       "159568  ffee36eab5c267c9  spitzer umm theres no actual article for prost...   \n",
       "159569  fff125370e4aaaf3  and it looks like it was actually you who put ...   \n",
       "159570  fff46fc426af1f9a  and i really do not think you understand i cam...   \n",
       "\n",
       "        toxic  severe_toxic  obscene  threat  insult  identity_hate  \n",
       "0           0             0        0       0       0              0  \n",
       "1           0             0        0       0       0              0  \n",
       "2           0             0        0       0       0              0  \n",
       "3           0             0        0       0       0              0  \n",
       "4           0             0        0       0       0              0  \n",
       "...       ...           ...      ...     ...     ...            ...  \n",
       "159566      0             0        0       0       0              0  \n",
       "159567      0             0        0       0       0              0  \n",
       "159568      0             0        0       0       0              0  \n",
       "159569      0             0        0       0       0              0  \n",
       "159570      0             0        0       0       0              0  \n",
       "\n",
       "[159571 rows x 8 columns]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train ['comment_text'] = train ['comment_text'].map (lambda text : remove_other_chars (text.lower ()))\n",
    "train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ca99566e",
   "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>id</th>\n",
       "      <th>comment_text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>00001cee341fdb12</td>\n",
       "      <td>yo bitch ja rule is more succesful then you wi...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0000247867823ef7</td>\n",
       "      <td>from rfc the title is fine as it is imo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>00013b17ad220c46</td>\n",
       "      <td>sources zawe ashton on lapland</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>00017563c3f7919a</td>\n",
       "      <td>if you have a look back at the source the info...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>00017695ad8997eb</td>\n",
       "      <td>i do not anonymously edit articles at all</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153159</th>\n",
       "      <td>fffcd0960ee309b5</td>\n",
       "      <td>i totally agree this stuff is nothing but too ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153160</th>\n",
       "      <td>fffd7a9a6eb32c16</td>\n",
       "      <td>throw from out field to home plate does it get...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153161</th>\n",
       "      <td>fffda9e8d6fafa9e</td>\n",
       "      <td>okinotorishima categories i see your changes a...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153162</th>\n",
       "      <td>fffe8f1340a79fc2</td>\n",
       "      <td>one of the founding nations of the eu germany ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153163</th>\n",
       "      <td>ffffce3fb183ee80</td>\n",
       "      <td>stop already your bullshit is not welcome here...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>153164 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                      id                                       comment_text\n",
       "0       00001cee341fdb12  yo bitch ja rule is more succesful then you wi...\n",
       "1       0000247867823ef7            from rfc the title is fine as it is imo\n",
       "2       00013b17ad220c46                     sources zawe ashton on lapland\n",
       "3       00017563c3f7919a  if you have a look back at the source the info...\n",
       "4       00017695ad8997eb          i do not anonymously edit articles at all\n",
       "...                  ...                                                ...\n",
       "153159  fffcd0960ee309b5  i totally agree this stuff is nothing but too ...\n",
       "153160  fffd7a9a6eb32c16  throw from out field to home plate does it get...\n",
       "153161  fffda9e8d6fafa9e  okinotorishima categories i see your changes a...\n",
       "153162  fffe8f1340a79fc2  one of the founding nations of the eu germany ...\n",
       "153163  ffffce3fb183ee80  stop already your bullshit is not welcome here...\n",
       "\n",
       "[153164 rows x 2 columns]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test ['comment_text'] = test ['comment_text'].map (lambda text : remove_other_chars (text.lower ()))\n",
    "test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cb62dd3",
   "metadata": {},
   "source": [
    "As we can see, the repetitive punctuations and the white space characters in the `comment_text` for both `test` and `train` data are now gone. We can say that our data is now clean. \n",
    "\n",
    "Although, we can see that there are still misspellings, this would not be cleaned. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce5a1735",
   "metadata": {},
   "source": [
    "## Feature Engineering\n",
    "As we are dealing with text data, we would have to transform the `comment_text` column into a feature that our models can use. \n",
    "\n",
    "In Natural Language Processing, one of the most utilized methods in feature engineering for classifying text data is the use of vectorization. But, before we do that, let us extract the feature column for both the train and test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "fe0ed90c-d06f-463a-af23-438a41c7495f",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = train ['comment_text']\n",
    "X_test = test ['comment_text']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8d49372",
   "metadata": {},
   "source": [
    "To ensure that the best model was found, the accuracy would be compared using the two well-known vectors in Natural Language Processing: (1) TF-IDF (Term Frequency - Inverse Document Frequency) Vectorization, and (2) Count Vectorization. Thus, two vectorizers would be declared."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e70cc4a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf_vectorizer = TfidfVectorizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "e36a848e",
   "metadata": {},
   "outputs": [],
   "source": [
    "count_vectorizer = CountVectorizer()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "167aa393",
   "metadata": {},
   "source": [
    "Furthermore, a copy of the vectorizer that only takes into account the top 5000 features is also created for each of the vectorizers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "ba334af4",
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf_vectorizer_5000 = TfidfVectorizer(max_features = 5000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "68bd79fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "count_vectorizer_5000 = CountVectorizer(max_features = 5000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18498193",
   "metadata": {},
   "source": [
    "The idea behind the **TF-IDF Vector** is that it is able to represent how important a word is in a given document, and documents with similar important words would have similar vectors. Thus, if a documents have similar vectors, then we could classify the test document into the similar class as the train document. Meanwhile, the **Count Vector** shows the number of occurrences of a word in a given document."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9cc2ad7",
   "metadata": {},
   "source": [
    "Once the vectorizers are made, we can learn the vocabulary and fit the vectors from the training set. Additionally, we can get the learned document-term matrix using the `fit_transform` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d8539084-37b8-45f3-8e1f-8eff5f3bcf3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf_train = tfidf_vectorizer.fit_transform(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "b45ce614-7fd4-4294-8ad9-34194560cead",
   "metadata": {},
   "outputs": [],
   "source": [
    "count_train = count_vectorizer.fit_transform(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "7d2db1fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf_train_5000 = tfidf_vectorizer_5000.fit_transform(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "256fdf1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "count_train_5000 = count_vectorizer_5000.fit_transform(X_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fe8d0da",
   "metadata": {},
   "source": [
    "As we now have trained our vectors, we can now use these to get the corresponding document-term matrix of our test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "2aaf58b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf_test = tfidf_vectorizer.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "578c7b4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "count_test = count_vectorizer.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "c4136822",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tfidf_test_5000 = tfidf_vectorizer_5000.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "630ab33d",
   "metadata": {},
   "outputs": [],
   "source": [
    "count_test_5000 = count_vectorizer_5000.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac4fdf03",
   "metadata": {},
   "source": [
    "## Model Training\n",
    "As the task that was given in the challenge needs a multi-label classifier, we had three things to decided on: (1) the approach that would be used (i.e., an n-classifier approach or a 1-classifier approach), (2) the estimator that would be utilized, and (3) for the n-classifier, the meta-estimator that we would use.\n",
    "\n",
    "As the score is important to the challenge, we decided to compare the score output of the n-classifiers and 1-classifier. Thus, we can move on with the next question: What estimator should we utilize?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9032b642",
   "metadata": {},
   "source": [
    "### Initializing Variables\n",
    "Before we start with the models, we would first declare the `y_train` values that we would be feeding our models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "b73e1ec4",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = train.loc [ : , 'toxic' : ]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43205170",
   "metadata": {},
   "source": [
    "### Declaring Helper Functions\n",
    "As we would be training many models, it would be better to declare functions that would repeatedly use. This would abstract these repeated lines of code, which could help us focus on the more important things.\n",
    "\n",
    "First, we will first create the dataframe that would hold the predicted values for the test set. Then, the `to_submission_csv` and the `to_submission_csv_multiclass` functions would save the values fo the dataframe into a CSV file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "5b90bf11",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sample_submission = pd.read_csv('data/sample_submission.csv')\n",
    "sample_submission ['id'] = test ['id']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "ea5011e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_submission_csv(predictions, filename):\n",
    "    for i in range (6):\n",
    "        sample_submission[classes [i]] = predictions[:, i : i + 1]\n",
    "\n",
    "    sample_submission.to_csv(f'results/' + filename + '.csv', index = False) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "e7cd78da",
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_submission_csv_multiclass(predictions, filename):\n",
    "    for i in range (6):\n",
    "        temp = list(zip(*predictions[i]))\n",
    "        sample_submission[classes [i]] = temp[1]\n",
    "\n",
    "    sample_submission.to_csv(f'results/' + filename + '.csv', index = False)     "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43dbe7df",
   "metadata": {},
   "source": [
    "As the task requires us to give predictions for six classes, the `train_models` function would train multiple classifiers that will give predictions for a given class. The function would fit each classifier using the passed train set, compute for the training accuracies for each class, then predict the classes of the passed test set.\n",
    "\n",
    "The function will return the trained models and the probability that the instance is categorized under a specific label. Take note that in predicting for the test data, `predict_proba` was used because the challenge uses ROC AUC as its scorer, and it aims to determine the probability of belonging to the label, and not the label itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "5603f9fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_models(model, X_train, X_test):\n",
    "    \"\"\"Trains six models using a given train and test set.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model : estimator object\n",
    "        the type of estimator to be trained \n",
    "    X_train : \n",
    "        the data used in fitting the model\n",
    "    X_test : \n",
    "        the data to be predicted\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    models\n",
    "        a list of fitted estimator objects\n",
    "    test_predictions\n",
    "        a list of prediction probabilities by the fitted model\n",
    "    \"\"\"\n",
    "    \n",
    "    test_predictions = np.zeros((len(test), len(classes)))                  # initialize empty list for predictions\n",
    "    models = []                                                             # initialize empty list for models\n",
    "    train_accuracy = []\n",
    "    \n",
    "    \n",
    "    print('Fitting', str(model) + '...')\n",
    "    \n",
    "    for i in range(6):                                                      # loop for each of six classes\n",
    "        \n",
    "        model.fit(X_train, y_train[classes[i]])                             # fit the model\n",
    "        \n",
    "        train_predictions = model.predict(X_train)                          # predict using train data\n",
    "        accuracy = accuracy_score(train_predictions, y_train[classes[i]])   # get training accuracy \n",
    "        print(classes[i] + ':', accuracy)\n",
    "        \n",
    "        test_predictions[:,i] = model.predict_proba(X_test)[:,1]            # predict using test data\n",
    "        \n",
    "        models += [model]\n",
    "        train_accuracy += [accuracy]\n",
    "    \n",
    "    print('\\nOverall training accuracy:', np.mean(train_accuracy))\n",
    "    \n",
    "    return models, test_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "302c11ed",
   "metadata": {},
   "source": [
    "Similarly, the `tune_and_train_models` function will train multiple classifiers with the addition of hyperparameter tuning to achieve a better training accuracy. Hyperparameter tuning will be done using a `GridSearchCV` for a more comprehensive search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "c1439293",
   "metadata": {},
   "outputs": [],
   "source": [
    "def tune_and_train_models(model, hyperparameters, X_train, X_test, scoring='accuracy', cv=2):\n",
    "    \"\"\"Tunes six models using a given train and test set.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model : estimator object\n",
    "        the type of estimator to be trained \n",
    "    hyperparameters : estimator object\n",
    "        the hyperparameters used for tuning the model  \n",
    "    X_train : \n",
    "        the data used in fitting the model\n",
    "    X_test : \n",
    "        the data to be predicted\n",
    "    scoring : \n",
    "        the metric for deciding the best combination of parameters\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    models\n",
    "        a list of fitted estimator objects\n",
    "    test_predictions\n",
    "        a list of prediction probabilities by the fitted model\n",
    "    \"\"\"\n",
    "    \n",
    "    test_predictions = np.zeros((len(test), len(classes)))                  # initialize empty list for predictions\n",
    "    models = []                                                             # initialize empty list for models\n",
    "    train_accuracy = []\n",
    "    \n",
    "    print('Tuning', str(model) + '...')\n",
    "    \n",
    "    for i in range(6):                                                              # loop for each of six classes\n",
    "        model_cv = GridSearchCV(model, hyperparameters, \n",
    "                                cv=cv, scoring=scoring)\n",
    "        model_cv.fit(X_train, y_train[classes[i]])\n",
    "        \n",
    "        train_predictions = model_cv.predict(X_train)                               # predict using train data\n",
    "        accuracy = accuracy_score(train_predictions, y_train[classes[i]])           # get training accuracy \n",
    "        print(classes[i] + ':', accuracy, model_cv.best_params_)\n",
    "        \n",
    "        test_predictions[:,i] = model_cv.predict_proba(X_test)[:,1]                 # predict using test data\n",
    "        \n",
    "        models += [model_cv.best_estimator_]\n",
    "        train_accuracy += [accuracy]\n",
    "    \n",
    "    print('\\nOverall training', scoring + ':', np.mean(train_accuracy))\n",
    "    \n",
    "    return models, test_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07838bf2",
   "metadata": {},
   "source": [
    "Multi-label classifiers would follow the pipeline of training the model, getting the training predictions, and predicting the classes of the test data. As such, the `_train_model` function will forgo the loop and proceed to train the model using the whole `y_train`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "45b7c361",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, X_train, X_test, dense=False):\n",
    "    \"\"\"Trains a model using a given train and test set.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model : estimator object\n",
    "        the type of estimator to be trained \n",
    "    X_train : \n",
    "        the data used in fitting the model\n",
    "    X_test : \n",
    "        the data to be predicted\n",
    "    dense : \n",
    "        a boolean value indicating if the predictions need to be converted to dense\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    model\n",
    "        a fitted estimator object\n",
    "    test_predictions\n",
    "        a list of prediction probabilities by the fitted model\n",
    "    \"\"\"\n",
    "    \n",
    "    print('Fitting', str(model) + '...')\n",
    "    \n",
    "    model.fit(X_train, y_train)                                               # fit the model\n",
    "    train_predictions = model.predict(X_train)                                # predict using train data\n",
    "    \n",
    "    if dense:                                           \n",
    "        train_predictions = train_predictions.todense()                       # convert predictions to dense\n",
    "        \n",
    "    accuracy = accuracy_score(train_predictions, y_train)                     # get training accuracy \n",
    "    print(accuracy)                                                        \n",
    "    \n",
    "    test_predictions = model.predict_proba(X_test)                            # predict using test data\n",
    "    \n",
    "    return model, test_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f9fec15",
   "metadata": {},
   "source": [
    "As with the previous functions, the `tune_and_train_model` function will tune a single multi-label classifier using a `GridSearchCV` to increase the training accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "de1d3c32",
   "metadata": {},
   "outputs": [],
   "source": [
    "def tune_and_train_model(model, hyperparameters, X_train, X_test, scoring='accuracy', dense=False):\n",
    "    \"\"\"Tunes a model using a given train and test set.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model : estimator object\n",
    "        the type of estimator to be trained \n",
    "    hyperparameters : estimator object\n",
    "        the hyperparameters used for tuning the model  \n",
    "    X_train : \n",
    "        the data used in fitting the model\n",
    "    X_test : \n",
    "        the data to be predicted\n",
    "    scoring : \n",
    "        the metric for deciding the best combination of parameters\n",
    "    dense : \n",
    "        a boolean value indicating if the predictions need to be converted to dense\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    model\n",
    "        a  fitted estimator object\n",
    "    test_predictions\n",
    "        a list of prediction probabilities by the fitted model\n",
    "    \"\"\"\n",
    "    \n",
    "    print('Tuning', str(model) + '...')\n",
    "\n",
    "    model_cv = GridSearchCV(model, hyperparameters, \n",
    "                            cv=2, scoring=scoring)\n",
    "    model_cv.fit(X_train, y_train)\n",
    "\n",
    "    train_predictions = model_cv.predict(X_train)                                # predict using train data\n",
    "    \n",
    "    if dense:                                           \n",
    "        train_predictions = train_predictions.todense()                          # convert predictions to dense\n",
    "        \n",
    "    accuracy = accuracy_score(train_predictions, y_train)                        # get training accuracy                                                   \n",
    "    \n",
    "    test_predictions = model_cv.predict_proba(X_test)                            # predict using test data\n",
    "    \n",
    "    return model_cv, test_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adc96e47",
   "metadata": {},
   "source": [
    "### Deciding on the Estimator\n",
    "For the estimator, we decided to compare the n-classifiers of Multinomial Naive Bayes and Logistic Regression, as these are the two estimators that are widely used for text classification. The one that yielded a higher score would be the one utilized in further experiements.\n",
    "\n",
    "First, we will be declaring a MultinomialNB() object with default parameters, which will serve as the base classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "82797333",
   "metadata": {},
   "outputs": [],
   "source": [
    "mn = MultinomialNB()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47954bda",
   "metadata": {},
   "source": [
    "This model will first be trained using the count vectorized train data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "fdf240f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting MultinomialNB()...\n",
      "toxic: 0.9513696097661856\n",
      "severe_toxic: 0.98641983819115\n",
      "obscene: 0.9670867513520627\n",
      "threat: 0.9955505699657206\n",
      "insult: 0.9646301646289113\n",
      "identity_hate: 0.9877233331871079\n",
      "\n",
      "Overall training accuracy: 0.975463377848523\n",
      "Wall time: 7.01 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "mn_models_count, predictions_mn_count = train_models(mn, count_train, count_test)\n",
    "to_submission_csv(predictions_mn_count, 'submission_mn_count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36a5a289",
   "metadata": {},
   "source": [
    "Then, the model will be trained with a TF-IDF vector as an input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "f5612f06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting MultinomialNB()...\n",
      "toxic: 0.9236828747078103\n",
      "severe_toxic: 0.9899104473870566\n",
      "obscene: 0.9538449968979326\n",
      "threat: 0.996973134216117\n",
      "insult: 0.9535629907689994\n",
      "identity_hate: 0.9911074067343063\n",
      "\n",
      "Overall training accuracy: 0.968180308452037\n",
      "Wall time: 6.17 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "mn_models_tfidf, predictions_mn_tfidf = train_models(mn, tfidf_train, tfidf_test)\n",
    "to_submission_csv(predictions_mn_tfidf, 'submission_mn_tfidf')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbcebc4c",
   "metadata": {},
   "source": [
    "From the output of the Multinomial Naive Bayes, we can see that the one that used a TF-IDF vector is faster in executing and had a higher score than the Count vector.\n",
    "\n",
    "Next, a Logistic Regression model will be created with default parameters, except for the `class_weight`, which will be equated to **balanced**. This is needed because of the imbalance in the class frequencies in the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "1fbd7e0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = LogisticRegression(n_jobs=-1, class_weight='balanced')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c36b69ed",
   "metadata": {},
   "source": [
    "Using the created model, we will be training a model with a Count vector as its input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "8067d05e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting LogisticRegression(class_weight='balanced', n_jobs=-1)...\n",
      "toxic: 0.9619542398054785\n",
      "severe_toxic: 0.9745254463530341\n",
      "obscene: 0.9747886520733717\n",
      "threat: 0.9962712522952165\n",
      "insult: 0.9625997205005922\n",
      "identity_hate: 0.9764368212269147\n",
      "\n",
      "Overall training accuracy: 0.9744293553757678\n",
      "Wall time: 1min 55s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "lr_models_count, predictions_lr_count = train_models(lr, count_train, count_test)\n",
    "to_submission_csv(predictions_lr_count, 'submission_lr_count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "141aca14",
   "metadata": {},
   "source": [
    "Like in the Multinomial Naive Bayes model, we will also be training a model that utilizes a TF-IDF as an input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "6b0865af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting LogisticRegression(class_weight='balanced', n_jobs=-1)...\n",
      "toxic: 0.9574296081368169\n",
      "severe_toxic: 0.9794135525878762\n",
      "obscene: 0.9807734488096208\n",
      "threat: 0.9937519975434133\n",
      "insult: 0.9681082402190875\n",
      "identity_hate: 0.9810303877270933\n",
      "\n",
      "Overall training accuracy: 0.976751205837318\n",
      "Wall time: 1min 34s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "lr_models_tfidf, predictions_lr_tfidf = train_models(lr, tfidf_train, tfidf_test)\n",
    "to_submission_csv(predictions_lr_tfidf, 'submission_lr_tfidf')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d43f8d3",
   "metadata": {},
   "source": [
    "The resulting files from these models were submitted to the challenge in Kaggle, which resulted in the following private and public score.\n",
    "\n",
    "<table class=\"tg\">\n",
    "<thead>\n",
    "  <tr>\n",
    "    <th class=\"tg-1wig\"></th>\n",
    "    <th class=\"tg-1wig\">private</th>\n",
    "    <th class=\"tg-1wig\">public</th>\n",
    "  </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "  <tr>\n",
    "    <td class=\"tg-baqh\">submission_mn_count</td>\n",
    "    <td class=\"tg-baqh\">0.84551</td>\n",
    "    <td class=\"tg-baqh\">0.85581</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-baqh\">submission_mn_tfidf</td>\n",
    "    <td class=\"tg-baqh\">0.82507</td>\n",
    "    <td class=\"tg-baqh\">0.83584</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-baqh\">submission_lr_count</td>\n",
    "    <td class=\"tg-baqh\">0.94598</td>\n",
    "    <td class=\"tg-baqh\">0.94576</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-baqh\">submission_lr_tfidf</td>\n",
    "    <td class=\"tg-baqh\">0.97558</td>\n",
    "    <td class=\"tg-baqh\">0.97621</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "</tbody>\n",
    "</table>\n",
    "\n",
    "From this, we can see that the models that utilize Logistic Regression were higher than their counterpart in Multinomial Naive Bayes (i.e., the one that used the same input vector). Thus, we have decided to continue with using Logistic Regression as the estimator."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eb8b0ab",
   "metadata": {},
   "source": [
    "### Deciding on the Meta-Estimator\n",
    "Next, as we already have our estimator, we can now continue with deciding the meta-estimator, which would be utilized for the 1-classifier. For multi-label classifiers, there is two main approaches: (1) Classifier Chain, and (2) Binary Relevance. ClassifierChain is the approach used if there are dependencies between the labels, while Binary Relevance is an intuitive approach for multi-label classification, which is fitting one classifier each for the labels (i.e., what we are doing in the n-classifiers). \n",
    "\n",
    "As we have seen in the EDA that the correlations between some of the labels are low, we have decided to continue with Binary Relevance. Thus, we will be creating a Binary Relevance object with a Logistic Regression model as its estimator."
   ]
  },
  {
   "cell_type": "raw",
   "id": "8a8b2ab7",
   "metadata": {},
   "source": [
    "br_lr = BinaryRelevance(LogisticRegression(n_jobs=-1, class_weight='balanced'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9b1c805",
   "metadata": {},
   "source": [
    "Then, a model would be trained using a Count vector with 5000 features. The maximum features utilized by this model would avoid memory errors as this model has a higher memory need than other multi-label or multi-class classifiers."
   ]
  },
  {
   "cell_type": "raw",
   "id": "ad4e707e",
   "metadata": {},
   "source": [
    "%%time\n",
    "br_lr_model_count, predictions_br_lr_count = train_model(br_lr, count_train_5000, count_test_5000, dense=True)\n",
    "to_submission_csv(predictions_br_lr_count, 'submission_br_lr_count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e0a45eb",
   "metadata": {},
   "source": [
    "Likewise, we would be training a model with a TF-IDF vector (with 5000 features) as its input."
   ]
  },
  {
   "cell_type": "raw",
   "id": "75e1b372",
   "metadata": {},
   "source": [
    "%%time\n",
    "br_lr_model_tfidf, predictions_br_lr_tfidf = train_model(br_lr, tfidf_train_5000, tfidf_test_5000, dense=True)\n",
    "to_submission_csv(predictions_br_lr_tfidf, 'submission_br_lr_tfidf')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c25b7ac",
   "metadata": {},
   "source": [
    "### Finding a Substitute for Binary Relevance\n",
    "Due to the high resource needs of Binary Relevance and its speed (i.e., training for nine hours on a device with an 8GB RAM and an Intel Core i7-1065G7 CPU), we tried to find a model that utilizes the same idea as Binary Relevance but faster. With this, we found `MultiOutputClassifier` and `OneVsRestClassifier`. Although `OneVsRestClassifier` is natively used as a multi-class classifier, it can also be used as a multi-label, wherein it would turn into comparing the probability of belonging into a label, rather than determining which label an instance belongs to. Thus, we would be creating models for each of these classifiers.\n",
    "\n",
    "First, we would be creating a `MultiOutputClassifier` object with a `LogisticRegression` base estimator. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "d7966ced",
   "metadata": {},
   "outputs": [],
   "source": [
    "mo_lr = MultiOutputClassifier(LogisticRegression(n_jobs=-1, class_weight='balanced'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76c32c55",
   "metadata": {},
   "source": [
    "A copy of this model would be trained using a Count vector with no explicitly declared number of maximum number of features, as the `MultiOutputClassifier` can handle the total number of features created by a default Count vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "62cb94e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting MultiOutputClassifier(estimator=LogisticRegression(class_weight='balanced',\n",
      "                                                   n_jobs=-1))...\n",
      "0.8935896873492051\n",
      "Wall time: 1min 43s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "mo_lr_model_count, predictions_mo_lr_count = train_model(mo_lr, count_train, count_test)\n",
    "to_submission_csv_multiclass(predictions_mo_lr_count, 'submission_mo_lr_count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5823bcf6",
   "metadata": {},
   "source": [
    "Afterwards, another copy of this model would be trained with a TF-IDF vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "89b0b42b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting MultiOutputClassifier(estimator=LogisticRegression(class_weight='balanced',\n",
      "                                                   n_jobs=-1))...\n",
      "0.9042495190228801\n",
      "Wall time: 1min 31s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "mo_lr_model_tfidf, predictions_mo_lr_tfidf = train_model(mo_lr, tfidf_train, tfidf_test)\n",
    "to_submission_csv_multiclass(predictions_mo_lr_tfidf, 'submission_mo_lr_tfidf')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cee527d",
   "metadata": {},
   "source": [
    "On the other hand, we would also be creating a `OneVsRestClassifier` object with the same base estimator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "1d01e03f",
   "metadata": {},
   "outputs": [],
   "source": [
    "oc_lr = OneVsRestClassifier(LogisticRegression(class_weight='balanced'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07885de3",
   "metadata": {},
   "source": [
    "Like for the previous models, we would first be using a Count vector to train this model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "1561b46a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting OneVsRestClassifier(estimator=LogisticRegression(class_weight='balanced'))...\n",
      "0.8949370499652193\n",
      "Wall time: 1min 53s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "oc_lr_model_count, predictions_oc_lr_count = train_model(oc_lr, count_train, count_test)\n",
    "to_submission_csv(predictions_oc_lr_count, 'submission_oc_lr_count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fa25697",
   "metadata": {},
   "source": [
    "Meanwhile, a copy of this model would be trained using a TF-IDF vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "c84bf732",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting OneVsRestClassifier(estimator=LogisticRegression(class_weight='balanced'))...\n",
      "0.9042557858257453\n",
      "Wall time: 1min 39s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "oc_lr_model_tfidf, predictions_oc_lr_tfidf = train_model(oc_lr, tfidf_train, tfidf_test)\n",
    "to_submission_csv(predictions_oc_lr_tfidf, 'submission_oc_lr_tfidf')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "506615a2",
   "metadata": {},
   "source": [
    "<style type=\"text/css\">\n",
    ".tg  {border-collapse:collapse;border-spacing:0;}\n",
    ".tg td{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;\n",
    "  overflow:hidden;padding:10px 5px;word-break:normal;}\n",
    ".tg th{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;\n",
    "  font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}\n",
    ".tg .tg-1wig{font-weight:bold;text-align:left;vertical-align:top}\n",
    ".tg .tg-baqh{text-align:center;vertical-align:top}\n",
    "</style>\n",
    "<table class=\"tg\">\n",
    "<thead>\n",
    "  <tr>\n",
    "    <th class=\"tg-1wig\"></th>\n",
    "    <th class=\"tg-1wig\">private</th>\n",
    "    <th class=\"tg-1wig\">public</th>\n",
    "  </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "  <tr>\n",
    "    <td class=\"tg-baqh\">submission_mo_lr_count</td>\n",
    "    <td class=\"tg-baqh\">0.94598</td>\n",
    "    <td class=\"tg-baqh\">0.94576</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-baqh\">submission_mo_lr_tfidf</td>\n",
    "    <td class=\"tg-baqh\">0.97558</td>\n",
    "    <td class=\"tg-baqh\">0.97621</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-baqh\">submission_oc_lr_count</td>\n",
    "    <td class=\"tg-baqh\">0.94598</td>\n",
    "    <td class=\"tg-baqh\">0.94576</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-baqh\">submission_oc_lr_tfidf</td>\n",
    "    <td class=\"tg-baqh\">0.97558</td>\n",
    "    <td class=\"tg-baqh\">0.97621</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "</tbody>\n",
    "</table>\n",
    "\n",
    "Using the ROC AUC scores given by the competition, we can see that the scores of the models are the same. Even the time of execution of both models only has minimal difference. But, from this, we can see that the TF-IDF models scored higher compared to those models who used Count vectors."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29cadb7f",
   "metadata": {},
   "source": [
    "### Hyperparameter Tuning\n",
    "As we already know that TF-IDF models have higher ROC AUC scores, we can try to tune the TF-IDF model of both `MultiOutputClassifier` and `OneVsRestClassifier` as the **representative of our 1-Classifier**. The result of this would help us decide which is a better model of the two.\n",
    "\n",
    "To start with hyperparameter tuning, we would declare the different hyperparameters that we would like to tune and the choices for their values. Values above and below the default values were added to determine how the increase or decrease of the values would affect the model's accuracy on the training data, and more importantly, on the test data.\n",
    "\n",
    "**Note: The following cells (under the Hyperparameter Tuning header) is expected to run for around one (1) hour (i.e., tested on a device with 8GB RAM).**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "f271f491",
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters_lr_mo = [{\n",
    "    'estimator__C': [0.01, 0.1, 1, 10],           \n",
    "    'estimator__max_iter': [50, 100, 300, 600, 900] \n",
    "}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "5ce21534",
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters_lr = [{\n",
    "    'C' : [0.01, 0.1, 1, 10],\n",
    "    'max_iter' : [50, 100, 300, 600, 900] \n",
    "}]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c5657d1",
   "metadata": {},
   "source": [
    "First, we would declare a `MultiOutputClassifier` estimator object, which would be used by the `GridSearchCV`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "10091c09",
   "metadata": {},
   "outputs": [],
   "source": [
    "mo_lr = MultiOutputClassifier(LogisticRegression(n_jobs=-1, class_weight='balanced'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "767879fd",
   "metadata": {},
   "source": [
    "We would be tuning a model that utlized this base estimator using the `GridSearchCV` class. Additionally, predictions on the test set would be made, and these predictions would be saved into a CSV file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "af1085a3",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuning MultiOutputClassifier(estimator=LogisticRegression(class_weight='balanced',\n",
      "                                                   n_jobs=-1))...\n",
      "Wall time: 35min 45s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "mo_lr_model_tfidf_tuned, predictions_mo_lr_tfidf_tuned = tune_and_train_model(mo_lr, \n",
    "                                                                              parameters_lr_mo, \n",
    "                                                                              tfidf_train, \n",
    "                                                                              tfidf_test)\n",
    "to_submission_csv_multiclass(predictions_mo_lr_tfidf_tuned, 'submission_mo_lr_tfidf_tuning')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45b741e7",
   "metadata": {},
   "source": [
    "Then, we would be creating a `OneVsRestClassifier` as a base estimator that the `GridSearchCV` would try to tune."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "b3c95548",
   "metadata": {},
   "outputs": [],
   "source": [
    "oc_lr = OneVsRestClassifier(LogisticRegression(class_weight='balanced'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a090028",
   "metadata": {},
   "source": [
    "As we already have a base estimator, we could pass this to `GridSearchCV`, and then create predictions on the test set, which would be put into a CSV file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "19e0e794",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuning OneVsRestClassifier(estimator=LogisticRegression(class_weight='balanced'))...\n",
      "Wall time: 26min 33s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "oc_lr_model_tfidf_tuned, predictions_oc_lr_tfidf_tuned = tune_and_train_model(oc_lr, \n",
    "                                                                              parameters_lr_mo, \n",
    "                                                                              tfidf_train, \n",
    "                                                                              tfidf_test)\n",
    "to_submission_csv(predictions_oc_lr_tfidf_tuned, 'submission_oc_lr_tfidf_tuning')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0df20531",
   "metadata": {},
   "source": [
    "Let us see the different hyperparameter combinations and their accuracy scores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "af6cb91d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_hyperparamter_score (name, model):\n",
    "    print(name)\n",
    "    for i in range (len(model.cv_results_['params'])):\n",
    "        params = model.cv_results_['params'][i]\n",
    "        score = model.cv_results_['mean_test_score'][i]\n",
    "        print('Hyperparameters: ', params, ' Score: ', score)\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "f8ceaecf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MultiOutputClassifier (Logistic Regression)\n",
      "Hyperparameters:  {'estimator__C': 0.01, 'estimator__max_iter': 50}  Score:  0.8016243652308874\n",
      "Hyperparameters:  {'estimator__C': 0.01, 'estimator__max_iter': 100}  Score:  0.8016243652308874\n",
      "Hyperparameters:  {'estimator__C': 0.01, 'estimator__max_iter': 300}  Score:  0.8016243652308874\n",
      "Hyperparameters:  {'estimator__C': 0.01, 'estimator__max_iter': 600}  Score:  0.8016243652308874\n",
      "Hyperparameters:  {'estimator__C': 0.01, 'estimator__max_iter': 900}  Score:  0.8016243652308874\n",
      "Hyperparameters:  {'estimator__C': 0.1, 'estimator__max_iter': 50}  Score:  0.8455233113308311\n",
      "Hyperparameters:  {'estimator__C': 0.1, 'estimator__max_iter': 100}  Score:  0.8455233113308311\n",
      "Hyperparameters:  {'estimator__C': 0.1, 'estimator__max_iter': 300}  Score:  0.8455233113308311\n",
      "Hyperparameters:  {'estimator__C': 0.1, 'estimator__max_iter': 600}  Score:  0.8455233113308311\n",
      "Hyperparameters:  {'estimator__C': 0.1, 'estimator__max_iter': 900}  Score:  0.8455233113308311\n",
      "Hyperparameters:  {'estimator__C': 1, 'estimator__max_iter': 50}  Score:  0.879902997741494\n",
      "Hyperparameters:  {'estimator__C': 1, 'estimator__max_iter': 100}  Score:  0.8799155311901337\n",
      "Hyperparameters:  {'estimator__C': 1, 'estimator__max_iter': 300}  Score:  0.8799155311901337\n",
      "Hyperparameters:  {'estimator__C': 1, 'estimator__max_iter': 600}  Score:  0.8799155311901337\n",
      "Hyperparameters:  {'estimator__C': 1, 'estimator__max_iter': 900}  Score:  0.8799155311901337\n",
      "Hyperparameters:  {'estimator__C': 10, 'estimator__max_iter': 50}  Score:  0.899098212365568\n",
      "Hyperparameters:  {'estimator__C': 10, 'estimator__max_iter': 100}  Score:  0.9005395735686086\n",
      "Hyperparameters:  {'estimator__C': 10, 'estimator__max_iter': 300}  Score:  0.9005709065225695\n",
      "Hyperparameters:  {'estimator__C': 10, 'estimator__max_iter': 600}  Score:  0.9005709065225695\n",
      "Hyperparameters:  {'estimator__C': 10, 'estimator__max_iter': 900}  Score:  0.9005709065225695\n",
      "\n",
      "\n",
      "OneVsRestClassifier (Logistic Regression)\n",
      "Hyperparameters:  {'estimator__C': 0.01, 'estimator__max_iter': 50}  Score:  0.8016243652308874\n",
      "Hyperparameters:  {'estimator__C': 0.01, 'estimator__max_iter': 100}  Score:  0.8016243652308874\n",
      "Hyperparameters:  {'estimator__C': 0.01, 'estimator__max_iter': 300}  Score:  0.8016243652308874\n",
      "Hyperparameters:  {'estimator__C': 0.01, 'estimator__max_iter': 600}  Score:  0.8016243652308874\n",
      "Hyperparameters:  {'estimator__C': 0.01, 'estimator__max_iter': 900}  Score:  0.8016243652308874\n",
      "Hyperparameters:  {'estimator__C': 0.1, 'estimator__max_iter': 50}  Score:  0.8455233113308311\n",
      "Hyperparameters:  {'estimator__C': 0.1, 'estimator__max_iter': 100}  Score:  0.8455233113308311\n",
      "Hyperparameters:  {'estimator__C': 0.1, 'estimator__max_iter': 300}  Score:  0.8455233113308311\n",
      "Hyperparameters:  {'estimator__C': 0.1, 'estimator__max_iter': 600}  Score:  0.8455233113308311\n",
      "Hyperparameters:  {'estimator__C': 0.1, 'estimator__max_iter': 900}  Score:  0.8455233113308311\n",
      "Hyperparameters:  {'estimator__C': 1, 'estimator__max_iter': 50}  Score:  0.879902997741494\n",
      "Hyperparameters:  {'estimator__C': 1, 'estimator__max_iter': 100}  Score:  0.8799155311901337\n",
      "Hyperparameters:  {'estimator__C': 1, 'estimator__max_iter': 300}  Score:  0.8799155311901337\n",
      "Hyperparameters:  {'estimator__C': 1, 'estimator__max_iter': 600}  Score:  0.8799155311901337\n",
      "Hyperparameters:  {'estimator__C': 1, 'estimator__max_iter': 900}  Score:  0.8799155311901337\n",
      "Hyperparameters:  {'estimator__C': 10, 'estimator__max_iter': 50}  Score:  0.899098212365568\n",
      "Hyperparameters:  {'estimator__C': 10, 'estimator__max_iter': 100}  Score:  0.9005583734666582\n",
      "Hyperparameters:  {'estimator__C': 10, 'estimator__max_iter': 300}  Score:  0.9005709065225695\n",
      "Hyperparameters:  {'estimator__C': 10, 'estimator__max_iter': 600}  Score:  0.9005709065225695\n",
      "Hyperparameters:  {'estimator__C': 10, 'estimator__max_iter': 900}  Score:  0.9005709065225695\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print_hyperparamter_score('MultiOutputClassifier (Logistic Regression)', mo_lr_model_tfidf_tuned)\n",
    "print_hyperparamter_score('OneVsRestClassifier (Logistic Regression)', oc_lr_model_tfidf_tuned)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a987adb",
   "metadata": {},
   "source": [
    "From the `MultiOutputClassifier`, we would think that the combination **C = 10** and **max_iter = 300** would be the best combination. However, submitting the predictions of this combination would actually in a lower score (i.e., a private score of 0.97135 and a public score of 0.97227). This might be because the model already become a little bit of overfitted to the train data (as C determines the regularization of the model), which is why it scored lower in the test data. Another interesting thing to note is that, starting from **max_iter = 100**, the values would be the same until the last value of the models with the same **C** values. This might infer that our model does not learn past this mark.\n",
    "\n",
    "On the other hand, for the `OneVsRestClassifier`, the hyperparameter combination that would yield the highest score would be **C = 10** and **max_iter = 300**. This combination would actually result in a private score of 0.97128 and a public score of 0.97214, which is lower than the untuned version. Addition to this, we can see that it follows the same pattern as the `MultiOutputClassifier`.\n",
    "\n",
    "As an experiment, we can try to set the hyperparameter values to **C = 1** and **max_iter = 100**, which are the values we used for `MultiOutputClassifier`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "1802e7c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting OneVsRestClassifier(estimator=LogisticRegression(C=1, class_weight='balanced'))...\n",
      "0.9042557858257453\n"
     ]
    }
   ],
   "source": [
    "best_model_or = OneVsRestClassifier(LogisticRegression(class_weight='balanced', C = 1, max_iter = 100))\n",
    "best_model_or, predictions_or =  train_model(best_model_or, tfidf_train, tfidf_test)\n",
    "to_submission_csv(predictions_or, 'submission_temp')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f1f3639",
   "metadata": {},
   "source": [
    "Submitting this to Kaggle, we would see that it would yield the same result as `MultiOutputClassifier`. This is actually expected as they are both utilizing the same idea: fitting one classifier per label. One of the reasons on why these hyperparameter values was not chosen as the best parameters (even though they yielded the higher score in the test data) was that we are overfitting to the train data as C increases.\n",
    "\n",
    "With this knowledge and the fact that both classifiers' training time is almost the same, we could pick either of the classifiers as our best classifier using this hyperparameter values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "714ad418",
   "metadata": {},
   "source": [
    "Then, we would also tune the **N-Classifiers of Logistic Regression** so that we would be able to compare which of the two approaches will yield a higher score. Although, it is important to note that this N-classifiers approach is also based on the same idea as `MultiOutputClassifier` and `OneVsRestClassifier` of fitting one classifier per label.\n",
    "\n",
    "We would start by declaring a `LogisticRegression` object that will be used as a base model for our training and tuning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "833df0e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = LogisticRegression(n_jobs=-1, class_weight='balanced')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ced04968",
   "metadata": {},
   "source": [
    "Afterwards, we would be training and tuning six classifiers using the `tune_and_train_models` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "bf5b999c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuning LogisticRegression(class_weight='balanced', n_jobs=-1)...\n",
      "toxic: 0.9798396951827086 {'C': 10, 'max_iter': 300}\n",
      "severe_toxic: 0.989340168326325 {'C': 10, 'max_iter': 300}\n",
      "obscene: 0.990267655150372 {'C': 10, 'max_iter': 100}\n",
      "threat: 0.9981387595490409 {'C': 10, 'max_iter': 100}\n",
      "insult: 0.9829918970238953 {'C': 10, 'max_iter': 300}\n",
      "identity_hate: 0.9905308608707096 {'C': 10, 'max_iter': 50}\n",
      "\n",
      "Overall training accuracy: 0.9885181726838419\n",
      "Wall time: 24min 46s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "lr_models_tfidf_tuned, predictions_lr_tfidf_tuned = tune_and_train_models(lr, parameters_lr, tfidf_train, tfidf_test)\n",
    "to_submission_csv(predictions_lr_tfidf_tuned, 'submission_lr_tfidf_tuned')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edc128dd",
   "metadata": {},
   "source": [
    "Like in the scenario of the `OneVsRestClassifier`, the score in Kaggle of the tuned version decreased, as it received the same score as the `MultiOutputClassifier`: a private score of 0.97135, and a public score of 0.97227. This may indicate the including a high value of **C** is not recommended as it is slightly overfitting. However, from its previous untuned score using the default parameters, we know that it scored the same as the `MultiOutputClassifier` and `OneVsRestClassifier`. \n",
    "\n",
    "Thus, as the utilized 1-Classifier models used the same concept of having N-Classifiers, they actually yielded the same score. Thus, we can use either N-Classifier or the any of the two 1-Classifiers as our final model."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5a380cb",
   "metadata": {},
   "source": [
    "### Model Selection\n",
    "From the above experiment during the hyperparameter tuning, we were able to get the best combination of hyperparameters, which is **C = 1** and **max_iter = 100** (i.e., the default values of Logistic Regression). Thus, we would be creating a `MultiOutputClassifier` with a `LogisticRegression` that uses this hyperparameter combination."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "45482b1b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "best_model = MultiOutputClassifier(LogisticRegression(n_jobs=-1, class_weight='balanced', C = 1, max_iter = 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3499723b",
   "metadata": {},
   "source": [
    "We would be training this model, and using it to predict on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "217d9942",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting MultiOutputClassifier(estimator=LogisticRegression(C=1, class_weight='balanced',\n",
      "                                                   n_jobs=-1))...\n",
      "0.9042495190228801\n"
     ]
    }
   ],
   "source": [
    "best_model, predictions_mo_lr_tfidf_tuned =  train_model(best_model, tfidf_train, tfidf_test)\n",
    "to_submission_csv_multiclass(predictions_mo_lr_tfidf_tuned, 'submission_best_model')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12b4bc71",
   "metadata": {},
   "source": [
    "This classifier yielded a private score of **0.97558** and a public score of **0.97621**. This is the same as the untuned model as it used the same parameter values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35a33813",
   "metadata": {},
   "source": [
    "## Trying different Models\n",
    "To further determine if this line of thinking is correct, we experimented on other approaches to this problem in another notebook. Thus, we would need to save the cleaned train and test datasets so that we can load it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "55faac8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.to_csv(f'cleaned_data/cleaned_train.csv', index = False) \n",
    "test.to_csv(f'cleaned_data/cleaned_test.csv', index = False) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "957515a0",
   "metadata": {},
   "source": [
    "The experimentation of the different models can be found in a [`supplementary notebook`](ToxicComment_S13_Group8_Supplementary.ipynb). Note that due to the number of models tested and tuned, running the **supplementary notebook** is **NOT** advised as the training and tuning would take a lot of time and memory space.\n",
    "\n",
    "As a summary of the other notebook, we experimented on the following:\n",
    "##### Six Single-Label Classifiers\n",
    "* Logistic Regression\n",
    "* Multinomial Naive Bayes\n",
    "* Random Forest Classifier\n",
    "* Gradient Boosting Classifier\n",
    "* eXtreme Gradient Boosting Classifier\n",
    "* AdaBoostClassifier Boosting Classifier\n",
    "* Stochastic Gradient Descent Classifier\n",
    "\n",
    "##### Multi-Label Classifiers\n",
    "* OneVsRest Classifier: Logistic Regression\n",
    "* OneVsRest Classifier: Multinomial Naive Bayes\n",
    "* MultiOutput Classifier: Logistic Regression\n",
    "* MultiOutput Classifier: Multinomial Naive Bayes\n",
    "\n",
    "For each type of the classifiers, at least two models were created: one for a TF-IDF vector input, and another for a Count vector input. However, for some of the models were also trained using word embeddings. From all of these implemented models, the MultiOutputClassifier, which can be found in this notebook, still scored the highest."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fc5da26",
   "metadata": {},
   "source": [
    "## Insights and Conclusions\n",
    "\n",
    "In doing this project, we used the data mining pipeline—without the data collection step—to create a model that can determine the type of toxicity a text shows. \n",
    "\n",
    "###### Exploring the Data\n",
    "First, we tried to understand the data that we were given so that we would know how to process the input for the model's use; this was done by exploring the data. In this, we checked the most frequently occuring words per class, the correlation between the different categories, the character count of the text data, and the number of instances each category has in the dataset. \n",
    "\n",
    "###### Preprocessing the Data\n",
    "Once we understood the data, we started the data pre-processing step. In this step, we cleaned the data by expanding the contractions, removing the punctuations, converting the characters into lowercase, and then removing non-word characters. After data cleaning, we did feature engineering where we transformed the given text into data that can be read by models. While we experimented with different feature engineering with text data (i.e., word embeddings with Word2Vec, TF-IDF Vectorization, and Count Vectorization), the importance of data cleaning, pre-processing, and deciding which features to utilize in the model was apparent; this is because the features given to the model will affect its predictions, and these depend on the task itself.\n",
    "\n",
    "For example, we had this preconceived notion that word embeddings would yield a higher score, as there are many studies that determine word embeddings have higher scores because it retains the relationship between words. However, models that used a TF-IDF vector actually scored higher compared to the models that used Count Vectors and word embeddings. Looking at the possible reasons why this is so, this might be because of how TF-IDF uses all of the features, by default, that it can get from the training data, while Word2Vec only gets 100 features by default. However, increasing the vector size of the Word2Vec would just result in a large amount of memory needed and a long training time for both the model and the word embedding. Thus, this was no longer explored further as the TF-IDF vector and the Count vector can already represent the data and serve as input to the model. The TF-IDF vector works might be because certain words are highly correlated to a specific class, as seen in the exploratory data analysis. As TF-IDF is able to represent the importance of words, this might have been picked up during the model training, which resulted in the success of these models.\n",
    "\n",
    "###### Modelling the Data\n",
    "The data pre-processing step is followed by the modeling, where we experimented with the different combinations of classifiers and multilabel strategies. Generally, we chose to experiment on classifiers which had high accuracy scores before tuning and can be quickly tuned; this was done in consideration of the time constraints imposed as it would be impractical to tune a model for days and receive only a minimal increase in accuracy, if any.\n",
    "\n",
    "For the classifiers, we mainly chose to experiment with the usage of Logistic Regression, Multinomial Naive Bayes, and Random Forest, while for the multi-labeling strategies, we tried MultiOutputClassifier, OneVsRestClassifier, ClassifierChain, and BinaryRelevance. While we also experimented with several other classifiers (i.e., Adaboost, XGBoost, Gradient Boosting, and Stochastic Gradient Descent), these were not prioritized due to the time complexity especially when tuning considering the number of hyperparameters these have.\n",
    "\n",
    "From creating models that utilized different algorithms and approaches for multi-label classification, we realized the importance of deeply understanding how the algorithm turns the input into the desired trained model. For instance, Binary Relevance requested around 200GB of memory in order to train a model using a vector (with no maximum features set) as an input. This led to the conclusion that different methods and algorithms have different needs, as we were able to make this work for other multi-labeling strategies (i.e., MultiOutputClassifier, OneVsRestClassifier).\n",
    "\n",
    "We also learned to think about the hyperparameters that we would be trying to tune as these would possibly improve the model's accuracy. In our case, we were confused at first about why the score of our models was decreasing when tuned. After some time, we discovered that the hyperparameter values that we used in the creation of the model were not included in the values of the hyperparameter that we were trying to tune. Moreover, we were not including the default values for the hyperparameters, and that for some models, these values were the best values. Fixing both of these issues rectified the error.\n",
    "\n",
    "Another mistake we made relates to our decision in setting some model's parameter **class_weight** to **balanced**, which means that the model would automatically calculate the class to be inversely proportional to the number of instances belonging to that class. At first, we considered this a hyperparameter to tune (i.e., **balanced** or **None**); this resulted in the model picking **None**, all the time. This was probably due to the fact that this value would result in a higher score, even though having a value of **None** for this parameter would result in the model predicting 0 (or False) most of the time. This does not affect the accuracy of the training data that much as most of the data has a value of 0 for the classes.\n",
    "\n",
    "###### Evaluating the Data\n",
    "Last, is the evaluation stage. This is done by submitting the resulting Comma-Separated Value (CSV) file to the Kaggle competition submission page. From this, the highest score that we received had a score of 0.97564, which means that it was able to predict 97.564% of the test data correctly. Whether n-classifiers, a One vs Rest classifier, or a Multi-output classifier was used, using a tuned or untuned Logistic Regression classifier as a base then training with TF-IDF vectors yielded the same score.\n",
    "\n",
    "Upon analysis of the meta-estimators, these all use the same concept as n-classifiers which explains why these models produced similar results. Moreover, tuned and untuned models have equal scores because the best found parameters are the default parameters. Logistic Regression might have been the best base estimator because it considers the input as a whole (i.e., in its whole form). This is unlike the Multinomial Naive Bayes which considers the probability of a class given each word.\n",
    "\n",
    "###### Recommendations\n",
    "For others who would like to take on this challenge, we would recommend tuning the TF-IDF vectorizer, as we only used the default parameters when vectorizing. Maybe a different tokenizer can be used, or stop words could have been removed, or maybe the accuracy would be affected by switching to character n-grams. Furthermore, they could also try other classifiers such as neural networks. One recommendation we found while researching is that the combination of word embeddings and neural networks may be effective, as such a model might be able to find patterns and correlations that a TF-IDF was not able to retain. Lastly, if a better machine is available, it might be beneficial to conduct more experiments on hyperparameter tuning, as we were limited by the specifications of our laptops. Some ensemble models, particularly, Adaboost and XGB models might have performed better if given enough resources for tuning."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92eec215",
   "metadata": {},
   "source": [
    "## Testing the Model\n",
    "Last, we can now test the model using a real-time input. The function `clean_test` is used to make the user input go through the data cleaning process easily."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "676222d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_test (text):\n",
    "    text = text.lower()\n",
    "    text = expand_contractions (text)\n",
    "    text = remove_other_chars (text)\n",
    "    return text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df8af32c",
   "metadata": {},
   "source": [
    "To stop the testing, type **stop**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "75dd5e98",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter text to check the type of toxicity of the text (if any): hello!\n",
      "\"hello!\" is: NOT of any type of toxicity. \n",
      "\n",
      "Enter text to check the type of toxicity of the text (if any): i miss you :(\n",
      "\"i miss you :(\" is: toxic (0.6527621554776144) \n",
      "\n",
      "Enter text to check the type of toxicity of the text (if any): stop\n"
     ]
    }
   ],
   "source": [
    "input_test = input(\"Enter text to check the type of toxicity of the text (if any): \")\n",
    "while input_test.lower() != \"stop\":\n",
    "    input_test_matrix = tfidf_vectorizer.transform([clean_test (input_test)])\n",
    "\n",
    "    results = best_model.predict(input_test_matrix)\n",
    "    probability = best_model.predict_proba(input_test_matrix)\n",
    "    \n",
    "    proba = []\n",
    "    for i in range (len(probability)):\n",
    "        temp = list(zip(*probability[i]))\n",
    "        a = str(temp[1]).split(',')[0] + ')'\n",
    "        proba.append(a)\n",
    "    \n",
    "    results_label = y_train.columns\n",
    "    \n",
    "    count = 0\n",
    "    result_string = '\"' + input_test + '\" is: '\n",
    "\n",
    "    for i in range (len(results[0])):\n",
    "        if (results [0][i] == 1):\n",
    "            if (count == 0):\n",
    "                result_string = result_string + results_label [i] + ' ' + proba [i]\n",
    "                count = count + 1\n",
    "            else:\n",
    "                result_string = result_string + ', ' + results_label [i] + ' ' + proba [i]\n",
    "                count = count + 1\n",
    "    \n",
    "    if (count == 0):\n",
    "        result_string = result_string + 'NOT of any type of toxicity.'\n",
    "\n",
    "    print(result_string, '\\n')\n",
    "    input_test = input(\"Enter text to check the type of toxicity of the text (if any): \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d90eea3",
   "metadata": {},
   "source": [
    "## References\n",
    "Dickinson, B. (2021, February 12). *Generate meaningful word clouds in Python*. Medium. Retrieved May 30, 2022, from https://towardsdatascience.com/generate-meaningful-word-clouds-in-python-5b85f5668eeb \n",
    "\n",
    "Statology. (2021, September 8). *F1 Score vs. Accuracy: Which Should You Use?*. https://www.statology.org/f1-score-vs-accuracy/\n",
    "\n",
    "Lukei. (2019, December 4). *Dealing with contractions in NLP*. Medium. Retrieved May 30, 2022, from https://medium.com/@lukei_3514/dealing-with-contractions-in-nlp-d6174300876b \n",
    "\n",
    "Raghunathan, D. (2020, June 9). *NLP in Python-Data Cleaning*. Medium. Retrieved May 30, 2022, from https://towardsdatascience.com/nlp-in-python-data-cleaning-6313a404a470 "
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}