code.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import re\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, roc_auc_score, roc_curve\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.svm import SVC\n",
    "from xgboost import XGBClassifier\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "import nltk\n",
    "import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Error loading stopwords: <urlopen error [SSL:\n",
      "[nltk_data]     CERTIFICATE_VERIFY_FAILED] certificate verify failed:\n",
      "[nltk_data]     unable to get local issuer certificate (_ssl.c:1000)>\n",
      "[nltk_data] Error loading wordnet: <urlopen error [SSL:\n",
      "[nltk_data]     CERTIFICATE_VERIFY_FAILED] certificate verify failed:\n",
      "[nltk_data]     unable to get local issuer certificate (_ssl.c:1000)>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('stopwords')\n",
    "nltk.download('wordnet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "true_df = pd.read_csv('True.csv')\n",
    "false_df = pd.read_csv('Fake.csv')\n",
    "\n",
    "true_df['True']=1\n",
    "false_df['True']=0\n",
    "\n",
    "combined_df = pd.concat([true_df, false_df], ignore_index=True)\n",
    "\n",
    "combined_df = combined_df.sample(frac=1).reset_index(drop=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "stop_words = set(stopwords.words('english'))\n",
    "lemmatizer = WordNetLemmatizer()\n",
    "\n",
    "def preprocess_text(text):\n",
    "    text = re.sub(r'\\d+', '', text)  # Remove numbers\n",
    "    text = re.sub(r'[^\\w\\s]', '', text)  # Remove punctuation\n",
    "    text = text.lower()  # Convert to lowercase\n",
    "    text = ' '.join([lemmatizer.lemmatize(word) for word in text.split() if word not in stop_words])\n",
    "    return text\n",
    "\n",
    "# Apply text cleaning\n",
    "combined_df['cleaned_text'] = combined_df['text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf = TfidfVectorizer(max_features=5000)\n",
    "X_tfidf = tfidf.fit_transform(combined_df['cleaned_text'])\n",
    "\n",
    "# Encode 'subject' column\n",
    "le = LabelEncoder()\n",
    "subject_encoded = le.fit_transform(combined_df['subject'])\n",
    "subject_encoded = subject_encoded.reshape(-1, 1)\n",
    "\n",
    "# Combine TF-IDF features with 'subject' feature\n",
    "X = np.hstack((X_tfidf.toarray(), subject_encoded))\n",
    "\n",
    "# Target variable\n",
    "y = combined_df['True']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Standardize features (important for SVM)\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "X_train_subset, _, y_train_subset, _ = train_test_split(X_train, y_train, train_size=0.5, random_state=42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "models = {\n",
    "    \"Logistic Regression\": LogisticRegression(),\n",
    "    \"XGBoost\": XGBClassifier(use_label_encoder=False, eval_metric='logloss'),\n",
    "    \"Random Forest\": RandomForestClassifier(),\n",
    "    \"SVM\": SVC(probability=True),\n",
    "    \n",
    "}\n",
    "#logistic regression: \n",
    "# Define parameter grids for Grid Search\n",
    "param_grids = {\n",
    "    \"Logistic Regression\": {\n",
    "        'C': [0.1, 1, 10],\n",
    "        'penalty': ['l1', 'l2'],\n",
    "        'solver': ['liblinear']\n",
    "    },\n",
    "    \"XGBoost\": {\n",
    "        'n_estimators': [100, 200, 300],\n",
    "        'max_depth': [3, 5, 7],\n",
    "        'learning_rate': [0.01, 0.1, 0.2]\n",
    "    },\n",
    "    \"Random Forest\": {\n",
    "        'n_estimators': [100, 200, 300],\n",
    "        'max_depth': [10, 20, 30],\n",
    "        'min_samples_split': [2, 5]\n",
    "    },\n",
    "    \"SVM\": {\n",
    "        'C': [0.1, 1, 10],\n",
    "        'kernel': ['linear', 'rbf']\n",
    "    },\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "models = {\n",
    "    \"XGBoost\": XGBClassifier(use_label_encoder=False, eval_metric='logloss'),\n",
    "    \"Random Forest\": RandomForestClassifier(),\n",
    "    \"SVM\": SVC(probability=True),\n",
    "    \n",
    "}\n",
    "\n",
    "# Define parameter grids for Grid Search\n",
    "param_grids = {\n",
    "    \"XGBoost\": {\n",
    "        'n_estimators': [100, 200, 300],\n",
    "        'max_depth': [3, 5, 7],\n",
    "        'learning_rate': [0.01, 0.1, 0.2]\n",
    "    },\n",
    "    \"Random Forest\": {\n",
    "        'n_estimators': [100, 200, 300],\n",
    "        'max_depth': [10, 20, 30],\n",
    "        'min_samples_split': [2, 5]\n",
    "    },\n",
    "    \"SVM\": {\n",
    "        'C': [0.1, 1, 10],\n",
    "        'kernel': ['linear', 'rbf']\n",
    "    },\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.999109\n",
      "\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00      4728\n",
      "           1       1.00      1.00      1.00      4252\n",
      "\n",
      "    accuracy                           1.00      8980\n",
      "   macro avg       1.00      1.00      1.00      8980\n",
      "weighted avg       1.00      1.00      1.00      8980\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAIjCAYAAAAk+FJEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAs1klEQVR4nO3deZhWdf3/8deAMOybC6AiiCumgaKZmSC5ryC5VwJlLpn7kvr9logLieKCGy6oZGqaC7mVqaioaZKKmplf9yUVwYV9UWZ+f/hjagIUcHA+6uNxXVxXc87nPud95uqanp059z0V1dXV1QEAgAI1qO8BAABgUcQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqwEK88MIL2XbbbdO6detUVFRkzJgxdXr8V199NRUVFbnqqqvq9LhfZltuuWW23HLL+h4DKIxYBYr10ksv5cADD0zXrl3TpEmTtGrVKptvvnnOO++8zJo1a5mee8CAAXnmmWdy2mmn5eqrr87GG2+8TM/3RRo4cGAqKirSqlWrhX4fX3jhhVRUVKSioiJnnXXWEh//rbfeyuDBgzNhwoQ6mBb4uluuvgcAWJg77rgje+yxRyorK7Pffvtl/fXXz9y5c/PQQw/l2GOPzbPPPptLL710mZx71qxZeeSRR/I///M/+fnPf75MztG5c+fMmjUrjRo1WibH/yzLLbdcZs6cmdtuuy177rlnrX3XXHNNmjRpktmzZy/Vsd96662cfPLJ6dKlS3r06LHYr/vzn/+8VOcDvtrEKlCcV155JXvvvXc6d+6csWPHpmPHjjX7DjnkkLz44ou54447ltn5J02alCRp06bNMjtHRUVFmjRpssyO/1kqKyuz+eab57rrrlsgVq+99trstNNOuemmm76QWWbOnJlmzZqlcePGX8j5gC8XjwEAxRk2bFimT5+eUaNG1QrV+dZcc80cfvjhNV9//PHHOeWUU7LGGmuksrIyXbp0yYknnpg5c+bUel2XLl2y884756GHHsq3vvWtNGnSJF27ds1vfvObmjWDBw9O586dkyTHHntsKioq0qVLlySf/Pp8/n/+T4MHD05FRUWtbXfffXe++93vpk2bNmnRokXWWWednHjiiTX7F/XM6tixY7PFFlukefPmadOmTfr27Zvnnntuoed78cUXM3DgwLRp0yatW7fOoEGDMnPmzEV/Y//Lvvvumz/+8Y/58MMPa7aNHz8+L7zwQvbdd98F1r///vs55phjssEGG6RFixZp1apVdthhhzz11FM1a+6///5ssskmSZJBgwbVPE4w/zq33HLLrL/++nn88cfTq1evNGvWrOb78t/PrA4YMCBNmjRZ4Pq32267tG3bNm+99dZiXyvw5SVWgeLcdttt6dq1a77zne8s1vr9998/v/rVr7LRRhvlnHPOSe/evTN06NDsvffeC6x98cUXs/vuu2ebbbbJ8OHD07Zt2wwcODDPPvtskqR///4555xzkiT77LNPrr766px77rlLNP+zzz6bnXfeOXPmzMmQIUMyfPjw7Lrrrnn44Yc/9XX33HNPtttuu7z77rsZPHhwjjrqqPzlL3/J5ptvnldffXWB9XvuuWemTZuWoUOHZs8998xVV12Vk08+ebHn7N+/fyoqKnLzzTfXbLv22muz7rrrZqONNlpg/csvv5wxY8Zk5513ztlnn51jjz02zzzzTHr37l0Tjt26dcuQIUOSJAcccECuvvrqXH311enVq1fNcd57773ssMMO6dGjR84999z06dNnofOdd955WXHFFTNgwIDMmzcvSXLJJZfkz3/+c84///ysvPLKi32twJdYNUBBpkyZUp2kum/fvou1fsKECdVJqvfff/9a24855pjqJNVjx46t2da5c+fqJNXjxo2r2fbuu+9WV1ZWVh999NE121555ZXqJNVnnnlmrWMOGDCgunPnzgvMcNJJJ1X/54/Tc845pzpJ9aRJkxY59/xzXHnllTXbevToUb3SSitVv/feezXbnnrqqeoGDRpU77fffguc78c//nGtY+62227Vyy+//CLP+Z/X0bx58+rq6urq3XffvXqrrbaqrq6urp43b151hw4dqk8++eSFfg9mz55dPW/evAWuo7KysnrIkCE128aPH7/Atc3Xu3fv6iTVI0eOXOi+3r1719p21113VSepPvXUU6tffvnl6hYtWlT369fvM68R+OpwZxUoytSpU5MkLVu2XKz1d955Z5LkqKOOqrX96KOPTpIFnm1db731ssUWW9R8veKKK2adddbJyy+/vNQz/7f5z7r+4Q9/SFVV1WK95u23386ECRMycODAtGvXrmb7N7/5zWyzzTY11/mfDjrooFpfb7HFFnnvvfdqvoeLY999983999+fd955J2PHjs0777yz0EcAkk+ec23Q4JP/2Zg3b17ee++9mkccnnjiicU+Z2VlZQYNGrRYa7fddtsceOCBGTJkSPr3758mTZrkkksuWexzAV9+YhUoSqtWrZIk06ZNW6z1r732Who0aJA111yz1vYOHTqkTZs2ee2112ptX2211RY4Rtu2bfPBBx8s5cQL2muvvbL55ptn//33T/v27bP33nvnhhtu+NRwnT/nOuuss8C+bt26ZfLkyZkxY0at7f99LW3btk2SJbqWHXfcMS1btsz111+fa665JptssskC38v5qqqqcs4552SttdZKZWVlVlhhhay44op5+umnM2XKlMU+5yqrrLJEb6Y666yz0q5du0yYMCEjRozISiuttNivBb78xCpQlFatWmXllVfO3//+9yV63X+/wWlRGjZsuNDt1dXVS32O+c9Tzte0adOMGzcu99xzT370ox/l6aefzl577ZVtttlmgbWfx+e5lvkqKyvTv3//jB49Orfccssi76omyemnn56jjjoqvXr1ym9/+9vcddddufvuu/ONb3xjse8gJ598f5bEk08+mXfffTdJ8swzzyzRa4EvP7EKFGfnnXfOSy+9lEceeeQz13bu3DlVVVV54YUXam2fOHFiPvzww5p39teFtm3b1nrn/Hz/ffc2SRo0aJCtttoqZ599dv7xj3/ktNNOy9ixY3Pfffct9Njz53z++ecX2PfPf/4zK6ywQpo3b/75LmAR9t133zz55JOZNm3aQt+UNt+NN96YPn36ZNSoUdl7772z7bbbZuutt17ge7K4/8dhccyYMSODBg3KeuutlwMOOCDDhg3L+PHj6+z4QPnEKlCc4447Ls2bN8/++++fiRMnLrD/pZdeynnnnZfkk19jJ1ngHftnn312kmSnnXaqs7nWWGONTJkyJU8//XTNtrfffju33HJLrXXvv//+Aq+d/+H4//1xWvN17NgxPXr0yOjRo2vF39///vf8+c9/rrnOZaFPnz455ZRTcsEFF6RDhw6LXNewYcMF7tr+/ve/z7/+9a9a2+ZH9cLCfkn94he/yOuvv57Ro0fn7LPPTpcuXTJgwIBFfh+Brx5/FAAozhprrJFrr702e+21V7p161brL1j95S9/ye9///sMHDgwSdK9e/cMGDAgl156aT788MP07t07jz32WEaPHp1+/fot8mORlsbee++dX/ziF9ltt91y2GGHZebMmbn44ouz9tpr13qD0ZAhQzJu3LjstNNO6dy5c959991cdNFFWXXVVfPd7353kcc/88wzs8MOO2SzzTbLT37yk8yaNSvnn39+WrduncGDB9fZdfy3Bg0a5H//938/c93OO++cIUOGZNCgQfnOd76TZ555Jtdcc026du1aa90aa6yRNm3aZOTIkWnZsmWaN2+eTTfdNKuvvvoSzTV27NhcdNFFOemkk2o+SuvKK6/MlltumV/+8pcZNmzYEh0P+HJyZxUo0q677pqnn346u+++e/7whz/kkEMOyfHHH59XX301w4cPz4gRI2rWXn755Tn55JMzfvz4HHHEERk7dmxOOOGE/O53v6vTmZZffvnccsstadasWY477riMHj06Q4cOzS677LLA7KuttlquuOKKHHLIIbnwwgvTq1evjB07Nq1bt17k8bfeeuv86U9/yvLLL59f/epXOeuss/Ltb387Dz/88BKH3rJw4okn5uijj85dd92Vww8/PE888UTuuOOOdOrUqda6Ro0aZfTo0WnYsGEOOuig7LPPPnnggQeW6FzTpk3Lj3/842y44Yb5n//5n5rtW2yxRQ4//PAMHz48jz76aJ1cF1C2iuoleRIfAAC+QO6sAgBQLLEKAECxxCoAAMUSqwAAFEusAgBQLLEKAECxxCoAAMX6Sv4Fq6Yb/ry+RwCoUx+Mv6C+RwCoU00Ws0LdWQUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFjL1fcAUIpjBm2TUw7rmwuuuS/HnnVTVuvYLs/fOWSha39w7KjcfM+T2WDtVXLMoG3ynR5rZPk2zfPaW+/n8hsfyoXX3V+ztu/3uuene2yRb66zSiobLZfnXn4np468M/c88twXdGUAn23ixIk59+wz8/CDD2b27FnptFrnDDn19Hxj/Q3qezS+5sQqJOm53mr5yfc3z9P/92bNtjcnfpAuW59Qa92Pv795jtxv69z18LNJkg27dcqk96dl0P+OzpvvfJBvd++aC/93n8yrqsrI68clSb670ZoZ++g/c9L5t+bD6bOy367fzk3nHZhePzorTz3/ZgDq29QpUzLwh/tk429tmgtHXpa27drm9ddeS6tWret7NBCr0Lxp41x5+sD87JTrcvz+29dsr6qqzsT3ptVau2uf7rnp7icyY9bcJMlv/vBorf2v/uu9bPrN1dP3e91rYvXYs26qteakC27Lzlt+Mzv2Xl+sAkW4YtRlad+hQ045bWjNtlVX7VSPE8G/1eszq5MnT86wYcOy2267ZbPNNstmm22W3XbbLWeeeWYmTZpUn6PxNXLuCXvlTw/+Pff99flPXbdht07psW6njB7zyKeua92iST6YOnOR+ysqKtKyWWU+mLLoNQBfpAfuG5tvfGP9HHPkYdlyi82y5/f75abf31DfY0GSeozV8ePHZ+21186IESPSunXr9OrVK7169Urr1q0zYsSIrLvuuvnb3/72mceZM2dOpk6dWutfddW8L+AK+CrYY7ue6bFup/zy/Fs/c+2AfpvluZffzqNPvbLINd/uvnp237ZnRt308CLXHLnfVmnerDI3/fmJpZoZoK69+eYbueH667Ja5y65+NJR2XOvfXLG0FNz65hb6ns0qL/HAA499NDsscceGTlyZCoqKmrtq66uzkEHHZRDDz00jzzy6Xexhg4dmpNPPrnWtobtN0mjjt+q85n5alm1fZuceez3s/PBF2TO3I8/dW2TykbZa4eN8+vL/rTINeut0TE3nHNATrv0ztz76D8Xumav7TfOiQfukD2OvDSTPpj+ueYHqCtVVdX5xvrr57AjjkqSdOu2Xl588YX8/obfZdd+u9XzdHzd1dud1aeeeipHHnnkAqGafPJr0iOPPDITJkz4zOOccMIJmTJlSq1/y7XvuQwm5qtmw26rpf3yrfLItb/ItPHnZdr489Jr47Xys316Z9r489Kgwb//u7nb1j3SrEnjXHP7Yws91rpdO+TOSw7NFTf9JWdcftdC1+yxXc9c9Kt988PjrvjMRw4Avkgrrrhiuq6xRq1tXbt2zdtvv1VPE8G/1dud1Q4dOuSxxx7Luuuuu9D9jz32WNq3b/+Zx6msrExlZWWtbRUNGtbJjHy13ffY8+m5+2m1tl168g/z/CsTM/yqu1NVVV2zfWC/7+SOB57J5IXcDe3WtUP+eOlhuea2v2bwhbct9Fx7bt8zI0/6QfY74cr86aFn6/ZCAD6nHhtulFdfqf2I02uvvpqVV16lniaCf6u3WD3mmGNywAEH5PHHH89WW21VE6YTJ07Mvffem8suuyxnnXVWfY3H18D0mXPyj5ferrVtxqy5eX/KjFrbu3ZaId/daI30O/TiBY6x3hod88dLD8s9f3kuI347Nu2Xb5kkmVdVXRO2e22/cS4b8qMcc+aNGf/MqzVrZs35KFOnz15Wlwew2H6434AM+OE+ufzSkdl2ux3y92eezo033pBfDV74Z03DF6neYvWQQw7JCiuskHPOOScXXXRR5s375E1RDRs2TM+ePXPVVVdlzz33rK/xoMaAvpvlXxM/zD2PLPgc6m5bb5iV2rXMvjt/K/vu/O/npF97672su9NJST75bNZGjRrmvBP3ynkn7lWz5upbH80BJ/122V8AwGdYf4Nv5uzzLsiIc8/OJRdfmFVWXTXH/eLE7LTzrvU9GqSiurq6+rOXLVsfffRRJk+enCRZYYUV0qhRo891vKYb/rwuxgIoxgfjL6jvEQDqVJPFvGVaxB8FaNSoUTp27FjfYwAAUJh6/aMAAADwacQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFWm5xFt16662LfcBdd911qYcBAID/tFix2q9fv8U6WEVFRebNm/d55gEAgBqLFatVVVXLeg4AAFiAZ1YBACjWYt1Z/W8zZszIAw88kNdffz1z586tte+www6rk8EAAGCJY/XJJ5/MjjvumJkzZ2bGjBlp165dJk+enGbNmmWllVYSqwAA1JklfgzgyCOPzC677JIPPvggTZs2zaOPPprXXnstPXv2zFlnnbUsZgQA4GtqiWN1woQJOfroo9OgQYM0bNgwc+bMSadOnTJs2LCceOKJy2JGAAC+ppY4Vhs1apQGDT552UorrZTXX389SdK6deu88cYbdTsdAABfa0v8zOqGG26Y8ePHZ6211krv3r3zq1/9KpMnT87VV1+d9ddff1nMCADA19QS31k9/fTT07FjxyTJaaedlrZt2+bggw/OpEmTcumll9b5gAAAfH1VVFdXV9f3EHWt6YY/r+8RAOrUB+MvqO8RAOpUk8X8/b4/CgAAQLGW+JnV1VdfPRUVFYvc//LLL3+ugQAAYL4ljtUjjjii1tcfffRRnnzyyfzpT3/KscceW1dzAQDAksfq4YcfvtDtF154Yf72t7997oEAAGC+OntmdYcddshNN91UV4cDAIC6i9Ubb7wx7dq1q6vDAQDA0v1RgP98g1V1dXXeeeedTJo0KRdddFGdDgcAwNfbEn/O6uDBg2vFaoMGDbLiiitmyy23zLrrrlvnAy6N2R/X9wQAdatt3xH1PQJAnZp1x2GLtW6J76wOHjx4SV8CAABLZYmfWW3YsGHefffdBba/9957adiwYZ0MBQAAyVLE6qKeGpgzZ04aN278uQcCAID5FvsxgBEjPnleqqKiIpdffnlatGhRs2/evHkZN25cMc+sAgDw1bDYsXrOOeck+eTO6siRI2v9yr9x48bp0qVLRo4cWfcTAgDwtbXYsfrKK68kSfr06ZObb745bdu2XWZDAQBAshSfBnDfffctizkAAGABS/wGq+9///s544wzFtg+bNiw7LHHHnUyFAAAJEsRq+PGjcuOO+64wPYddtgh48aNq5OhAAAgWYpYnT59+kI/oqpRo0aZOnVqnQwFAADJUsTqBhtskOuvv36B7b/73e+y3nrr1clQAACQLMUbrH75y1+mf//+eemll/K9730vSXLvvffm2muvzY033ljnAwIA8PW1xLG6yy67ZMyYMTn99NNz4403pmnTpunevXvGjh2bdu3aLYsZAQD4mqqoXtTfT11MU6dOzXXXXZdRo0bl8ccfz7x58+pqtqU2++P6ngCgbrXtO6K+RwCoU7PuOGyx1i3xM6vzjRs3LgMGDMjKK6+c4cOH53vf+14effTRpT0cAAAsYIkeA3jnnXdy1VVXZdSoUZk6dWr23HPPzJkzJ2PGjPHmKgAA6txi31ndZZddss466+Tpp5/Oueeem7feeivnn3/+spwNAICvucW+s/rHP/4xhx12WA4++OCstdZay3ImAABIsgR3Vh966KFMmzYtPXv2zKabbpoLLrggkydPXpazAQDwNbfYsfrtb387l112Wd5+++0ceOCB+d3vfpeVV145VVVVufvuuzNt2rRlOScAAF9Dn+ujq55//vmMGjUqV199dT788MNss802ufXWW+tyvqXio6uArxofXQV81Szzj65KknXWWSfDhg3Lm2++meuuu+7zHAoAABbwuf8oQIncWQW+atxZBb5qvpA7qwAAsCyJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAirVcfQ8AXzajLrsk997957zyysupbNIkPXpsmCOOOiZdVu9a36MB1HLMHj1zysDNc8GYJ3PsZQ+mbYvK/PKH385WG66WTiu2zOQps3Lboy/l5KsfzdSZc2teN+uOwxY41n5n/DG/H/dCzddbbLBKzth/i6zXefm8OWlafn39+Pz2nue+kOvi60WswhL62/jHstc+P8g3Ntgg8z6el/PPOzsH/fQnufnWO9KsWbP6Hg8gSdJzrZXyk+3Xz9MvT6rZ1nH55unYrnlOGPVQnnv9/ay2Usuc//M+6diuRfYdemet1//0nLtz9+Ov1Xz94fQ5Nf+5c/tWuWXwrrn8zmcy6Ky70qd7p1x82FZ55/0ZueeJ15f9xfG1IlZhCV186ahaXw857dfps8Vmee4fz6bnxpvU01QA/9a8SaNceex2+dn5Y3P8Xv/+ufSP197PPqf/O0pfeWdKBv/mkVxxzHZp2KAi86qqa/ZNmT4nEz+YudDj/3TH9fPqO1Nz/KiHkiTPv/FBvrPeyjm034ZilTrnmVX4nKZPm5YkadW6dT1PAvCJcw/eMn8a/2rum/DGZ65t1awyU2fOrRWq84/xxrU/zYNn75n9tlmv1r5N1+2Y+ybUjtK7n3gtm67b4fMPD/+l6Durb7zxRk466aRcccUVi1wzZ86czJkzp9a26oaVqaysXNbjQaqqqjLsjNPTY8ONstZaa9f3OADZo9da6bHmivnuEdd/5trlWzXJCftskiv+9Pda20+++pE88NSbmTnn42y90Wo572dbpkWTRrnotqeSJO3bNsvED2fVes27H85M6+aVadK4YWbPnVd3F8TXXtF3Vt9///2MHj36U9cMHTo0rVu3rvXvzDOGfkET8nV3+qkn56UXXsiws86p71EAsuoKLXLmAb0z6My7MuejTw/Glk0b55bBu+a519/Pqdf8tda+X/9ufB557u089fKkDL/x8Zx90+M58vsbLcvRYZHq9c7qrbfe+qn7X3755c88xgknnJCjjjqq1rbqhu6qsuydfuqQjHvg/lwx+rdp38GvvoD6t+GaK6V922Z5ZMQ+NduWa9gg311/lRy0S/e07ndhqqqq06Jpo9x6St9MmzU3e516Rz6eV/Wpxx3//MScuM+mabxcw8z9eF4mfjAz7ds0rbVmpTbNMmXGHHdVqXP1Gqv9+vVLRUVFqqurF7mmoqLiU49RWbngr/xnf1wn48FCVVdXZ+hpp2TsvXdn1FVXZ9VVO9X3SABJkvueeiM9f/bbWtsuPWKbPP/mBxl+499SVVWdlk0b57ZT+mbOR/Oy+5DbP/MObJJ8s+sKeX/a7Mz9+JO1f/3n29lu4y611my14Wr56z/fqbNrgfnq9TGAjh075uabb05VVdVC/z3xxBP1OR4s1OmnnJw7b781vx42PM2bNc/kSZMyedKkzJ49u75HA77mps/6KP947f1a/2bM/ijvT52Vf7z2flo2bZzbT+2XZk0a5aDz7k2rZo3Tvm2ztG/bLA0afHJzaMdvrZ6B234j63Vul64dW+enO26Q4/bcJBf//+dVk+SyO/+e1Tu0zmmDNs/aq7bNATttkO9vsVbOH/NkfV06X2H1eme1Z8+eefzxx9O3b9+F7v+su65QH264/rokyU8G/qjW9iGnDk3f3frXx0gAi6XHmivmW///Hfv/GDWg1r51Bl2Z19+dlo/mVeXAnb+ZYT/dIhUVyUtvT8kvLnswV9z17zdhvTZxanYbfGuG/bRXDunbI/+aPD0Hj7jXx1axTFRU12MNPvjgg5kxY0a23377he6fMWNG/va3v6V3795LdFyPAQBfNW37jqjvEQDq1ML+UtrC1Oud1S222OJT9zdv3nyJQxUAgK+Ooj+6CgCArzexCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUKyK6urq6voeAr6M5syZk6FDh+aEE05IZWVlfY8D8Ln5uUaJxCospalTp6Z169aZMmVKWrVqVd/jAHxufq5RIo8BAABQLLEKAECxxCoAAMUSq7CUKisrc9JJJ3kTAvCV4ecaJfIGKwAAiuXOKgAAxRKrAAAUS6wCAFAssQoAQLHEKiylCy+8MF26dEmTJk2y6aab5rHHHqvvkQCWyrhx47LLLrtk5ZVXTkVFRcaMGVPfI0ENsQpL4frrr89RRx2Vk046KU888US6d++e7bbbLu+++259jwawxGbMmJHu3bvnwgsvrO9RYAE+ugqWwqabbppNNtkkF1xwQZKkqqoqnTp1yqGHHprjjz++nqcDWHoVFRW55ZZb0q9fv/oeBZK4swpLbO7cuXn88cez9dZb12xr0KBBtt566zzyyCP1OBkAfPWIVVhCkydPzrx589K+ffta29u3b5933nmnnqYCgK8msQoAQLHEKiyhFVZYIQ0bNszEiRNrbZ84cWI6dOhQT1MBwFeTWIUl1Lhx4/Ts2TP33ntvzbaqqqrce++92WyzzepxMgD46lmuvgeAL6OjjjoqAwYMyMYbb5xvfetbOffcczNjxowMGjSovkcDWGLTp0/Piy++WPP1K6+8kgkTJqRdu3ZZbbXV6nEy8NFVsNQuuOCCnHnmmXnnnXfSo0ePjBgxIptuuml9jwWwxO6///706dNnge0DBgzIVVdd9cUPBP9BrAIAUCzPrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIUZuDAgenXr1/N11tuuWWOOOKIL3yO+++/PxUVFfnwww+/8HMDzCdWARbTwIEDU1FRkYqKijRu3DhrrrlmhgwZko8//niZnvfmm2/OKaecslhrBSbwVbNcfQ8A8GWy/fbb58orr8ycOXNy55135pBDDkmjRo1ywgkn1Fo3d+7cNG7cuE7O2a5duzo5DsCXkTurAEugsrIyHTp0SOfOnXPwwQdn6623zq233lrzq/vTTjstK6+8ctZZZ50kyRtvvJE999wzbdq0Sbt27dK3b9+8+uqrNcebN29ejjrqqLRp0ybLL798jjvuuFRXV9c6538/BjBnzpz84he/SKdOnVJZWZk111wzo0aNyquvvpo+ffokSdq2bZuKiooMHDgwSVJVVZWhQ4dm9dVXT9OmTdO9e/fceOONtc5z5513Zu21107Tpk3Tp0+fWnMC1BexCvA5NG3aNHPnzk2S3HvvvXn++edz99135/bbb89HH32U7bbbLi1btsyDDz6Yhx9+OC1atMj2229f85rhw4fnqquuyhVXXJGHHnoo77//fm655ZZPPed+++2X6667LiNGjMhzzz2XSy65JC1atEinTp1y0003JUmef/75vP322znvvPOSJEOHDs1vfvObjBw5Ms8++2yOPPLI/PCHP8wDDzyQ5JOo7t+/f3bZZZdMmDAh+++/f44//vhl9W0DWGweAwBYCtXV1bn33ntz11135dBDD82kSZPSvHnzXH755TW//v/tb3+bqqqqXH755amoqEiSXHnllWnTpk3uv//+bLvttjn33HNzwgknpH///kmSkSNH5q677lrkef/v//4vN9xwQ+6+++5svfXWSZKuXbvW7J//yMBKK62UNm3aJPnkTuzpp5+ee+65J5tttlnNax566KFccskl6d27dy6++OKsscYaGT58eJJknXXWyTPPPJMzzjijDr9rAEtOrAIsgdtvvz0tWrTIRx99lKqqquy7774ZPHhwDjnkkGywwQa1nlN96qmn8uKLL6Zly5a1jjF79uy89NJLmTJlSt5+++1suummNfuWW265bLzxxgs8CjDfhAkT0rBhw/Tu3XuxZ37xxRczc+bMbLPNNrW2z507NxtuuGGS5Lnnnqs1R5KasAWoT2IVYAn06dMnF198cRo3bpyVV145yy337x+jzZs3r7V2+vTp6dmzZ6655poFjrPiiisu1fmbNm26xK+ZPn16kuSOO+7IKqusUmtfZWXlUs0B8EURqwBLoHnz5llzzTUXa+1GG22U66+/PiuttFJatWq10DUdO3bMX//61/Tq1StJ8vHHH+fxxx/PRhtttND1G2ywQaqqqvLAAw/UPAbwn+bf2Z03b17NtvXWWy+VlZV5/fXXF3lHtlu3brn11ltrbXv00Uc/+yIBljFvsAJYRn7wgx9khRVWSN++ffPggw/mlVdeyf3335/DDjssb775ZpLk8MMPz69//euMGTMm//znP/Ozn/3sUz8jtUuXLhkwYEB+/OMfZ8yYMTXHvOGGG5IknTt3TkVFRW6//fZMmjQp06dPT8uWLXPMMcfkyCOPzOjRo/PSSy/liSeeyPnnn5/Ro0cnSQ466KC88MILOfbYY/P888/n2muvzVVXXbWsv0UAn0msAiwjzZo1y7hx47Laaqulf//+6datW37yk59k9uzZNXdajz766PzoRz/KgAEDstlmm6Vly5bZbbfdPvW4F198cXbffff87Gc/y7rrrpuf/vSnmTFjRpJklVVWycknn5zjjz8+7du3z89//vMkySmnnJJf/vKXGTp0aLp165btt98+d9xxR1ZfffUkyWqrrZabbropY8aMSffu3TNy5Micfvrpy/C7A7B4KqoX9RQ/AADUM3dWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGL9P1nVz/J5P3o4AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mo=RandomForestClassifier(max_depth=20, min_samples_split=2, n_estimators=200)\n",
    "mo.fit(X_train, y_train)\n",
    "y_pred = mo.predict(X_test)\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(f\"Accuracy: {accuracy:.6f}\")\n",
    "print(\"\\nClassification Report:\")\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "# Confusion Matrix\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(cm, annot=True, cmap='Blues', fmt='d', cbar=False)\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = LogisticRegression(C=10, penalty='l2', solver='liblinear')\n",
    "lr.fit(X_train, y_train)\n",
    "y_pred = lr.predict(X_test)\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(f\"Accuracy: {accuracy:.6f}\")\n",
    "print(\"\\nClassification Report:\")\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sv=SVC(C=10, kernel='rbf', probability=True)\n",
    "sv.fit(X_train, y_train)\n",
    "y_pred = sv.predict(X_test)\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(f\"Accuracy: {accuracy:.6f}\")\n",
    "print(\"\\nClassification Report:\")\n",
    "print(classification_report(y_test, y_pred))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(17959, 5001)\n",
      "(17959,)\n"
     ]
    }
   ],
   "source": [
    "#size of the data\n",
    "print(X_train_subset.shape)\n",
    "print(y_train_subset.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training Logistic Regression...\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "Logistic Regression model saved as 'Logistic Regression_best_model.pkl'\n",
      "Best Parameters: {'C': 1, 'penalty': 'l1', 'solver': 'liblinear'}\n",
      "cv:  [1. 1. 1. 1. 1.]\n",
      "Logistic Regression Cross-Validation Accuracy: 1.0\n",
      "predict\n",
      "Logistic Regression Accuracy: 0.9983296213808464\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00      4609\n",
      "           1       1.00      1.00      1.00      4371\n",
      "\n",
      "    accuracy                           1.00      8980\n",
      "   macro avg       1.00      1.00      1.00      8980\n",
      "weighted avg       1.00      1.00      1.00      8980\n",
      "\n",
      "Logistic Regression ROC-AUC: 0.9997822886289885\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training XGBoost...\n",
      "Fitting 5 folds for each of 27 candidates, totalling 135 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/joblib/externals/loky/process_executor.py:752: UserWarning: A worker stopped while some jobs were given to the executor. This can be caused by a too short worker timeout or by a memory leak.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[19], line 5\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124mTraining \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m...\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      4\u001b[0m grid_search \u001b[38;5;241m=\u001b[39m GridSearchCV(model, param_grids[name], cv\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m, scoring\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maccuracy\u001b[39m\u001b[38;5;124m'\u001b[39m, verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m,n_jobs\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m----> 5\u001b[0m \u001b[43mgrid_search\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train_subset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train_subset\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      6\u001b[0m best_model \u001b[38;5;241m=\u001b[39m grid_search\u001b[38;5;241m.\u001b[39mbest_estimator_\n\u001b[1;32m      7\u001b[0m best_models[name] \u001b[38;5;241m=\u001b[39m best_model\n",
      "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/base.py:1473\u001b[0m, in \u001b[0;36m_fit_context.<locals>.decorator.<locals>.wrapper\u001b[0;34m(estimator, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1466\u001b[0m     estimator\u001b[38;5;241m.\u001b[39m_validate_params()\n\u001b[1;32m   1468\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[1;32m   1469\u001b[0m     skip_parameter_validation\u001b[38;5;241m=\u001b[39m(\n\u001b[1;32m   1470\u001b[0m         prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[1;32m   1471\u001b[0m     )\n\u001b[1;32m   1472\u001b[0m ):\n\u001b[0;32m-> 1473\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfit_method\u001b[49m\u001b[43m(\u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/model_selection/_search.py:968\u001b[0m, in \u001b[0;36mBaseSearchCV.fit\u001b[0;34m(self, X, y, **params)\u001b[0m\n\u001b[1;32m    962\u001b[0m     results \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_format_results(\n\u001b[1;32m    963\u001b[0m         all_candidate_params, n_splits, all_out, all_more_results\n\u001b[1;32m    964\u001b[0m     )\n\u001b[1;32m    966\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m results\n\u001b[0;32m--> 968\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_run_search\u001b[49m\u001b[43m(\u001b[49m\u001b[43mevaluate_candidates\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    970\u001b[0m \u001b[38;5;66;03m# multimetric is determined here because in the case of a callable\u001b[39;00m\n\u001b[1;32m    971\u001b[0m \u001b[38;5;66;03m# self.scoring the return type is only known after calling\u001b[39;00m\n\u001b[1;32m    972\u001b[0m first_test_score \u001b[38;5;241m=\u001b[39m all_out[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtest_scores\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n",
      "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/model_selection/_search.py:1543\u001b[0m, in \u001b[0;36mGridSearchCV._run_search\u001b[0;34m(self, evaluate_candidates)\u001b[0m\n\u001b[1;32m   1541\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_run_search\u001b[39m(\u001b[38;5;28mself\u001b[39m, evaluate_candidates):\n\u001b[1;32m   1542\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Search all candidates in param_grid\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1543\u001b[0m     \u001b[43mevaluate_candidates\u001b[49m\u001b[43m(\u001b[49m\u001b[43mParameterGrid\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparam_grid\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/model_selection/_search.py:914\u001b[0m, in \u001b[0;36mBaseSearchCV.fit.<locals>.evaluate_candidates\u001b[0;34m(candidate_params, cv, more_results)\u001b[0m\n\u001b[1;32m    906\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m    907\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\n\u001b[1;32m    908\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFitting \u001b[39m\u001b[38;5;132;01m{0}\u001b[39;00m\u001b[38;5;124m folds for each of \u001b[39m\u001b[38;5;132;01m{1}\u001b[39;00m\u001b[38;5;124m candidates,\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    909\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m totalling \u001b[39m\u001b[38;5;132;01m{2}\u001b[39;00m\u001b[38;5;124m fits\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(\n\u001b[1;32m    910\u001b[0m             n_splits, n_candidates, n_candidates \u001b[38;5;241m*\u001b[39m n_splits\n\u001b[1;32m    911\u001b[0m         )\n\u001b[1;32m    912\u001b[0m     )\n\u001b[0;32m--> 914\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mparallel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    915\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdelayed\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_fit_and_score\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    916\u001b[0m \u001b[43m        \u001b[49m\u001b[43mclone\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbase_estimator\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    917\u001b[0m \u001b[43m        \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    918\u001b[0m \u001b[43m        \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    919\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtrain\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtrain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    920\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtest\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    921\u001b[0m \u001b[43m        \u001b[49m\u001b[43mparameters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparameters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    922\u001b[0m \u001b[43m        \u001b[49m\u001b[43msplit_progress\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43msplit_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_splits\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    923\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcandidate_progress\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcand_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_candidates\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    924\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mfit_and_score_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    925\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    926\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mcand_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparameters\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43msplit_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mproduct\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    927\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcandidate_params\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    928\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mrouted_params\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplitter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    929\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    930\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    932\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(out) \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m    933\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m    934\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo fits were performed. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    935\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWas the CV iterator empty? \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    936\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWere there no candidates?\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    937\u001b[0m     )\n",
      "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/utils/parallel.py:67\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m     62\u001b[0m config \u001b[38;5;241m=\u001b[39m get_config()\n\u001b[1;32m     63\u001b[0m iterable_with_config \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m     64\u001b[0m     (_with_config(delayed_func, config), args, kwargs)\n\u001b[1;32m     65\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m delayed_func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m iterable\n\u001b[1;32m     66\u001b[0m )\n\u001b[0;32m---> 67\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43miterable_with_config\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/joblib/parallel.py:2007\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   2001\u001b[0m \u001b[38;5;66;03m# The first item from the output is blank, but it makes the interpreter\u001b[39;00m\n\u001b[1;32m   2002\u001b[0m \u001b[38;5;66;03m# progress until it enters the Try/Except block of the generator and\u001b[39;00m\n\u001b[1;32m   2003\u001b[0m \u001b[38;5;66;03m# reaches the first `yield` statement. This starts the asynchronous\u001b[39;00m\n\u001b[1;32m   2004\u001b[0m \u001b[38;5;66;03m# dispatch of the tasks to the workers.\u001b[39;00m\n\u001b[1;32m   2005\u001b[0m \u001b[38;5;28mnext\u001b[39m(output)\n\u001b[0;32m-> 2007\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m output \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturn_generator \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/joblib/parallel.py:1650\u001b[0m, in \u001b[0;36mParallel._get_outputs\u001b[0;34m(self, iterator, pre_dispatch)\u001b[0m\n\u001b[1;32m   1647\u001b[0m     \u001b[38;5;28;01myield\u001b[39;00m\n\u001b[1;32m   1649\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backend\u001b[38;5;241m.\u001b[39mretrieval_context():\n\u001b[0;32m-> 1650\u001b[0m         \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_retrieve()\n\u001b[1;32m   1652\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mGeneratorExit\u001b[39;00m:\n\u001b[1;32m   1653\u001b[0m     \u001b[38;5;66;03m# The generator has been garbage collected before being fully\u001b[39;00m\n\u001b[1;32m   1654\u001b[0m     \u001b[38;5;66;03m# consumed. This aborts the remaining tasks if possible and warn\u001b[39;00m\n\u001b[1;32m   1655\u001b[0m     \u001b[38;5;66;03m# the user if necessary.\u001b[39;00m\n\u001b[1;32m   1656\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n",
      "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/joblib/parallel.py:1762\u001b[0m, in \u001b[0;36mParallel._retrieve\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1757\u001b[0m \u001b[38;5;66;03m# If the next job is not ready for retrieval yet, we just wait for\u001b[39;00m\n\u001b[1;32m   1758\u001b[0m \u001b[38;5;66;03m# async callbacks to progress.\u001b[39;00m\n\u001b[1;32m   1759\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ((\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jobs) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m\n\u001b[1;32m   1760\u001b[0m     (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jobs[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mget_status(\n\u001b[1;32m   1761\u001b[0m         timeout\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtimeout) \u001b[38;5;241m==\u001b[39m TASK_PENDING)):\n\u001b[0;32m-> 1762\u001b[0m     \u001b[43mtime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0.01\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1763\u001b[0m     \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m   1765\u001b[0m \u001b[38;5;66;03m# We need to be careful: the job list can be filling up as\u001b[39;00m\n\u001b[1;32m   1766\u001b[0m \u001b[38;5;66;03m# we empty it and Python list are not thread-safe by\u001b[39;00m\n\u001b[1;32m   1767\u001b[0m \u001b[38;5;66;03m# default hence the use of the lock\u001b[39;00m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "best_models = {}\n",
    "for name, model in models.items():\n",
    "    print(f\"\\nTraining {name}...\")\n",
    "    grid_search = GridSearchCV(model, param_grids[name], cv=5, scoring='accuracy', verbose=1,n_jobs=2)\n",
    "    grid_search.fit(X_train_subset, y_train_subset)\n",
    "    best_model = grid_search.best_estimator_\n",
    "    best_models[name] = best_model\n",
    "    joblib.dump(best_model, f'{name}_best_model.pkl')\n",
    "    print(f\"{name} model saved as '{name}_best_model.pkl'\")\n",
    "    print(f\"Best Parameters: {grid_search.best_params_}\")\n",
    "    # Cross-validation scores\n",
    "    cv_scores = cross_val_score(best_model, X, y, cv=5)\n",
    "    print(\"cv: \",cv_scores)\n",
    "    print(f\"{name} Cross-Validation Accuracy: {cv_scores.mean()}\")\n",
    "    print(\"predict\")\n",
    "    # Predictions\n",
    "    y_pred = best_model.predict(X_test)\n",
    "    \n",
    "    # Evaluation\n",
    "    print(f\"{name} Accuracy: {accuracy_score(y_test, y_pred)}\")\n",
    "    print(classification_report(y_test, y_pred))\n",
    "    \n",
    "    # ROC-AUC\n",
    "    if hasattr(best_model, \"predict_proba\"):\n",
    "        y_pred_proba = best_model.predict_proba(X_test)[:, 1]\n",
    "    else:\n",
    "        y_pred_proba = best_model.decision_function(X_test)\n",
    "    \n",
    "    roc_auc = roc_auc_score(y_test, y_pred_proba)\n",
    "    print(f\"{name} ROC-AUC: {roc_auc}\")\n",
    "\n",
    "    # Confusion Matrix\n",
    "    conf_matrix = confusion_matrix(y_test, y_pred)\n",
    "    sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues')\n",
    "    plt.title(f'{name} Confusion Matrix')\n",
    "    plt.xlabel('Predicted Label')\n",
    "    plt.ylabel('True Label')\n",
    "    plt.show()\n",
    "\n",
    "    # ROC Curve\n",
    "    fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)\n",
    "    plt.plot(fpr, tpr, label=f'{name} (AUC = {roc_auc:.2f})')\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.title(f'{name} ROC Curve')\n",
    "    plt.legend(loc='lower right')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for name, model in best_models.items():\n",
    "    if hasattr(model, \"feature_importances_\"):\n",
    "        feature_importances = model.feature_importances_\n",
    "        feature_names = tfidf.get_feature_names_out()\n",
    "        \n",
    "        # Combine TF-IDF and subject feature names\n",
    "        combined_feature_names = list(feature_names) + ['subject']\n",
    "        \n",
    "        # Plot feature importances\n",
    "        importance_df = pd.DataFrame({\n",
    "            'Feature': combined_feature_names,\n",
    "            'Importance': feature_importances\n",
    "        }).sort_values(by='Importance', ascending=False)\n",
    "        \n",
    "        plt.figure(figsize=(10, 6))\n",
    "        sns.barplot(x='Importance', y='Feature', data=importance_df.head(20))\n",
    "        plt.title(f'{name} Top 20 Feature Importances')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}