classifiers3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: torch in ./venv/lib/python3.11/site-packages (2.0.1)\n",
      "Requirement already satisfied: accelerate in ./venv/lib/python3.11/site-packages (0.22.0)\n",
      "Requirement already satisfied: imblearn in ./venv/lib/python3.11/site-packages (0.0)\n",
      "Requirement already satisfied: transformers in ./venv/lib/python3.11/site-packages (4.33.1)\n",
      "Requirement already satisfied: nltk in ./venv/lib/python3.11/site-packages (3.8.1)\n",
      "Requirement already satisfied: pandas in ./venv/lib/python3.11/site-packages (2.1.0)\n",
      "Requirement already satisfied: numpy in ./venv/lib/python3.11/site-packages (1.25.2)\n",
      "Requirement already satisfied: matplotlib in ./venv/lib/python3.11/site-packages (3.7.2)\n",
      "Requirement already satisfied: seaborn in ./venv/lib/python3.11/site-packages (0.12.2)\n",
      "Requirement already satisfied: wordcloud in ./venv/lib/python3.11/site-packages (1.9.2)\n",
      "Requirement already satisfied: xgboost in ./venv/lib/python3.11/site-packages (1.7.6)\n",
      "Collecting fasttext\n",
      "  Downloading fasttext-0.9.2.tar.gz (68 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m68.8/68.8 kB\u001b[0m \u001b[31m1.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
      "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25hRequirement already satisfied: filelock in ./venv/lib/python3.11/site-packages (from torch) (3.12.3)\n",
      "Requirement already satisfied: typing-extensions in ./venv/lib/python3.11/site-packages (from torch) (4.7.1)\n",
      "Requirement already satisfied: sympy in ./venv/lib/python3.11/site-packages (from torch) (1.12)\n",
      "Requirement already satisfied: networkx in ./venv/lib/python3.11/site-packages (from torch) (3.1)\n",
      "Requirement already satisfied: jinja2 in ./venv/lib/python3.11/site-packages (from torch) (3.1.2)\n",
      "Requirement already satisfied: packaging>=20.0 in ./venv/lib/python3.11/site-packages (from accelerate) (23.1)\n",
      "Requirement already satisfied: psutil in ./venv/lib/python3.11/site-packages (from accelerate) (5.9.5)\n",
      "Requirement already satisfied: pyyaml in ./venv/lib/python3.11/site-packages (from accelerate) (6.0.1)\n",
      "Requirement already satisfied: imbalanced-learn in ./venv/lib/python3.11/site-packages (from imblearn) (0.11.0)\n",
      "Requirement already satisfied: huggingface-hub<1.0,>=0.15.1 in ./venv/lib/python3.11/site-packages (from transformers) (0.17.1)\n",
      "Requirement already satisfied: regex!=2019.12.17 in ./venv/lib/python3.11/site-packages (from transformers) (2023.8.8)\n",
      "Requirement already satisfied: requests in ./venv/lib/python3.11/site-packages (from transformers) (2.31.0)\n",
      "Requirement already satisfied: tokenizers!=0.11.3,<0.14,>=0.11.1 in ./venv/lib/python3.11/site-packages (from transformers) (0.13.3)\n",
      "Requirement already satisfied: safetensors>=0.3.1 in ./venv/lib/python3.11/site-packages (from transformers) (0.3.3)\n",
      "Requirement already satisfied: tqdm>=4.27 in ./venv/lib/python3.11/site-packages (from transformers) (4.66.1)\n",
      "Requirement already satisfied: click in ./venv/lib/python3.11/site-packages (from nltk) (8.1.7)\n",
      "Requirement already satisfied: joblib in ./venv/lib/python3.11/site-packages (from nltk) (1.3.2)\n",
      "Requirement already satisfied: python-dateutil>=2.8.2 in ./venv/lib/python3.11/site-packages (from pandas) (2.8.2)\n",
      "Requirement already satisfied: pytz>=2020.1 in ./venv/lib/python3.11/site-packages (from pandas) (2023.3.post1)\n",
      "Requirement already satisfied: tzdata>=2022.1 in ./venv/lib/python3.11/site-packages (from pandas) (2023.3)\n",
      "Requirement already satisfied: contourpy>=1.0.1 in ./venv/lib/python3.11/site-packages (from matplotlib) (1.1.0)\n",
      "Requirement already satisfied: cycler>=0.10 in ./venv/lib/python3.11/site-packages (from matplotlib) (0.11.0)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in ./venv/lib/python3.11/site-packages (from matplotlib) (4.42.1)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in ./venv/lib/python3.11/site-packages (from matplotlib) (1.4.5)\n",
      "Requirement already satisfied: pillow>=6.2.0 in ./venv/lib/python3.11/site-packages (from matplotlib) (10.0.0)\n",
      "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in ./venv/lib/python3.11/site-packages (from matplotlib) (3.0.9)\n",
      "Requirement already satisfied: scipy in ./venv/lib/python3.11/site-packages (from xgboost) (1.11.2)\n",
      "Collecting pybind11>=2.2 (from fasttext)\n",
      "  Using cached pybind11-2.11.1-py3-none-any.whl (227 kB)\n",
      "Requirement already satisfied: setuptools>=0.7.0 in ./venv/lib/python3.11/site-packages (from fasttext) (68.0.0)\n",
      "Requirement already satisfied: fsspec in ./venv/lib/python3.11/site-packages (from huggingface-hub<1.0,>=0.15.1->transformers) (2023.9.0)\n",
      "Requirement already satisfied: six>=1.5 in ./venv/lib/python3.11/site-packages (from python-dateutil>=2.8.2->pandas) (1.16.0)\n",
      "Requirement already satisfied: scikit-learn>=1.0.2 in ./venv/lib/python3.11/site-packages (from imbalanced-learn->imblearn) (1.3.0)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in ./venv/lib/python3.11/site-packages (from imbalanced-learn->imblearn) (3.2.0)\n",
      "Requirement already satisfied: MarkupSafe>=2.0 in ./venv/lib/python3.11/site-packages (from jinja2->torch) (2.1.3)\n",
      "Requirement already satisfied: charset-normalizer<4,>=2 in ./venv/lib/python3.11/site-packages (from requests->transformers) (3.2.0)\n",
      "Requirement already satisfied: idna<4,>=2.5 in ./venv/lib/python3.11/site-packages (from requests->transformers) (3.4)\n",
      "Requirement already satisfied: urllib3<3,>=1.21.1 in ./venv/lib/python3.11/site-packages (from requests->transformers) (2.0.4)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in ./venv/lib/python3.11/site-packages (from requests->transformers) (2023.7.22)\n",
      "Requirement already satisfied: mpmath>=0.19 in ./venv/lib/python3.11/site-packages (from sympy->torch) (1.3.0)\n",
      "Building wheels for collected packages: fasttext\n",
      "  Building wheel for fasttext (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25h  Created wheel for fasttext: filename=fasttext-0.9.2-cp311-cp311-macosx_13_0_x86_64.whl size=356798 sha256=930e57d485ec7b365bee9f2d7cbfc87378dbd0634c7b45369c6d79d2a97d2575\n",
      "  Stored in directory: /Users/bushraabdullahi/Library/Caches/pip/wheels/12/89/c9/c932d04c4dd65abe347bbb3e6f7668688753cbc585305ad8b7\n",
      "Successfully built fasttext\n",
      "Installing collected packages: pybind11, fasttext\n",
      "Successfully installed fasttext-0.9.2 pybind11-2.11.1\n",
      "\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.1.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "! pip install torch accelerate imblearn transformers nltk pandas numpy matplotlib seaborn wordcloud xgboost fasttext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Unnamed: 0    0\n",
       "title         0\n",
       "text          0\n",
       "label         0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "csv_file_path = \"preprocessed_dataframes/preprocessed_data_3.csv\"\n",
    "\n",
    "preprocessed_df = pd.read_csv(csv_file_path)\n",
    "\n",
    "preprocessed_df[\"text\"].fillna(\"\", inplace=True)\n",
    "preprocessed_df.isnull().sum()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9570368255780759\n",
      "Precision: 0.9502103786816269\n",
      "Recall: 0.9648248362289946\n",
      "F1-score: 0.9574618428490672\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Split the data into train and test sets\n",
    "train_df, test_df = train_test_split(preprocessed_df, test_size=0.2, random_state=42)\n",
    "\n",
    "# Initialize the TF-IDF vectorizer\n",
    "vectorizer = TfidfVectorizer()\n",
    "\n",
    "# Fit the vectorizer on the training text\n",
    "vectorizer.fit(train_df[\"text\"])\n",
    "\n",
    "# Transform the training and test text into TF-IDF feature vectors\n",
    "train_tfidf = vectorizer.transform(train_df[\"text\"])\n",
    "test_tfidf = vectorizer.transform(test_df[\"text\"])\n",
    "\n",
    "# Get the corresponding labels\n",
    "train_labels = train_df[\"label\"]\n",
    "test_labels = test_df[\"label\"]\n",
    "\n",
    "# Train a logistic regression classifier\n",
    "classifier = LogisticRegression()\n",
    "classifier.fit(train_tfidf, train_labels)\n",
    "\n",
    "# Predict on the test set\n",
    "predictions = classifier.predict(test_tfidf)\n",
    "\n",
    "# Calculate the evaluation metrics\n",
    "accuracy = accuracy_score(test_labels, predictions)\n",
    "precision = precision_score(test_labels, predictions)\n",
    "recall = recall_score(test_labels, predictions)\n",
    "f1 = f1_score(test_labels, predictions)\n",
    "\n",
    "# Calculate the confusion matrix\n",
    "conf_matrix = confusion_matrix(test_labels, predictions)\n",
    "\n",
    "print(f\"Accuracy: {accuracy}\")\n",
    "print(f\"Precision: {precision}\")\n",
    "print(f\"Recall: {recall}\")\n",
    "print(f\"F1-score: {f1}\")\n",
    "\n",
    "# Create a heatmap of the confusion matrix\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(conf_matrix, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False)\n",
    "plt.xlabel(\"Predicted\")\n",
    "plt.ylabel(\"Actual\")\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8703968027405081\n",
      "Precision: 0.8909582457194353\n",
      "Recall: 0.8447735687838223\n",
      "F1-score: 0.867251461988304\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Split the data into train and test sets\n",
    "train_df, test_df = train_test_split(preprocessed_df, test_size=0.2, random_state=42)\n",
    "\n",
    "# Initialize the TF-IDF vectorizer\n",
    "vectorizer = TfidfVectorizer()\n",
    "\n",
    "# Fit the vectorizer on the training text\n",
    "vectorizer.fit(train_df[\"text\"])\n",
    "\n",
    "# Transform the training and test text into TF-IDF feature vectors\n",
    "train_tfidf = vectorizer.transform(train_df[\"text\"])\n",
    "test_tfidf = vectorizer.transform(test_df[\"text\"])\n",
    "\n",
    "# Get the corresponding labels\n",
    "train_labels = train_df[\"label\"]\n",
    "test_labels = test_df[\"label\"]\n",
    "\n",
    "# Train a Multinomial Naive Bayes classifier\n",
    "classifier = MultinomialNB()\n",
    "classifier.fit(train_tfidf, train_labels)\n",
    "\n",
    "# Predict on the test set\n",
    "predictions = classifier.predict(test_tfidf)\n",
    "\n",
    "# Calculate the evaluation metrics\n",
    "accuracy = accuracy_score(test_labels, predictions)\n",
    "precision = precision_score(test_labels, predictions)\n",
    "recall = recall_score(test_labels, predictions)\n",
    "f1 = f1_score(test_labels, predictions)\n",
    "\n",
    "# Calculate the confusion matrix\n",
    "conf_matrix = confusion_matrix(test_labels, predictions)\n",
    "\n",
    "print(f\"Accuracy: {accuracy}\")\n",
    "print(f\"Precision: {precision}\")\n",
    "print(f\"Recall: {recall}\")\n",
    "print(f\"F1-score: {f1}\")\n",
    "\n",
    "# Create a heatmap of the confusion matrix\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(conf_matrix, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False)\n",
    "plt.xlabel(\"Predicted\")\n",
    "plt.ylabel(\"Actual\")\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.svm import SVC\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Split the data into train and test sets\n",
    "train_df, test_df = train_test_split(preprocessed_df, test_size=0.2, random_state=42)\n",
    "\n",
    "# Initialize the TF-IDF vectorizer\n",
    "vectorizer = TfidfVectorizer()\n",
    "\n",
    "# Fit the vectorizer on the training text\n",
    "vectorizer.fit(train_df[\"text\"])\n",
    "\n",
    "# Transform the training and test text into TF-IDF feature vectors\n",
    "train_tfidf = vectorizer.transform(train_df[\"text\"])\n",
    "test_tfidf = vectorizer.transform(test_df[\"text\"])\n",
    "\n",
    "# Get the corresponding labels\n",
    "train_labels = train_df[\"label\"]\n",
    "test_labels = test_df[\"label\"]\n",
    "\n",
    "# Train a Support Vector Machine (SVM) classifier\n",
    "classifier = SVC(kernel='linear')  \n",
    "classifier.fit(train_tfidf, train_labels)\n",
    "\n",
    "# Predict on the test set\n",
    "predictions = classifier.predict(test_tfidf)\n",
    "\n",
    "# Calculate the evaluation metrics\n",
    "accuracy = accuracy_score(test_labels, predictions)\n",
    "precision = precision_score(test_labels, predictions)\n",
    "recall = recall_score(test_labels, predictions)\n",
    "f1 = f1_score(test_labels, predictions)\n",
    "\n",
    "# Calculate the confusion matrix\n",
    "conf_matrix = confusion_matrix(test_labels, predictions)\n",
    "\n",
    "print(f\"Accuracy: {accuracy}\")\n",
    "print(f\"Precision: {precision}\")\n",
    "print(f\"Recall: {recall}\")\n",
    "print(f\"F1-score: {f1}\")\n",
    "\n",
    "# Create a heatmap of the confusion matrix\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(conf_matrix, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False)\n",
    "plt.xlabel(\"Predicted\")\n",
    "plt.ylabel(\"Actual\")\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9384099343419926\n",
      "Precision: 0.9374911208978548\n",
      "Recall: 0.9397607519225292\n",
      "F1-score: 0.9386245643979803\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Split the data into train and test sets\n",
    "train_df, test_df = train_test_split(preprocessed_df, test_size=0.2, random_state=42)\n",
    "\n",
    "# Initialize the TF-IDF vectorizer\n",
    "vectorizer = TfidfVectorizer()\n",
    "\n",
    "# Fit the vectorizer on the training text\n",
    "vectorizer.fit(train_df[\"text\"])\n",
    "\n",
    "# Transform the training and test text into TF-IDF feature vectors\n",
    "train_tfidf = vectorizer.transform(train_df[\"text\"])\n",
    "test_tfidf = vectorizer.transform(test_df[\"text\"])\n",
    "\n",
    "# Get the corresponding labels\n",
    "train_labels = train_df[\"label\"]\n",
    "test_labels = test_df[\"label\"]\n",
    "\n",
    "# Train a Random Forest classifier\n",
    "classifier = RandomForestClassifier()\n",
    "classifier.fit(train_tfidf, train_labels)\n",
    "\n",
    "# Predict on the test set\n",
    "predictions = classifier.predict(test_tfidf)\n",
    "\n",
    "# Calculate the evaluation metrics\n",
    "accuracy = accuracy_score(test_labels, predictions)\n",
    "precision = precision_score(test_labels, predictions)\n",
    "recall = recall_score(test_labels, predictions)\n",
    "f1 = f1_score(test_labels, predictions)\n",
    "\n",
    "# Calculate the confusion matrix\n",
    "conf_matrix = confusion_matrix(test_labels, predictions)\n",
    "\n",
    "print(f\"Accuracy: {accuracy}\")\n",
    "print(f\"Precision: {precision}\")\n",
    "print(f\"Recall: {recall}\")\n",
    "print(f\"F1-score: {f1}\")\n",
    "\n",
    "# Create a heatmap of the confusion matrix\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(conf_matrix, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False)\n",
    "plt.xlabel(\"Predicted\")\n",
    "plt.ylabel(\"Actual\")\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/bushraabdullahi/Library/CloudStorage/OneDrive-Personal/Uni/L6/Final Project/FP-final/venv/lib/python3.11/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9729517556380245\n",
      "Precision: 0.9672246448164299\n",
      "Recall: 0.9792082027912276\n",
      "F1-score: 0.9731795343570872\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "import xgboost as xgb\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Split the data into train and test sets\n",
    "train_df, test_df = train_test_split(preprocessed_df, test_size=0.2, random_state=42)\n",
    "\n",
    "# Initialize the TF-IDF vectorizer\n",
    "vectorizer = TfidfVectorizer()\n",
    "\n",
    "# Fit the vectorizer on the training text\n",
    "vectorizer.fit(train_df[\"text\"])\n",
    "\n",
    "# Transform the training and test text into TF-IDF feature vectors\n",
    "train_tfidf = vectorizer.transform(train_df[\"text\"])\n",
    "test_tfidf = vectorizer.transform(test_df[\"text\"])\n",
    "\n",
    "# Get the corresponding labels\n",
    "train_labels = train_df[\"label\"]\n",
    "test_labels = test_df[\"label\"]\n",
    "\n",
    "# Train an XGBoost classifier\n",
    "classifier = xgb.XGBClassifier()  # Initialize XGBoost classifier\n",
    "classifier.fit(train_tfidf, train_labels)\n",
    "\n",
    "# Predict on the test set\n",
    "predictions = classifier.predict(test_tfidf)\n",
    "\n",
    "# Calculate the evaluation metrics\n",
    "accuracy = accuracy_score(test_labels, predictions)\n",
    "precision = precision_score(test_labels, predictions)\n",
    "recall = recall_score(test_labels, predictions)\n",
    "f1 = f1_score(test_labels, predictions)\n",
    "\n",
    "# Calculate the confusion matrix\n",
    "conf_matrix = confusion_matrix(test_labels, predictions)\n",
    "\n",
    "print(f\"Accuracy: {accuracy}\")\n",
    "print(f\"Precision: {precision}\")\n",
    "print(f\"Recall: {recall}\")\n",
    "print(f\"F1-score: {f1}\")\n",
    "\n",
    "# Create a heatmap of the confusion matrix\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(conf_matrix, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False)\n",
    "plt.xlabel(\"Predicted\")\n",
    "plt.ylabel(\"Actual\")\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.9 ('venv': venv)",
   "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.2"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "18a029f34de569bc87a5b20bf3524e89bed39c69b1af6c862570a3b15f046199"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}