Naive-Bayes - Classificator.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multinomial Naïve Bayes Classifier - the YouTube Spam Collection Data Set\n",
    "Dataset from kaggle:\n",
    "https://www.kaggle.com/datasets/lakshmi25npathi/images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome! In this Project I'm willing to practice a classification problem with the Naïve Bayes Classificator.\n",
    "\n",
    "I chose this Algorithm in order to practice it.\n",
    "\n",
    "The problem to solve is to classify YouTube comments either as Spam or Ham.\n",
    "\n",
    "The Dataset is found in Kaggle ([link here](https://www.kaggle.com/datasets/lakshmi25npathi/images)).\n",
    "\n",
    "Well, let's Classify!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing the necessary libreries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pandas to handle the data and numpy for math calculations\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# train_test_split for separating in a reproducible way\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# CountVectorizer for transforming the comments in word's vectors\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "\n",
    "# Two Naïve Bayes classifiers we are going to try\n",
    "from sklearn.naive_bayes import MultinomialNB, ComplementNB\n",
    "\n",
    "# ConfusionMatrixDisplay and classification_report for Metrics visualization\n",
    "from sklearn.metrics import ConfusionMatrixDisplay, classification_report\n",
    "\n",
    "# To look through file\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reading and exploring the database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Youtube01-Psy.csv', 'Youtube02-KatyPerry.csv', 'Youtube03-LMFAO.csv', 'Youtube04-Eminem.csv', 'Youtube05-Shakira.csv']\n"
     ]
    }
   ],
   "source": [
    "# Save the names of the files that contain the data in a list and print i\n",
    "datasets_list = os.listdir('Data/')\n",
    "\n",
    "print(datasets_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, there are 5 files containing comments, each file for a different Youtube Video of a differente artist:\n",
    "\n",
    "- Psy (The korean singer behind the world phenomenom Gangnam Style)\n",
    "- Katy Perry\n",
    "- LMFAO\n",
    "- Eminem\n",
    "- And from my home country Colombia ♥️: Shakira"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Columns for each df\n",
      "\n",
      "['COMMENT_ID' 'AUTHOR' 'DATE' 'CONTENT' 'CLASS']\n",
      "['COMMENT_ID' 'AUTHOR' 'DATE' 'CONTENT' 'CLASS']\n",
      "['COMMENT_ID' 'AUTHOR' 'DATE' 'CONTENT' 'CLASS']\n",
      "['COMMENT_ID' 'AUTHOR' 'DATE' 'CONTENT' 'CLASS']\n",
      "['COMMENT_ID' 'AUTHOR' 'DATE' 'CONTENT' 'CLASS']\n",
      "\n",
      "Shape of each df\n",
      "\n",
      "(350, 5)\n",
      "(350, 5)\n",
      "(438, 5)\n",
      "(448, 5)\n",
      "(370, 5)\n",
      "\n",
      "Total of rows:  1956\n"
     ]
    }
   ],
   "source": [
    "# Load the data into DataFrames and store those DataFrames into a list\n",
    "dataframes_list = [pd.read_csv(f'Data/{dataset}') for dataset in datasets_list]\n",
    "\n",
    "# Loop to see the columns on each df\n",
    "print(\"Columns for each df\\n\")\n",
    "for df in dataframes_list:\n",
    "    print(df.columns.values)\n",
    "\n",
    "# See the shape in each df and the total amount of rows\n",
    "rows_count = 0\n",
    "print(\"\\nShape of each df\\n\")\n",
    "for df in dataframes_list:\n",
    "    print(df.shape)\n",
    "    rows_count += df.shape[0]\n",
    "\n",
    "print('\\nTotal of rows: ', rows_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, each dataframe contains the same columns (that's good luck for us).\n",
    "\n",
    "The total amount of rows add up to 1956 comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>COMMENT_ID</th>\n",
       "      <th>AUTHOR</th>\n",
       "      <th>DATE</th>\n",
       "      <th>CONTENT</th>\n",
       "      <th>CLASS</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>LZQPQhLyRh80UYxNuaDWhIGQYNQ96IuCg-AYWqNPjpU</td>\n",
       "      <td>Julius NM</td>\n",
       "      <td>2013-11-07T06:20:48</td>\n",
       "      <td>Huh, anyway check out this you[tube] channel: ...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>LZQPQhLyRh_C2cTtd9MvFRJedxydaVW-2sNg5Diuo4A</td>\n",
       "      <td>adam riyati</td>\n",
       "      <td>2013-11-07T12:37:15</td>\n",
       "      <td>Hey guys check out my new channel and our firs...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>LZQPQhLyRh9MSZYnf8djyk0gEF9BHDPYrrK-qCczIY8</td>\n",
       "      <td>Evgeny Murashkin</td>\n",
       "      <td>2013-11-08T17:34:21</td>\n",
       "      <td>just for test I have to say murdev.com</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>z13jhp0bxqncu512g22wvzkasxmvvzjaz04</td>\n",
       "      <td>ElNino Melendez</td>\n",
       "      <td>2013-11-09T08:28:43</td>\n",
       "      <td>me shaking my sexy ass on my channel enjoy ^_^ ﻿</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>z13fwbwp1oujthgqj04chlngpvzmtt3r3dw</td>\n",
       "      <td>GsMega</td>\n",
       "      <td>2013-11-10T16:05:38</td>\n",
       "      <td>watch?v=vtaRGgvGtWQ   Check this out .﻿</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                    COMMENT_ID            AUTHOR  \\\n",
       "0  LZQPQhLyRh80UYxNuaDWhIGQYNQ96IuCg-AYWqNPjpU         Julius NM   \n",
       "1  LZQPQhLyRh_C2cTtd9MvFRJedxydaVW-2sNg5Diuo4A       adam riyati   \n",
       "2  LZQPQhLyRh9MSZYnf8djyk0gEF9BHDPYrrK-qCczIY8  Evgeny Murashkin   \n",
       "3          z13jhp0bxqncu512g22wvzkasxmvvzjaz04   ElNino Melendez   \n",
       "4          z13fwbwp1oujthgqj04chlngpvzmtt3r3dw            GsMega   \n",
       "\n",
       "                  DATE                                            CONTENT  \\\n",
       "0  2013-11-07T06:20:48  Huh, anyway check out this you[tube] channel: ...   \n",
       "1  2013-11-07T12:37:15  Hey guys check out my new channel and our firs...   \n",
       "2  2013-11-08T17:34:21             just for test I have to say murdev.com   \n",
       "3  2013-11-09T08:28:43   me shaking my sexy ass on my channel enjoy ^_^ ﻿   \n",
       "4  2013-11-10T16:05:38            watch?v=vtaRGgvGtWQ   Check this out .﻿   \n",
       "\n",
       "   CLASS  \n",
       "0      1  \n",
       "1      1  \n",
       "2      1  \n",
       "3      1  \n",
       "4      1  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's see what the one of the dfs cointains\n",
    "\n",
    "dataframes_list[0].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preparing the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We only need the last two columns: CONTENT and CLASS.\n",
    "Let's drop them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['CONTENT' 'CLASS']\n",
      "['CONTENT' 'CLASS']\n",
      "['CONTENT' 'CLASS']\n",
      "['CONTENT' 'CLASS']\n",
      "['CONTENT' 'CLASS']\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>CONTENT</th>\n",
       "      <th>CLASS</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Huh, anyway check out this you[tube] channel: ...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Hey guys check out my new channel and our firs...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>just for test I have to say murdev.com</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>me shaking my sexy ass on my channel enjoy ^_^ ﻿</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>watch?v=vtaRGgvGtWQ   Check this out .﻿</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                             CONTENT  CLASS\n",
       "0  Huh, anyway check out this you[tube] channel: ...      1\n",
       "1  Hey guys check out my new channel and our firs...      1\n",
       "2             just for test I have to say murdev.com      1\n",
       "3   me shaking my sexy ass on my channel enjoy ^_^ ﻿      1\n",
       "4            watch?v=vtaRGgvGtWQ   Check this out .﻿      1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Columns to Drop\n",
    "dropping_columns = ['COMMENT_ID', 'AUTHOR', 'DATE']\n",
    "\n",
    "# Loop through each df\n",
    "for index in range(len(dataframes_list)):\n",
    "    \n",
    "    # Checking if one of the columns is on each df if the cell is run twice\n",
    "    if dropping_columns[0] in dataframes_list[index].columns:\n",
    "    \n",
    "        # Dropping the columns on each df\n",
    "        dataframes_list[index] = dataframes_list[index].drop(dropping_columns, axis=1)\n",
    "    \n",
    "    # Print the columns on each df after the drop\n",
    "    print(dataframes_list[index].columns.values)\n",
    "    \n",
    "# Let's see\n",
    "dataframes_list[0].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After we droppped the columns we didn't need. Let's concatenate all the dfs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rows before concatenating:  1956 Rows after concatenating:  1956\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>CONTENT</th>\n",
       "      <th>CLASS</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Huh, anyway check out this you[tube] channel: ...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Hey guys check out my new channel and our firs...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>just for test I have to say murdev.com</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>me shaking my sexy ass on my channel enjoy ^_^ ﻿</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>watch?v=vtaRGgvGtWQ   Check this out .﻿</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                             CONTENT  CLASS\n",
       "0  Huh, anyway check out this you[tube] channel: ...      1\n",
       "1  Hey guys check out my new channel and our firs...      1\n",
       "2             just for test I have to say murdev.com      1\n",
       "3   me shaking my sexy ass on my channel enjoy ^_^ ﻿      1\n",
       "4            watch?v=vtaRGgvGtWQ   Check this out .﻿      1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Concatenate all dfs in just one\n",
    "df = pd.concat(dataframes_list, axis=0, ignore_index=True)\n",
    "\n",
    "# Let's confirm the number of rows\n",
    "print('Rows before concatenating: ', rows_count, 'Rows after concatenating: ', df.shape[0])\n",
    "\n",
    "# Let's see the output\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numbers add up! Let's look for Null values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CONTENT    0\n",
       "CLASS      0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check null values per columns\n",
    "df.isnull().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apparently the perfect data exists... Just kidding. Though having no null values helps a lot.\n",
    "\n",
    "Let's check the distribution of the classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    0.513804\n",
       "0    0.486196\n",
       "Name: CLASS, dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Balance of the classes\n",
    "df['CLASS'].value_counts(normalize=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is great! We have a pretty good and balanced dataset, this also helps a lot for the learning of the algorithm we are going to use.\n",
    "\n",
    "Meanings of each class:\n",
    "\n",
    "- Class 1: The comment is Spam\n",
    "- Class 2: The comment is Ham"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spliting the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separating the columns into predictors (CONTENT) and target (CLASS)\n",
    "input = df['CONTENT']\n",
    "target = df['CLASS']\n",
    "\n",
    "x_train, x_test, y_train, y_test = train_test_split(\n",
    "                                                    input, # The predictors\n",
    "                                                    target, # The target\n",
    "                                                    test_size=.2, # Portion for splitting the data\n",
    "                                                    stratify=target, # Columns to guide the stratification of the classes in the sets\n",
    "                                                    random_state=365 # random state for reproducibility\n",
    "                                                    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    0.514066\n",
       "0    0.485934\n",
       "Name: CLASS, dtype: float64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's check if the stratification worked\n",
    "# y train\n",
    "y_train.value_counts(normalize=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    0.512755\n",
       "0    0.487245\n",
       "Name: CLASS, dtype: float64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's check if the stratification worked\n",
    "# y test\n",
    "y_test.value_counts(normalize=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apparently the stratification worked, let's continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transforming the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "513     https://www.facebook.com/pages/Nailey-nicool/6...\n",
       "1821                                                   :)\n",
       "973                  Check out this playlist on YouTube:﻿\n",
       "916                     Check out this video on YouTube:﻿\n",
       "1323    This past Christmas my dad passed away, to hel...\n",
       "Name: CONTENT, dtype: object"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see it consists on comments, but how will the algorithm will read the information?\n",
    "\n",
    "Well, we are going to use CountVectorizer from Sklearn. A class that turns the data into a matrix, in which each column represents a word (it does it with each word with a lenght greater than 1 letter). And each row represents how many times the word appeard in the comment.\n",
    "\n",
    "Let's do it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import CountVectorizer Class\n",
    "vectorizer = CountVectorizer()\n",
    "\n",
    "# Fit_transform our data in the training set\n",
    "x_train_transf = vectorizer.fit_transform(x_train)\n",
    "\n",
    "# Transform the data based only on the train set\n",
    "x_test_transf = vectorizer.transform(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to take a look to the matrix it generates (that is a scipy sparse matrix), you can take a look at it with the .toarray() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0]], dtype=int64)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train_transf.toarray()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see the words each column represent with the .get_feature_names_out() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['00', '000', '002', ..., 'ｔｈｉｓ', 'ｕｓｒ', 'ｗｗｗ'], dtype=object)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vectorizer.get_feature_names_out()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a random sample:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['last', 'team', 'chubby', 'short', 'hw', 'donating', 'lane', 'fit',\n",
       "       'loosing', 'countless'], dtype=object)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Random sample of the words that represent a column in the transformed data\n",
    "np.random.choice(vectorizer.get_feature_names_out(), size=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see the lenght of the matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1564,)\n",
      "(1564, 3814)\n"
     ]
    }
   ],
   "source": [
    "# Shape of the train predictors\n",
    "print(x_train.shape)\n",
    "\n",
    "# Shape of the transformed predictors\n",
    "print(x_train_transf.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that we get 3814 words in the entire training dataset.\n",
    "\n",
    "Let's confirm this in the test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(392,)\n",
      "(392, 3814)\n"
     ]
    }
   ],
   "source": [
    "# Shape of the test set and the transformed test set\n",
    "print(x_test.shape)\n",
    "print(x_test_transf.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, we are ready to train our model!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, we are going to use two classificators (very used in text classification) for Naïve Bayes from Sklearn and checked their performances:\n",
    "\n",
    "- **MultinomialNB:** Uses relative frequency countings for calculating probabilities\n",
    "- **ComplementNB:** Adaptation of the standard multinomial naive Bayes (MNB) algorithm that is particularly suited for imbalanced data sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Default MultinomialNB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>MultinomialNB()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">MultinomialNB</label><div class=\"sk-toggleable__content\"><pre>MultinomialNB()</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "MultinomialNB()"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set the class Multinomial NB\n",
    "clf = MultinomialNB()\n",
    "\n",
    "# Fit the train set to it\n",
    "clf.fit(x_train_transf, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'alpha': 1.0, 'class_prior': None, 'fit_prior': True}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can check the parameters. Alpha is a Smoothing parameter that does not allow probabilities to be zero\n",
    "# Class priors: probabilities of belonging to each class\n",
    "# Fit prior: if the priors should be calculated from the data or should be considered to be uniformed\n",
    "clf.get_params()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make predictions out of test set\n",
    "y_test_predict = clf.predict(x_test_transf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see its performance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Class that displays Confussion Matrix with a heatmap\n",
    "ConfusionMatrixDisplay.from_predictions(\n",
    "    y_test, y_test_predict,\n",
    "    labels=clf.classes_\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at some other metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         Ham       0.94      0.87      0.91       191\n",
      "        Spam       0.89      0.95      0.92       201\n",
      "\n",
      "    accuracy                           0.91       392\n",
      "   macro avg       0.91      0.91      0.91       392\n",
      "weighted avg       0.91      0.91      0.91       392\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Metrics report\n",
    "print(classification_report(y_test, y_test_predict, target_names=['Ham', 'Spam']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see it performed quite well in the Spam Precision, however, let's see if we can improve this value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. MultinomialNB Adjusting Priors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well let's make a simple assumption: The internet normally behaves better and the percentage of Spam comments is lower than the Ham ones, so let's change the priors to:\n",
    "\n",
    "- Ham comments: 60%\n",
    "- Spam comments: 40%\n",
    "\n",
    "Let's check how this performs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alpha': 1.0, 'class_prior': [0.6, 0.4], 'fit_prior': True}\n"
     ]
    }
   ],
   "source": [
    "# MultinomialNB with changed priors\n",
    "clf2 = MultinomialNB(class_prior=[.6, .4])\n",
    "\n",
    "# Fit values\n",
    "clf2.fit(x_train_transf, y_train)\n",
    "\n",
    "# Print the params\n",
    "print(clf2.get_params())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see its predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Predict\n",
    "y_test_predict2 = clf2.predict(x_test_transf)\n",
    "\n",
    "# Confusion Matrix\n",
    "ConfusionMatrixDisplay.from_predictions(\n",
    "    y_test,\n",
    "    y_test_predict2,\n",
    "    labels=clf2.classes_\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wow, the False Positives decreased, let's look at the metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         Ham       0.94      0.96      0.95       191\n",
      "        Spam       0.96      0.95      0.95       201\n",
      "\n",
      "    accuracy                           0.95       392\n",
      "   macro avg       0.95      0.95      0.95       392\n",
      "weighted avg       0.95      0.95      0.95       392\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, y_test_predict2, target_names=['Ham', 'Spam']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeed, the recall improved a lot as it was one of the lowest values for the Ham predictions.\n",
    "\n",
    "Let's take this to another level"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. MultinomialNB Adjusting Priors vol 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use other distribution and assume that the internet behaves way better\n",
    "\n",
    "- Ham comments: 70%\n",
    "- Spam comments: 30%\n",
    "\n",
    "Let's check how this performs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alpha': 1.0, 'class_prior': [0.7, 0.3], 'fit_prior': True}\n"
     ]
    }
   ],
   "source": [
    "# MultinomialNB with changed priors\n",
    "clf3 = MultinomialNB(class_prior=[.7, .3])\n",
    "\n",
    "# Fit values\n",
    "clf3.fit(x_train_transf, y_train)\n",
    "\n",
    "# Print the params\n",
    "print(clf3.get_params())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see its predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Predict\n",
    "y_test_predict3 = clf3.predict(x_test_transf)\n",
    "\n",
    "# Confusion Matrix\n",
    "ConfusionMatrixDisplay.from_predictions(\n",
    "    y_test,\n",
    "    y_test_predict3,\n",
    "    labels=clf3.classes_\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The False Positives decreased again, however it seems that from this point the false negatives seem to start increasing at this point. Let's take a look at the metrics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         Ham       0.94      0.97      0.95       191\n",
      "        Spam       0.97      0.94      0.95       201\n",
      "\n",
      "    accuracy                           0.95       392\n",
      "   macro avg       0.95      0.95      0.95       392\n",
      "weighted avg       0.95      0.95      0.95       392\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, y_test_predict3, target_names=['Ham', 'Spam']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nevertheless we achive to improve the precision for Spams one point! This shows the importance for trying out different parameters. I will choose this model as our classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus: ComplimentNB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deep inside me wanted to try out this one because it has shown better results for text classification. Let's see how it goes with the parameters from the classifier we chose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alpha': 1.0, 'class_prior': [0.7, 0.3], 'fit_prior': True, 'norm': False}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "clf4 = ComplementNB(class_prior=[0.7,0.3])\n",
    "clf4.fit(x_train_transf, y_train)\n",
    "print(clf4.get_params())\n",
    "\n",
    "y_test_predict4 = clf4.predict(x_test_transf)\n",
    "\n",
    "ConfusionMatrixDisplay.from_predictions(\n",
    "    y_test,\n",
    "    y_test_predict4,\n",
    "    labels=clf4.classes_\n",
    ");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         Ham       0.94      0.92      0.93       191\n",
      "        Spam       0.93      0.95      0.94       201\n",
      "\n",
      "    accuracy                           0.93       392\n",
      "   macro avg       0.93      0.93      0.93       392\n",
      "weighted avg       0.93      0.93      0.93       392\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, y_test_predict4, target_names=['Ham', 'Spam']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, it seems that the results were real good, however it seems that because the dataset was well balanced, the MultinomialNB gives better results with the priors = [0.7, 0.3]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion and prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do some predictions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1], dtype=int64)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Transform two made up comments, One that is a Ham and one that is Spam, respectively\n",
    "data_to_predict = vectorizer.transform(['Shakira is the best, love to Colombia!',\n",
    "                                        'click here to earn easy money, 100% real'])\n",
    "\n",
    "# Prediction\n",
    "clf3.predict(data_to_predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Effectively, the prediction was correct.\n",
    "\n",
    "We can conclude that Naive Bayes is efficent as a text Classifier with great performance. Let's see in next commits how we can take this to another level.\n",
    "\n",
    "Thanks for reading"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.11.0 ('naive-bayes_classificator')",
   "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.11.0"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "8e400ec7822a00590dd0c982e2406cf595442efbb3559e82c22d3e4733b7a00e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}