notebooks/model_SGD.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d21dc15f-e474-4b63-8337-21cae7b84e51",
   "metadata": {},
   "source": [
    "# 1. Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# add root path to system path\n",
    "import sys\n",
    "import os\n",
    "\n",
    "sys.path.append('../')\n",
    "\n",
    "os.chdir(\"../\")"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "f0e5f6160fdbe676"
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2a164ea1-c512-422e-b840-e383ae8e0852",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "from utility.utils import export_submission, WordEmbeddingVectorizer, load_preprocessed_data, \\\n",
    "    load_preprocessed_full_data, load_preprocessed_test_data\n",
    "from utility.paths import DataPath\n",
    "\n",
    "import gensim"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7f559a6-228f-4063-a7b7-a504d350f7f8",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 2. Data loading"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef0f06d-439a-4477-9ddb-ca3bcaaeb713",
   "metadata": {},
   "source": [
    "First, we will load the pre-processed datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "10d344d4-94fa-4e15-9297-9c73d20b1d94",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the data\n",
    "data_train = load_preprocessed_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "722d51ed-0294-42b1-9417-30d6a9f58d1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of total tweets: 181290\n",
      "Percentage of positive tweets: 49.77%\n",
      "Percentage of negative tweets: 50.23%\n"
     ]
    }
   ],
   "source": [
    "# Calculate the number of positive and negative tweets\n",
    "num_positive = len(data_train[data_train[\"label\"] == 1])\n",
    "num_negative = len(data_train[data_train[\"label\"] == -1])\n",
    "total_tweets = data_train.shape[0]\n",
    "\n",
    "# Calculate the percentages\n",
    "perc_positive = num_positive / total_tweets * 100\n",
    "perc_negative = num_negative / total_tweets * 100\n",
    "\n",
    "# Print the information\n",
    "print(\"Number of total tweets:\", total_tweets)\n",
    "print(\"Percentage of positive tweets: {:.2f}%\".format(perc_positive))\n",
    "print(\"Percentage of negative tweets: {:.2f}%\".format(perc_negative))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fba80a18-7fbc-44fc-b86c-f8b47c22f34a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the data into training and testing sets\n",
    "X_train, X_validation, y_train, y_validation = train_test_split(data_train[\"text\"], data_train['label'], test_size=0.2,\n",
    "                                                                random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00f31caf-e6b0-4d02-bfc9-5812dc2c7452",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 3. Text Vectorizer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73a3b502-3f03-4803-8a30-4034f380947b",
   "metadata": {},
   "source": [
    "Now, we will conduct a grid search to identify the optimal text vectorizer for **SGD**, from the followings :\n",
    "\n",
    "- `Count Vectorizer`\n",
    "- `TF-IDF Vectorizer`\n",
    "- `Word2Vec`\n",
    "\n",
    "This will include determining their best hyperparameters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f58b02fc-cb79-4a60-b07b-4289d1219a0e",
   "metadata": {},
   "source": [
    "Note : Testing grid search on the full dataset, which comprises 2.5 million entries, is highly time-consuming. This is because the duration required for a grid search scales exponentially with the number of values that are being tested. Consequently, to manage this challenge effectively, we conducted the grid search on a smaller sample of the dataset, containing 200,000 entries. This approach ensures efficiency in processing time while retaining the integrity and representativeness of the data, thereby not resulting in significant information loss."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0880803-0a15-4b66-b00a-8e1d12235d57",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Count Vectorizer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7721f7de-5f13-405a-a0d6-ff933ecceb4e",
   "metadata": {},
   "source": [
    "The Count Vectorizer is a text analysis method that converts a collection of text documents into a matrix of token counts. This technique involves counting the number of times each word appears in a document, resulting in a sparse matrix where rows correspond to documents and columns correspond to tokens (usually words) in the entire dataset. It's a simple yet effective way to represent text data for machine learning algorithms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "14d287eb-3c66-4682-97e8-b341ce6980d1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count Vectorizer - Best parameters: {'vect__ngram_range': (1, 3)}\n",
      "Count Vectorizer - Best score: 0.8135859756439612\n"
     ]
    }
   ],
   "source": [
    "# Define pipeline for Count Vectorizer\n",
    "pipeline_count = Pipeline([\n",
    "    ('vect', CountVectorizer()),\n",
    "    ('clf', SGDClassifier())\n",
    "])\n",
    "\n",
    "# Parameter grid for Count Vectorizer pipeline\n",
    "parameter_grid_count = {\n",
    "    'vect__ngram_range': [(1, 1), (1, 2), (1, 3)],\n",
    "}\n",
    "\n",
    "# Grid search for Count Vectorizer pipeline\n",
    "grid_search_count = GridSearchCV(pipeline_count, parameter_grid_count, cv=5)\n",
    "\n",
    "# Fit the grid search to the data\n",
    "grid_search_count.fit(X_train, y_train)\n",
    "\n",
    "# After fitting, we can access the best parameters, best score, etc.\n",
    "print(\"Count Vectorizer - Best parameters:\", grid_search_count.best_params_)\n",
    "print(\"Count Vectorizer - Best score:\", grid_search_count.best_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7a14adb-df2f-4a73-942b-e41aa473e124",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### TF-IDF Vectorizer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6aac4ab-c39c-4098-92a0-2a2c2101cc91",
   "metadata": {},
   "source": [
    "The TF-IDF Vectorizer (Term Frequency-Inverse Document Frequency) is a more advanced technique compared to the Count Vectorizer. It reflects how important a word is to a document in a collection or corpus. The TF-IDF value increases proportionally with the number of times a word appears in the document but is offset by the frequency of the word in the corpus, which helps control for the fact that some words are generally more common than others. This method is particularly useful for feature extraction in text analysis, enabling better handling of common words and highlighting the unique aspects of each document."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "816306ec-d4e8-4a22-bd83-77e8633bcd57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TF-IDF - Best parameters: {'vect__ngram_range': (1, 1)}\n",
      "TF-IDF - Best score: 0.7833305793955809\n"
     ]
    }
   ],
   "source": [
    "# Define pipeline for TF-IDF\n",
    "pipeline_tfidf = Pipeline([\n",
    "    ('vect', TfidfVectorizer()),\n",
    "    ('clf', SGDClassifier())\n",
    "])\n",
    "\n",
    "# Parameter grid for TF-IDF pipeline\n",
    "parameter_grid_tfidf = {\n",
    "    'vect__ngram_range': [(1, 1), (1, 2), (1, 3)],\n",
    "}\n",
    "\n",
    "# Grid search for TF-IDF pipeline\n",
    "grid_search_tfidf = GridSearchCV(pipeline_tfidf, parameter_grid_tfidf, cv=5)\n",
    "\n",
    "# Fit the grid search to the data\n",
    "grid_search_tfidf.fit(X_train, y_train)\n",
    "\n",
    "# After fitting, you can access the best parameters, best score, etc.\n",
    "print(\"TF-IDF - Best parameters:\", grid_search_tfidf.best_params_)\n",
    "print(\"TF-IDF - Best score:\", grid_search_tfidf.best_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3efae94c-b835-438d-9c2a-ad0b0a3cdfcc",
   "metadata": {},
   "source": [
    "#### Word2Vec"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6338ff34-ac62-4603-a95f-a1b5168b2e5b",
   "metadata": {},
   "source": [
    "Word2Vec is a popular method developed by Google. It uses either a Continuous Bag of Words (CBOW) or Skip-Gram model to transform words into dense vectors in a high-dimensional space. The key concept behind Word2Vec is that words with similar meanings tend to appear in similar contexts, so the algorithm captures semantic relationships between words based on their co-occurrence in text corpora.\n",
    "\n",
    "We used Google's pre-trained Word2Vec model, which has been trained on a large Google News dataset and contains word vectors for 3 million words and phrases. The pre-trained model can be downloaded here : https://www.kaggle.com/datasets/adarshsng/googlenewsvectors/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6796bf75-c2d4-4606-b632-256a6ba69f55",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load Google's pre-trained Word2Vec model.\n",
    "model_path = 'data/GoogleNews-vectors-negative300.bin'\n",
    "word_vectors = gensim.models.KeyedVectors.load_word2vec_format(model_path, binary=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "66e04609-48c4-404f-951c-28d3002e51c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6271167742291356\n"
     ]
    }
   ],
   "source": [
    "# Create an instance of the WordEmbeddingVectorizer with our Word2Vec model\n",
    "word_vectorizer = WordEmbeddingVectorizer(word_vectors)\n",
    "\n",
    "# Create a pipeline\n",
    "pipeline = Pipeline([\n",
    "    ('word2vec', word_vectorizer),\n",
    "    ('classifier', SGDClassifier())\n",
    "])\n",
    "\n",
    "# Train the model\n",
    "pipeline.fit(X_train, y_train)\n",
    "\n",
    "# Calculate and print the accuracy\n",
    "accuracy = pipeline.score(X_validation, y_validation)\n",
    "print(\"Accuracy:\", accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff3bafdd-2f49-4663-bba7-454283eb96c4",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 4. Optimization of the SGD model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee552d20-1cd0-4ac5-9a17-ae6916672b86",
   "metadata": {},
   "source": [
    "We notice that the vectorizer that yields the best accuracy is `CountVectorizer` with the parameters `ngram_range=(1, 3)`. Now let's use it to find the best SGD hyperparameters with a grid search."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "330a6c8c-2244-4fa8-be0e-38d2354deebd",
   "metadata": {},
   "source": [
    "### Definition of the model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2d9c8b1-4b28-4c9a-a020-40a735cc980e",
   "metadata": {},
   "source": [
    "First, let's vectorize the data with the best vectorizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b2fb8b88-274b-409c-9591-9384d29faab4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# CountVectorizer\n",
    "best_vectorizer = CountVectorizer(ngram_range=(1, 3))\n",
    "X_train_vectorized = best_vectorizer.fit_transform(X_train)\n",
    "X_validation_vectorized = best_vectorizer.transform(X_validation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ae2fea3-63a9-4980-94eb-503413de4a08",
   "metadata": {},
   "source": [
    "Now let's train the SGD model with the vectorized data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "859c8e68-df99-45b0-b412-84490e5233fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training time: 2.01 sec\n"
     ]
    }
   ],
   "source": [
    "# Instanciate an SGD classifier\n",
    "clf = SGDClassifier()\n",
    "start_time = time.time()\n",
    "clf.fit(X_train_vectorized, y_train)\n",
    "end_time = time.time()\n",
    "elapsed_time = end_time - start_time\n",
    "\n",
    "# Get decision scores instead of binary predictions\n",
    "y_train_scores = clf.decision_function(X_train_vectorized)\n",
    "y_validation_scores = clf.decision_function(X_validation_vectorized)\n",
    "print(f\"Training time: {elapsed_time:.2f} sec\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ca9c596-6516-4106-b48d-88fe234a44fe",
   "metadata": {},
   "source": [
    "### Grid search for optimal decision boundary threshold"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b366c81-7b44-4124-a38a-54d353f501d5",
   "metadata": {},
   "source": [
    "Now let's find the best decision boundary threshold for the positive and negative labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5b76dd42-f19f-4025-af48-f2ae9476ac9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Define the thresholds to test\n",
    "thresholds = np.arange(-5, 5.01, 0.01)\n",
    "\n",
    "# Initialize empty lists to store accuracy and F1 scores\n",
    "train_accuracies = []\n",
    "validation_accuracies = []\n",
    "\n",
    "# Loop through each threshold\n",
    "for threshold in thresholds:\n",
    "    y_train_pred = np.where(y_train_scores >= threshold, 1, -1)\n",
    "    y_validation_pred = np.where(y_validation_scores >= threshold, 1, -1)\n",
    "\n",
    "    train_accuracy = accuracy_score(y_train, y_train_pred)\n",
    "    validation_accuracy = accuracy_score(y_validation, y_validation_pred)\n",
    "\n",
    "    train_accuracies.append(train_accuracy * 100)\n",
    "    validation_accuracies.append(validation_accuracy * 100)\n",
    "\n",
    "# Create a line plot for training set\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(thresholds, train_accuracies, label='Trainning set Accuracy')\n",
    "\n",
    "# Create a line plot for validation set\n",
    "plt.plot(thresholds, validation_accuracies, label='Validation set Accuracy')\n",
    "\n",
    "plt.xlabel('Threshold')\n",
    "plt.ylabel('Percentage')\n",
    "plt.title('Performance Metrics vs. Threshold')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "83f4ef3a-2167-4f13-b783-5b757ae8be6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The threshold for maximum validation accuracy 81.68% is: 0.12\n"
     ]
    }
   ],
   "source": [
    "# Find the index of the max validation accuracy\n",
    "max_accuracy_index = np.argmax(validation_accuracies)\n",
    "\n",
    "# Get the corresponding threshold\n",
    "optimal_threshold = thresholds[max_accuracy_index]\n",
    "\n",
    "print(\n",
    "    f\"The threshold for maximum validation accuracy {validation_accuracies[max_accuracy_index]:.2f}% is: {optimal_threshold:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5ee2347-c3be-427e-b65b-6d0019e337a0",
   "metadata": {},
   "source": [
    "Let's recall that the decision function returns an unbounded confidence score rather than a probability. Since the best threshold that we found is 0.06 (\t$\\approx$ 0.0), this is statistically coherent with the fact that the training data are balanced 50.2% negative and 49.8% positive. Therefore, we can keep the regular decision boundary of the SGD model which is 0."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91503512-1422-4869-b234-0c945a3f8941",
   "metadata": {},
   "source": [
    "### Grid search for optimal regularization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f15cfcd0-b8a1-4459-8a0d-b790f1bcfcfa",
   "metadata": {},
   "source": [
    "Now, let's implement some regularization methods to check if our model is overfitting the data. We will again conduct a grid search, focusing on the following parameters :\n",
    "\n",
    "- `loss function`\n",
    "- `penalty`\n",
    "- `alpha`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "855c5fb8-14d3-4e19-bfb9-c179d1f16aef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;}#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>GridSearchCV(cv=5, estimator=SGDClassifier(), n_jobs=-1,\n",
       "             param_grid={&#x27;alpha&#x27;: [0.001, 0.01, 0.1],\n",
       "                         &#x27;loss&#x27;: [&#x27;hinge&#x27;, &#x27;log_loss&#x27;, &#x27;modified_huber&#x27;],\n",
       "                         &#x27;penalty&#x27;: [&#x27;l2&#x27;, &#x27;l1&#x27;]},\n",
       "             scoring=&#x27;accuracy&#x27;)</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 sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GridSearchCV</label><div class=\"sk-toggleable__content\"><pre>GridSearchCV(cv=5, estimator=SGDClassifier(), n_jobs=-1,\n",
       "             param_grid={&#x27;alpha&#x27;: [0.001, 0.01, 0.1],\n",
       "                         &#x27;loss&#x27;: [&#x27;hinge&#x27;, &#x27;log_loss&#x27;, &#x27;modified_huber&#x27;],\n",
       "                         &#x27;penalty&#x27;: [&#x27;l2&#x27;, &#x27;l1&#x27;]},\n",
       "             scoring=&#x27;accuracy&#x27;)</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: SGDClassifier</label><div class=\"sk-toggleable__content\"><pre>SGDClassifier()</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">SGDClassifier</label><div class=\"sk-toggleable__content\"><pre>SGDClassifier()</pre></div></div></div></div></div></div></div></div></div></div>"
      ],
      "text/plain": [
       "GridSearchCV(cv=5, estimator=SGDClassifier(), n_jobs=-1,\n",
       "             param_grid={'alpha': [0.001, 0.01, 0.1],\n",
       "                         'loss': ['hinge', 'log_loss', 'modified_huber'],\n",
       "                         'penalty': ['l2', 'l1']},\n",
       "             scoring='accuracy')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param_grid = {\n",
    "    'loss': ['hinge', 'log_loss', 'modified_huber'],\n",
    "    'penalty': ['l2', 'l1'],\n",
    "    'alpha': [0.001, 0.01, 0.1]\n",
    "}\n",
    "\n",
    "# Set up GridSearchCV\n",
    "grid_search = GridSearchCV(estimator=clf, param_grid=param_grid, n_jobs=-1, cv=5, scoring='accuracy')\n",
    "\n",
    "# Perform grid search\n",
    "grid_search.fit(X_train_vectorized, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "99a168fa-31aa-4e49-a61c-6fa3a5e490a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best parameters: {'alpha': 0.001, 'loss': 'modified_huber', 'penalty': 'l2'}\n",
      "Best accuracy: 81.04%\n"
     ]
    }
   ],
   "source": [
    "# Get the best parameters\n",
    "best_parameters = grid_search.best_params_\n",
    "best_score = grid_search.best_score_\n",
    "\n",
    "print(\"Best parameters:\", best_parameters)\n",
    "print(f\"Best accuracy: {best_score * 100:.2f}%\")\n",
    "\n",
    "# Predictions with the best model\n",
    "y_pred = grid_search.predict(X_validation_vectorized)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3edb32eb-61bc-40d1-a849-fe5d0cdfe98f",
   "metadata": {},
   "source": [
    "We observe that the best regularization results in a lower accuracy. From this, we can conclude that our model is not overfitting the data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "679bc8ee-ecfc-4868-b18c-6f6eb9b2ff17",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 5. Submission using the Full Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f991f95b-48f9-4b75-8012-035ed473bc44",
   "metadata": {},
   "source": [
    "Now, let's proceed to test our optimal vectorizer and model on the full dataset (2.5M entries), and then make a submission on AIcrowd."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c24717ae-1a3a-4165-af44-fcf55cca6cd8",
   "metadata": {},
   "source": [
    "First, we load the full training dataset and the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "11253963-a178-45e6-8021-20329947620f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the full data\n",
    "full_data_train = load_preprocessed_full_data()\n",
    "full_data_test = load_preprocessed_test_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "213084a1-5ea9-4039-97cb-f9e87e259dbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prepare the data feature and target\n",
    "X_train_full = full_data_train[\"text\"]\n",
    "y_train_full = full_data_train[\"label\"]\n",
    "X_test = full_data_test[\"text\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3c2b1db-e469-4dcb-b17e-e7739153ffdf",
   "metadata": {},
   "source": [
    "Then we setup the optimal vectorizer with the optimal model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0a7d8ace-e29b-455a-8a7d-2471eab5800e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the optimal vectorizer: CountVectorizer with ngram_range=(1, 3)\n",
    "full_vectorizer = CountVectorizer(ngram_range=(1, 3))\n",
    "X_train_full_vectorized = full_vectorizer.fit_transform(X_train_full)\n",
    "X_test_vectorized = full_vectorizer.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9249f46d-e85f-4f20-b418-ba55f44b9403",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-2 {color: black;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 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-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 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-2 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-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 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-2 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-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 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-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 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-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 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-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>SGDClassifier()</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-4\" type=\"checkbox\" checked><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">SGDClassifier</label><div class=\"sk-toggleable__content\"><pre>SGDClassifier()</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "SGDClassifier()"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the SGD model without any regularization\n",
    "clf_submission = SGDClassifier()\n",
    "clf.fit(X_train_full_vectorized, y_train_full)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff634d3f-2783-437b-ac17-9c1992bff2b4",
   "metadata": {},
   "source": [
    "Finally, we can make the prediciton and make a submission."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "baea216d-c26b-436c-a527-5f226d181fb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make the prediction\n",
    "y_test_pred = clf.predict(X_test_vectorized)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "706f85ff-ced9-4860-b1f6-46e1a7982870",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Export the prediction\n",
    "export_submission(y_test_pred, f\"{DataPath.ML_SUBMISSION}/test_predictions_SGD.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc320338-b9f1-48c6-b424-10a346a143c0",
   "metadata": {},
   "source": [
    "This submission to AIcrowd achieved the following accuracy scores:\n",
    "    \n",
    "- First Score =`0.836`\n",
    "- Secondary Score = `0.841`\n",
    "\n",
    "You can access the results here:\n",
    "\n",
    "- csv output file : [test_predictions_SGD.csv](../submissions/ml/test_predictions_SGD.csv)\n",
    "- AIcrowd submission id : **[#246982](https://www.aicrowd.com/challenges/epfl-ml-text-classification/submissions/246982)**\n",
    "\n",
    "This appears quite promising. Let's now experiment with a different model : [Logistic Regression](model_logistic_regression.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7ef34df-62c0-4d9c-8f03-a25b0ad4cf02",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:ada]",
   "language": "python",
   "name": "conda-env-ada-py"
  },
  "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}