LogisticRegression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1> <strong> <center> Model 2: Logistic Regression </center> </strong>  </h1> \n",
    "\n",
    "Our second model preprocesses and classifies a dataset of Urdu-language text articles using both a manual implementation of Logisitic Regression and Scikit-learn's version of the model. The dataset is split and evaluated in the same manner as it was in the implementation of our first model. The results from the manual 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": 56,
   "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.metrics import (accuracy_score, classification_report, confusion_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 2) Data Cleaning and Text Preprocessing </h4>\n",
    "\n",
    "We have used the Regex and LughaatNLP libraries to clean and preprocess Urdu text. \n",
    "This includes:\n",
    "- removes URLs\n",
    "- removes punctuation\n",
    "- removes non-alphanumeric characters\n",
    "- normalizes the text \n",
    "- eliminates stopwords \n",
    "- corrects spelling \n",
    "- tokenizes the text into words\n",
    "- joins the tokens back into a processed string\n",
    "\n",
    "After that we import our clean dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2749, 3)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>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",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      gold_label                                  processed_content  \\\n",
       "0  entertainment  مشہور پنجابی گلوکار اداکار بلجیت دوران معلومات...   \n",
       "1  entertainment  بلا ووڈ دبنگ خان ممبئی ما شاہ رخ خان پرتعیش رہ...   \n",
       "2  entertainment  بھارتی فلم ٹی وی معروف اداکارہ نیٹ فلکس مشہور ...   \n",
       "\n",
       "                                     processed_title  \n",
       "0  بھولنا بھی ۳ گانا پرانا بلجیت کارتک دھماکا دار...  \n",
       "1          سلمان خان شاہ رخ خان منت متعلق بڑا انکشاف  \n",
       "2  نیلم کوشیاری غیر متوقع سوال پرانا حیران حاضرین...  "
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv(\"scraped_data.csv\")\n",
    "print(df.shape)\n",
    "df.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 3) 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": 58,
   "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)\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)\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> 4) Label Encoding and Vectorization </h4>\n",
    "\n",
    "- Here, we convert the categorical labels into numeric format using a custom class, MyLabelEncoder\n",
    "- Then, we convert text into numerical features using another custom class, MyCountVectorizer with a vocabulary of the 1,000 most frequent words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyLabelEncoder:\n",
    "    def __init__(self):\n",
    "        self.classes_ = None\n",
    "        self.class_to_index = {}\n",
    "        self.index_to_class = {}\n",
    "\n",
    "    def fit(self, labels):\n",
    "        self.classes_ = sorted(set(labels))\n",
    "        self.class_to_index = {cls: idx for idx, cls in enumerate(self.classes_)}\n",
    "        self.index_to_class = {idx: cls for cls, idx in self.class_to_index.items()}\n",
    "        return self\n",
    "\n",
    "    def transform(self, labels):\n",
    "        transformed_labels = []\n",
    "        for label in labels:\n",
    "            index = self.class_to_index[label]\n",
    "            transformed_labels.append(index)\n",
    "        return transformed_labels\n",
    "\n",
    "    def inverse_transform(self, indices):\n",
    "        original_labels = []\n",
    "        for index in indices:\n",
    "            label = self.index_to_class[index]\n",
    "            original_labels.append(label)\n",
    "        return original_labels\n",
    "\n",
    "    def fit_transform(self, labels):\n",
    "        self.fit(labels)\n",
    "        return self.transform(labels)\n",
    "\n",
    "label_encoder = MyLabelEncoder()\n",
    "\n",
    "y_train_encoded = label_encoder.fit_transform(y_train)\n",
    "y_validation_encoded = label_encoder.transform(y_validation)\n",
    "y_test_encoded = label_encoder.transform(y_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_features = X_train['processed_content'].values\n",
    "X_validation_features = X_validation['processed_content'].values\n",
    "X_test_features = X_test['processed_content'].values\n",
    "\n",
    "\n",
    "class MyCountVectorizer:\n",
    "    def __init__(self, max_features=None):\n",
    "        self.max_features = max_features\n",
    "        self.vocabulary_ = None\n",
    "\n",
    "    def fit(self, documents):\n",
    "        word_counts = {}\n",
    "        for doc in documents:\n",
    "            words = doc.split() \n",
    "            for word in words:\n",
    "                if word in word_counts:\n",
    "                    word_counts[word] += 1\n",
    "                else:\n",
    "                    word_counts[word] = 1\n",
    "        \n",
    "        sorted_word_counts = sorted(word_counts.items(), key=lambda x: x[1], reverse=True)\n",
    "        most_common_words = sorted_word_counts[:self.max_features]\n",
    "        self.vocabulary_ = {word: idx for idx, (word, _) in enumerate(most_common_words)}\n",
    "        return self\n",
    "\n",
    "    def transform(self, documents):\n",
    "        vectors = []\n",
    "        for doc in documents:\n",
    "            words = doc.split()  \n",
    "            vector = np.zeros(len(self.vocabulary_), dtype=int)\n",
    "            for word in words:\n",
    "                if word in self.vocabulary_:\n",
    "                    vector[self.vocabulary_[word]] += 1\n",
    "            vectors.append(vector)\n",
    "        return np.array(vectors)\n",
    "\n",
    "    def fit_transform(self, documents):\n",
    "        self.fit(documents)\n",
    "        return self.transform(documents)\n",
    "\n",
    "custom_vectorizer = MyCountVectorizer(max_features=1000)\n",
    "X_train_vectors = custom_vectorizer.fit_transform(X_train_features)\n",
    "X_validation_vectors = custom_vectorizer.transform(X_validation_features)\n",
    "X_test_vectors = custom_vectorizer.transform(X_test_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <h4> 5) Implementation of MultiClass Logistic Regression Class from Scratch </h4>\n",
    "\n",
    "- **Softmax:** Applies softmax for multi-class probability distribution.\n",
    "- **Fit:** Trains model using gradient descent with one-hot encoding for labels.\n",
    "- **Predict:** Outputs class labels based on the highest softmax probability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiClassLogisticRegression:\n",
    "    def __init__(self, learning_rate, epochs, num_classes=None):\n",
    "        self.learning_rate = learning_rate\n",
    "        self.epochs = epochs\n",
    "        self.num_classes = num_classes\n",
    "        self.weights = None\n",
    "        self.bias = None\n",
    "\n",
    "    @staticmethod\n",
    "    def softmax(z):\n",
    "        exp_z = np.exp(z - np.max(z, axis=1, keepdims=True)) \n",
    "        return exp_z / np.sum(exp_z, axis=1, keepdims=True)\n",
    "\n",
    "    def fit(self, X, y):\n",
    "        n_samples, n_features = X.shape\n",
    "        if self.num_classes is None:\n",
    "            self.num_classes = len(np.unique(y))\n",
    "\n",
    "        self.weights = np.zeros((n_features, self.num_classes))\n",
    "        self.bias = np.zeros(self.num_classes)\n",
    "\n",
    "        y_one_hot = np.zeros((n_samples, self.num_classes))\n",
    "        y_one_hot[np.arange(n_samples), y] = 1\n",
    "\n",
    "        for i in range(self.epochs):\n",
    "            linear_model = np.dot(X, self.weights) + self.bias\n",
    "            predictions = self.softmax(linear_model)\n",
    "\n",
    "            dw = (1 / n_samples) * np.dot(X.T, (predictions - y_one_hot))\n",
    "            db = (1 / n_samples) * np.sum(predictions - y_one_hot, axis=0)\n",
    "\n",
    "            self.weights -= self.learning_rate * dw\n",
    "            self.bias -= self.learning_rate * db\n",
    "\n",
    "    def predict(self, X):\n",
    "        linear_model = np.dot(X, self.weights) + self.bias\n",
    "        predictions = self.softmax(linear_model)\n",
    "        return np.argmax(predictions, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 6) Evaluation Metrics </h4>\n",
    "\n",
    "Below we have defined a function that will assess the performance using the following evaluation metrics:\n",
    "- Accuracy\n",
    "- Class-wise Precision\n",
    "- Class-wise Recall\n",
    "- Macro F1 Score\n",
    "- Confusion Matrix\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "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_true, y_pred, target_names):\n",
    "    accuracy = accuracy_score(y_true, y_pred)\n",
    "    print(f\"Accuracy: {accuracy * 100:.2f}%\\n\")\n",
    "    print(\"Classification Report:\")\n",
    "    print(classification_report(y_true, y_pred, target_names=target_names))\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "    make_heat_map(cm, \"Confusion Matrix\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 7) Training the model </h4>\n",
    "\n",
    "Here we train our model, MultiClassLogisticRegression on the training dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = MultiClassLogisticRegression(learning_rate=0.01, epochs=10000)\n",
    "model.fit(X_train_vectors, y_train_encoded)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 8) Testing on the Validation Dataset </h4>\n",
    "\n",
    "Here, we test our model on the validation dataset and assess its performance using the evaluate metrics:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 96.73%\n",
      "\n",
      "Classification Report:\n",
      "                    precision    recall  f1-score   support\n",
      "\n",
      "          business       0.98      0.96      0.97        46\n",
      "     entertainment       0.97      0.97      0.97        61\n",
      "science-technology       1.00      0.92      0.96        37\n",
      "            sports       0.98      1.00      0.99        60\n",
      "             world       0.93      0.97      0.95        71\n",
      "\n",
      "          accuracy                           0.97       275\n",
      "         macro avg       0.97      0.96      0.97       275\n",
      "      weighted avg       0.97      0.97      0.97       275\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_predicted_validation = model.predict(X_validation_vectors)\n",
    "evaluate(y_validation_encoded, y_predicted_validation, label_encoder.classes_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 9) 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": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 95.27%\n",
      "\n",
      "Classification Report:\n",
      "                    precision    recall  f1-score   support\n",
      "\n",
      "          business       0.98      0.97      0.97       117\n",
      "     entertainment       0.98      0.94      0.96       131\n",
      "science-technology       0.91      0.95      0.93        64\n",
      "            sports       0.98      0.98      0.98       121\n",
      "             world       0.89      0.93      0.91       117\n",
      "\n",
      "          accuracy                           0.95       550\n",
      "         macro avg       0.95      0.95      0.95       550\n",
      "      weighted avg       0.95      0.95      0.95       550\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_predicted_test = model.predict(X_test_vectors)\n",
    "evaluate(y_test_encoded, y_predicted_test, label_encoder.classes_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> 10) Implementing the Logistic Regression 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": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/envs/ML_env/lib/python3.12/site-packages/sklearn/linear_model/_logistic.py:1247: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. From then on, it will always use 'multinomial'. Leave it to its default value to avoid this warning.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sklearn Logistic Regression Accuracy for validation data set: 96.73%\n",
      "Manual Logistic Regression Accuracy for validation data set: 96.73% \n",
      "\n",
      "Sklearn Logistic Regression Accuracy for test data set: 94.55%\n",
      "Manual Logistic Regression Accuracy for test data set: 95.27%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "sklearn_log_reg = LogisticRegression(multi_class='multinomial', solver='lbfgs', max_iter=1000, random_state=42)\n",
    "sklearn_log_reg.fit(X_train_vectors, y_train_encoded)\n",
    "\n",
    "y_validation_predicted_sklearn_log_reg = sklearn_log_reg.predict(X_validation_vectors)\n",
    "y_test_predicted_sklearn_log_reg = sklearn_log_reg.predict(X_test_vectors)\n",
    "\n",
    "sklearn_accuracy_validation_log_reg = accuracy_score(y_validation_encoded, y_validation_predicted_sklearn_log_reg)\n",
    "sklearn_accuracy_test_log_reg = accuracy_score(y_test_encoded, y_test_predicted_sklearn_log_reg)\n",
    "\n",
    "manual_accuracy_validation_log_reg = accuracy_score(y_validation_encoded, y_predicted_validation)\n",
    "manual_accuracy_test_log_reg = accuracy_score(y_test_encoded, y_predicted_test)\n",
    "\n",
    "print(f\"Sklearn Logistic Regression Accuracy for validation data set: {sklearn_accuracy_validation_log_reg * 100:.2f}%\")\n",
    "print(f\"Manual Logistic Regression Accuracy for validation data set: {manual_accuracy_validation_log_reg * 100:.2f}% \\n\")\n",
    "print(f\"Sklearn Logistic Regression Accuracy for test data set: {sklearn_accuracy_test_log_reg * 100:.2f}%\")\n",
    "print(f\"Manual Logistic Regression Accuracy for test data set: {manual_accuracy_test_log_reg * 100:.2f}%\")"
   ]
  }
 ],
 "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}