NaiveBayes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1> <strong> <center> Model 1: Multinomial Naive Bayes Classification </center> </strong>  </h1> \n",
    "\n",
    "Our first model classifies a dataset of Urdu-language text articles using both a manual implementation of Multinomial Naive Bayes (MNB) and Scikit-learn's MNB model. The dataset is split into training, validation, and test sets, and the models are trained and evaluated on these. Metrics like accuracy, precision, recall, F1 score, and confusion matrices are calculated to assess performance. The results from the manual MNB implementation are compared with those from Scikit-learn to ensure consistency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 1) Library Imports </h4>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.metrics import (accuracy_score, classification_report, confusion_matrix, roc_auc_score, roc_curve)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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>gold_label</th>\n",
       "      <th>processed_content</th>\n",
       "      <th>processed_title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>entertainment</td>\n",
       "      <td>مشہور پنجابی گلوکار اداکار بلجیت دوران معلومات...</td>\n",
       "      <td>بھولنا بھی ۳ گانا پرانا بلجیت کارتک دھماکا دار...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>entertainment</td>\n",
       "      <td>بلا ووڈ دبنگ خان ممبئی ما شاہ رخ خان پرتعیش رہ...</td>\n",
       "      <td>سلمان خان شاہ رخ خان منت متعلق بڑا انکشاف</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>entertainment</td>\n",
       "      <td>بھارتی فلم ٹی وی معروف اداکارہ نیٹ فلکس مشہور ...</td>\n",
       "      <td>نیلم کوشیاری غیر متوقع سوال پرانا حیران حاضرین...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>entertainment</td>\n",
       "      <td>شہرت بلندی چھونا بلا ووڈ اداکار پربھاری تنا بڑ...</td>\n",
       "      <td>اداکار پربھاری فلم انڈسٹری بڑا معاہدہ کرلیا</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>entertainment</td>\n",
       "      <td>مشہور بھارتی سیریز ترک مہت الٹنا چشمہ سیٹ پران...</td>\n",
       "      <td>ترک مہت سیٹ پرانا جھگڑا دلیپ جوشی شہ چھوڑنا دھمکی</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      gold_label                                  processed_content  \\\n",
       "0  entertainment  مشہور پنجابی گلوکار اداکار بلجیت دوران معلومات...   \n",
       "1  entertainment  بلا ووڈ دبنگ خان ممبئی ما شاہ رخ خان پرتعیش رہ...   \n",
       "2  entertainment  بھارتی فلم ٹی وی معروف اداکارہ نیٹ فلکس مشہور ...   \n",
       "3  entertainment  شہرت بلندی چھونا بلا ووڈ اداکار پربھاری تنا بڑ...   \n",
       "4  entertainment  مشہور بھارتی سیریز ترک مہت الٹنا چشمہ سیٹ پران...   \n",
       "\n",
       "                                     processed_title  \n",
       "0  بھولنا بھی ۳ گانا پرانا بلجیت کارتک دھماکا دار...  \n",
       "1          سلمان خان شاہ رخ خان منت متعلق بڑا انکشاف  \n",
       "2  نیلم کوشیاری غیر متوقع سوال پرانا حیران حاضرین...  \n",
       "3        اداکار پربھاری فلم انڈسٹری بڑا معاہدہ کرلیا  \n",
       "4  ترک مہت سیٹ پرانا جھگڑا دلیپ جوشی شہ چھوڑنا دھمکی  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('scraped_data.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 2) Data Splitting </h4>\n",
    "\n",
    "- This part involves extracting the `gold_label` column from the dataframe to form the labels data.\n",
    "- It also involves using Scikit-Learn's `train_test_split` function to split the data into Training, Validation, and Testing datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training dataset shape: (1924, 2), (1924,)\n",
      "Validation dataset shape: (275, 2), (275,)\n",
      "Test dataset shape: (550, 2), (550,)\n"
     ]
    }
   ],
   "source": [
    "X = df.drop('gold_label', axis=1)  \n",
    "y = df['gold_label'] \n",
    "\n",
    "train_size = 0.7\n",
    "validation_size = 0.10\n",
    "test_size = 0.20\n",
    "\n",
    "X_train_validation, X_test, y_train_validation, y_test = train_test_split(X, y, test_size= test_size, random_state= 42, stratify= y)\n",
    "X_train, X_validation, y_train, y_validation = train_test_split(X_train_validation, y_train_validation, test_size= (validation_size / (train_size + validation_size)), random_state= 42, stratify= y_train_validation)\n",
    "\n",
    "print(f\"Training dataset shape: {X_train.shape}, {y_train.shape}\")\n",
    "print(f\"Validation dataset shape: {X_validation.shape}, {y_validation.shape}\")\n",
    "print(f\"Test dataset shape: {X_test.shape}, {y_test.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 3) Vectorizing the Data/Text </h4>\n",
    "\n",
    "Now that we have completed the preprocessing of our data, we will need to vectorize our sentences - this is necessary to be able to numericalize our inputs before feeding them into our model. \n",
    "\n",
    "We will be using the `Bag of Words` approach to vectorize our sentences, which we implemented in PA1_1. <br> \n",
    "Here, we create a `BagOfWords` class to vectorize our sentences. This will involve creating\n",
    "\n",
    "1. A vocabulary from our corpus\n",
    "\n",
    "2. A mapping from words to indices in our vocabulary\n",
    "\n",
    "3. A function to vectorize a sentence in the fashion described above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BagOfWords:\n",
    "    def __init__(self):\n",
    "        self.vocabulary = {}\n",
    "    \n",
    "    def fit(self, texts):\n",
    "        for text in texts:\n",
    "            for word in text.split():\n",
    "                if word not in self.vocabulary:\n",
    "                    self.vocabulary[word] = len(self.vocabulary)\n",
    "    \n",
    "    def vectorize(self, text):\n",
    "        vector = np.zeros(len(self.vocabulary), dtype=int) \n",
    "        for word in text.split():\n",
    "            if word in self.vocabulary:\n",
    "                vector[self.vocabulary[word]] += 1\n",
    "        return vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "bow = BagOfWords()\n",
    "bow.fit(X_train['processed_content'])\n",
    "\n",
    "train_data_vectors = np.array([bow.vectorize(text) for text in X_train['processed_content']])\n",
    "validation_data_vectors = np.array([bow.vectorize(text) for text in X_validation['processed_content']])\n",
    "test_data_vectors = np.array([bow.vectorize(text) for text in X_test['processed_content']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 4) Implementing the Naive Bayes Machine Learning Model from Scratch </h4>\n",
    "\n",
    "Now, we implement a manual version of the Multinomial Naive Bayes (MNB) classifier using two functions. \n",
    "\n",
    "1. **`train_MNB` Function**: Computes the class priors and likelihoods for each word in the dataset. It uses Laplace smoothing to handle unseen words and calculates the probabilities based on word frequencies in the training data for each class.\n",
    "   \n",
    "2. **`MNB_classifier` Function**: Uses the computed priors and likelihoods to classify new data. It calculates the log probabilities of each class for a given input and assigns the class with the highest probability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def train_MNB(X, y):\n",
    "    \"\"\"\n",
    "    Train a Multinomial Naive Bayes model.\n",
    "    \"\"\"\n",
    "    classes, counts = np.unique(y, return_counts=True)\n",
    "    num_classes = len(classes)\n",
    "    priors = counts / len(y)\n",
    "    num_features = X.shape[1]\n",
    "    likelihoods = np.zeros((num_classes, num_features))\n",
    "\n",
    "    for i, class_label in enumerate(classes):\n",
    "        X_class = X[y == class_label]\n",
    "        word_count = X_class.sum(axis=0)\n",
    "        likelihoods[i, :] = (word_count + 1) / (word_count.sum() + num_features)  # Laplace smoothing\n",
    "\n",
    "    likelihoods += 1e-10  # To avoid numerical stability issues\n",
    "    return priors, likelihoods, classes\n",
    "\n",
    "def MNB_classifier(X, class_priors, likelihoods, classes):\n",
    "    \"\"\"\n",
    "    Predict labels for given data using a trained MNB model.\n",
    "    \"\"\"\n",
    "    log_probabilities = np.zeros((X.shape[0], len(classes)))\n",
    "\n",
    "    for i in range(len(classes)):\n",
    "        log_prior = np.log(class_priors[i])\n",
    "        log_likelihood = np.log(likelihoods[i, :])\n",
    "        log_probabilities[:, i] = log_prior + np.dot(X, log_likelihood)\n",
    "\n",
    "    return classes[np.argmax(log_probabilities, axis=1)]\n",
    "\n",
    "def bootstrap_sample(X, y):\n",
    "    \"\"\"\n",
    "    Generate a bootstrap sample from X and y.\n",
    "    \"\"\"\n",
    "    n_samples = X.shape[0]\n",
    "    indices = np.random.randint(0, n_samples, n_samples)\n",
    "    return X.iloc[indices] if isinstance(X, pd.DataFrame) else X[indices], y.iloc[indices] if isinstance(y, pd.Series) else y[indices]\n",
    "\n",
    "def train_bagging_naive_bayes(X, y, n_estimators=10):\n",
    "    \"\"\"\n",
    "    Train a bagging ensemble of Naive Bayes models.\n",
    "    \"\"\"\n",
    "    models = []\n",
    "    for _ in range(n_estimators):\n",
    "        X_sample, y_sample = bootstrap_sample(X, y)\n",
    "        priors, likelihoods, classes = train_MNB(X_sample, y_sample)\n",
    "        models.append((priors, likelihoods))\n",
    "    return models, classes\n",
    "\n",
    "def predict_bagging_naive_bayes(X, models, classes):\n",
    "    \"\"\"\n",
    "    Predict labels using a bagging ensemble of Naive Bayes models.\n",
    "    \"\"\"\n",
    "    n_classes = len(classes)\n",
    "    predictions = np.zeros((X.shape[0], n_classes))\n",
    "\n",
    "    for priors, likelihoods in models:\n",
    "        model_predictions = MNB_classifier(X, priors, likelihoods, classes)\n",
    "        for i, class_label in enumerate(model_predictions):\n",
    "            class_index = np.where(classes == class_label)[0][0] \n",
    "            predictions[i, class_index] += 1\n",
    "\n",
    "    return classes[np.argmax(predictions, axis=1)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 5) Testing on the Validation Dataset </h4>\n",
    "\n",
    "Here, we test our model on the validation dataset and assess its performance using the following metrics:\n",
    "- Accuracy\n",
    "- Class-wise Precision\n",
    "- Class-wise Recall\n",
    "- Macro F1 Score\n",
    "- Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class_priors, likelihoods, classes = train_MNB(train_data_vectors, y_train.values)\n",
    "# validation_predictions = np.array(MNB_classifier(validation_data_vectors, class_priors, likelihoods, classes))\n",
    "# validation_actual = y_validation.values\n",
    "\n",
    "n_estimators = 1000\n",
    "bagging_models, bagging_classes = train_bagging_naive_bayes(train_data_vectors, y_train, n_estimators)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_heat_map(confusion_matrix, title):\n",
    "  plt.figure(figsize=(12, 6))\n",
    "  sns.heatmap(confusion_matrix, fmt=\"d\", annot= True, cmap= \"Blues\", cbar= True)\n",
    "  plt.title(title)\n",
    "  plt.xlabel(\"True Label\")\n",
    "  plt.ylabel(\"Predicted Label\")\n",
    "  plt.show()\n",
    "\n",
    "def evaluate(y_actual, y_predicted, class_labels):\n",
    "    accuracy = accuracy_score(y_actual, y_predicted)\n",
    "    print(f\"Accuracy: {accuracy * 100:.2f}%\\n\")\n",
    "    \n",
    "    print(\"Classification Report:\")\n",
    "    print(classification_report(y_actual, y_predicted, target_names=list(map(str, class_labels))))\n",
    "    \n",
    "    cm = confusion_matrix(y_actual, y_predicted, labels=class_labels)\n",
    "    make_heat_map(cm, \"Confusion Matrix\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 95.64%\n",
      "\n",
      "Classification Report:\n",
      "                    precision    recall  f1-score   support\n",
      "\n",
      "          business       1.00      0.96      0.98        54\n",
      "     entertainment       0.94      1.00      0.97        61\n",
      "science-technology       0.94      0.91      0.93        34\n",
      "            sports       0.98      0.98      0.98        63\n",
      "             world       0.92      0.90      0.91        63\n",
      "\n",
      "          accuracy                           0.96       275\n",
      "         macro avg       0.96      0.95      0.95       275\n",
      "      weighted avg       0.96      0.96      0.96       275\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bagging_validation_predictions = predict_bagging_naive_bayes(validation_data_vectors, bagging_models, bagging_classes)\n",
    "evaluate(y_validation, bagging_validation_predictions, bagging_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 6) Testing on the Test Dataset </h4>\n",
    "\n",
    "Here, we test our model on the test dataset and assess its performance using the metrics mentioned above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class_priors, likelihoods, classes = train_MNB(train_data_vectors, y_train.values)\n",
    "# test_predictions = np.array(MNB_classifier(test_data_vectors, class_priors, likelihoods, classes))\n",
    "# test_actual = y_test.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 96.55%\n",
      "\n",
      "Classification Report:\n",
      "                    precision    recall  f1-score   support\n",
      "\n",
      "          business       0.98      0.97      0.98       108\n",
      "     entertainment       0.98      0.98      0.98       121\n",
      "science-technology       0.94      0.94      0.94        69\n",
      "            sports       0.99      0.98      0.99       127\n",
      "             world       0.93      0.94      0.94       125\n",
      "\n",
      "          accuracy                           0.97       550\n",
      "         macro avg       0.96      0.96      0.96       550\n",
      "      weighted avg       0.97      0.97      0.97       550\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bagging_test_predictions = predict_bagging_naive_bayes(test_data_vectors, bagging_models, bagging_classes)\n",
    "evaluate(y_test, bagging_test_predictions, bagging_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 7) Implementing the Naive Bayes Machine Learning Model using Scikit-Learn </h4>\n",
    "\n",
    "Here we simply implement the Naive Bayes model using the Scikit-Learn library to compare the performance of our own model with that of the standard Scikit-Learn one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sklearn Multinomial Naive Bayes Accuracy for validation data set: 95.64%\n",
      "Manual Multinomial Naive Bayes Accuracy for validation data set: 95.64% \n",
      "\n",
      "Sklearn Multinomial Naive Bayes Accuracy for test data set: 96.73%\n",
      "Manual Multinomial Naive Bayes Accuracy for test data set: 96.55%\n"
     ]
    }
   ],
   "source": [
    "mnb = MultinomialNB()\n",
    "mnb.fit(train_data_vectors, y_train)\n",
    "\n",
    "y_validation_predicted_sklearn_MNB = mnb.predict(validation_data_vectors) \n",
    "y_test_predicted_sklearn_MNB = mnb.predict(test_data_vectors) \n",
    "\n",
    "sklearn_accuracy_validation = accuracy_score(y_validation, y_validation_predicted_sklearn_MNB) \n",
    "sklearn_accuracy_test = accuracy_score(y_test, y_test_predicted_sklearn_MNB)  \n",
    "manual_accuracy_validation = accuracy_score(y_validation, bagging_validation_predictions)  \n",
    "manual_accuracy_test = accuracy_score(y_test, bagging_test_predictions)  \n",
    "\n",
    "print(f\"Sklearn Multinomial Naive Bayes Accuracy for validation data set: {sklearn_accuracy_validation * 100:.2f}%\")\n",
    "print(f\"Manual Multinomial Naive Bayes Accuracy for validation data set: {manual_accuracy_validation * 100:.2f}% \\n\")\n",
    "print(f\"Sklearn Multinomial Naive Bayes Accuracy for test data set: {sklearn_accuracy_test * 100:.2f}%\")\n",
    "print(f\"Manual Multinomial Naive Bayes Accuracy for test data set: {manual_accuracy_test * 100:.2f}%\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "AI_env",
   "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}