notebook/model_training.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "36095a8b-7945-404c-ba6f-513cef6da180",
   "metadata": {},
   "source": [
    "# **IMPORTS AND DATA CHECKS**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "aabcd3c8-d742-4cb7-b83a-81f993441121",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib as plt\n",
    "import seaborn as sb\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "78a1bbb8-06a2-4199-a974-3484c81fec2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import our saved split datas from our EDA notebobok\n",
    "X_train_path = os.path.join('..', 'data', 'processed', 'X_train.csv')\n",
    "y_train_path = os.path.join('..', 'data', 'processed', 'y_train.csv')\n",
    "X_test_path = os.path.join('..', 'data', 'processed', 'X_test.csv')\n",
    "y_test_path = os.path.join('..', 'data', 'processed', 'y_test.csv')\n",
    "\n",
    "# Load the CSV files\n",
    "X_train = pd.read_csv(X_train_path)\n",
    "y_train = pd.read_csv(y_train_path)\n",
    "X_test = pd.read_csv(X_test_path)\n",
    "y_test = pd.read_csv(y_test_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d51f3fc8-56e9-4e50-84a8-2ced621bd19d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HadAngina                0\n",
       "AgeCategory              0\n",
       "BMI                      0\n",
       "chronic_disease_score    0\n",
       "health_days              0\n",
       "lifestyle_score          0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "426a45da-1513-4d3b-afa6-fe45022baf4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>HadAngina</th>\n",
       "      <th>AgeCategory</th>\n",
       "      <th>BMI</th>\n",
       "      <th>chronic_disease_score</th>\n",
       "      <th>health_days</th>\n",
       "      <th>lifestyle_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>28.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>23.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>-2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>31.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   HadAngina  AgeCategory   BMI  chronic_disease_score  health_days  \\\n",
       "0        0.0          4.0  28.0                    1.0          0.0   \n",
       "1        0.0          6.0  23.0                    3.0         30.0   \n",
       "2        0.0         10.0  31.0                    6.0         10.0   \n",
       "3        0.0         10.0  44.0                    4.0         13.0   \n",
       "4        0.0          3.0  22.0                    1.0         30.0   \n",
       "\n",
       "   lifestyle_score  \n",
       "0              1.5  \n",
       "1             -2.0  \n",
       "2              3.0  \n",
       "3              1.5  \n",
       "4              2.0  "
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0e96a957-f407-4f7e-883c-b2c11f09df30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 550340 entries, 0 to 550339\n",
      "Data columns (total 6 columns):\n",
      " #   Column                 Non-Null Count   Dtype  \n",
      "---  ------                 --------------   -----  \n",
      " 0   HadAngina              550340 non-null  float64\n",
      " 1   AgeCategory            550340 non-null  float64\n",
      " 2   BMI                    550340 non-null  float64\n",
      " 3   chronic_disease_score  550340 non-null  float64\n",
      " 4   health_days            550340 non-null  float64\n",
      " 5   lifestyle_score        550340 non-null  float64\n",
      "dtypes: float64(6)\n",
      "memory usage: 25.2 MB\n"
     ]
    }
   ],
   "source": [
    "X_train.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "af428023-4ada-42d2-9d2e-7c69a90e6380",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>HadAngina</th>\n",
       "      <th>AgeCategory</th>\n",
       "      <th>BMI</th>\n",
       "      <th>chronic_disease_score</th>\n",
       "      <th>health_days</th>\n",
       "      <th>lifestyle_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>32.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>52.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>31.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   HadAngina  AgeCategory   BMI  chronic_disease_score  health_days  \\\n",
       "0        0.0          9.0  30.0                    4.0          0.0   \n",
       "1        0.0          4.0  32.0                    4.0          0.0   \n",
       "2        0.0          1.0  52.0                    2.0          0.0   \n",
       "3        1.0         10.0  31.0                    6.0         33.0   \n",
       "4        0.0          9.0  30.0                    2.0          0.0   \n",
       "\n",
       "   lifestyle_score  \n",
       "0              5.0  \n",
       "1              1.0  \n",
       "2             -1.0  \n",
       "3              1.5  \n",
       "4              2.0  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "51cdbc12-11ae-4ebd-9e16-d456723a27da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 137586 entries, 0 to 137585\n",
      "Data columns (total 6 columns):\n",
      " #   Column                 Non-Null Count   Dtype  \n",
      "---  ------                 --------------   -----  \n",
      " 0   HadAngina              137586 non-null  float64\n",
      " 1   AgeCategory            137586 non-null  float64\n",
      " 2   BMI                    137586 non-null  float64\n",
      " 3   chronic_disease_score  137586 non-null  float64\n",
      " 4   health_days            137586 non-null  float64\n",
      " 5   lifestyle_score        137586 non-null  float64\n",
      "dtypes: float64(6)\n",
      "memory usage: 6.3 MB\n"
     ]
    }
   ],
   "source": [
    "X_test.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98470b31-fd21-4a43-8df2-2f37d01526a4",
   "metadata": {},
   "source": [
    "# **Feature Scaling**\n",
    "\n",
    "this step ensures that our data are on a comparable size with other features avoiding giving more importance to features with higher values like (BMI) this also makes it fair for other models that were gonna use for training and were saving it for when we are gonna use it again for real user input when deploying the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5a621a8d-2a6d-4a87-8e04-585a9179ec0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   HadAngina  AgeCategory       BMI  chronic_disease_score  health_days  \\\n",
      "0        0.0          4.0 -0.089857              -0.387270    -0.632443   \n",
      "1        0.0          6.0 -0.879086              -0.027967     1.568246   \n",
      "2        0.0         10.0  0.383680               0.510986     0.101120   \n",
      "3        0.0         10.0  2.435674               0.151684     0.321189   \n",
      "4        0.0          3.0 -1.036932              -0.387270     1.568246   \n",
      "\n",
      "   lifestyle_score  \n",
      "0        -0.321207  \n",
      "1        -2.192118  \n",
      "2         0.480612  \n",
      "3        -0.321207  \n",
      "4        -0.053934  \n",
      "\n",
      "   HadAngina  AgeCategory       BMI  chronic_disease_score  health_days  \\\n",
      "0        0.0          9.0  0.225834               0.151684    -0.632443   \n",
      "1        0.0          4.0  0.541525               0.151684    -0.632443   \n",
      "2        0.0          1.0  3.698439              -0.207619    -0.632443   \n",
      "3        1.0         10.0  0.383680               0.510986     1.788315   \n",
      "4        0.0          9.0  0.225834              -0.207619    -0.632443   \n",
      "\n",
      "   lifestyle_score  \n",
      "0         1.549704  \n",
      "1        -0.588480  \n",
      "2        -1.657572  \n",
      "3        -0.321207  \n",
      "4        -0.053934  \n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "#features to standardize (continious vairables)\n",
    "feature_to_standardize = ['BMI','chronic_disease_score','health_days','lifestyle_score']\n",
    "\n",
    "#initiate standard scaler\n",
    "std_scaler = StandardScaler()\n",
    "\n",
    "X_train[feature_to_standardize] = std_scaler.fit_transform(X_train[feature_to_standardize])\n",
    "#only use transform to x_test\n",
    "X_test[feature_to_standardize] = std_scaler.transform(X_test[feature_to_standardize])\n",
    "\n",
    "# Save the scaler to the model directory\n",
    "joblib.dump(std_scaler, 'model/scaler.pkl')\n",
    "\n",
    "#compare this df head to the one we just did earlier to check if it worked\n",
    "print(X_train.head())\n",
    "print()\n",
    "print(X_test.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5feb3a58-a382-485c-b82e-f62bee491a9a",
   "metadata": {},
   "source": [
    "# **Initializing our models**\n",
    "\n",
    "**first we are gonna test baseline model training and see our accuracy after that we are gonna create a hyperparmeter space or grid and tune our models into their best parameters and were gonna test that using a Stratified Cross validation technique in order for each fold to have the same balance and finally we're gonna take the best model and test it with our final accuracy metric we'll be specificly paying much more attention to 'recall' metric because in medical classification problem**\n",
    "\n",
    "+ **Recall:** is much more important because it focuses on minimizing false postive cases where our model fails to identify a true positive case (someone having a heart disease but model considered it as \"none\") this is very critical so in conclusion recall is our priority score here, aside from recall we're also gonna be using AUC ROC(which provides a good overall view) and F1-SCORE (which provide us a view of both false positive and negative) basic accuracy method is unreliable in this case where our data is imbalanced\n",
    "+ **Imabalanced target:** having our target variable imbalanced as much as possible in order to remove bias towards the majority avoiding inaccurate accuracy metrics scores so it makes sense for us and very important to use techniques to handle these imbalances such as stratified split, sampling techniques, stratified cross validation, and recall accuracy metrics addressing class imbalance is very important as it will lead to fairness and better generalization of our model\n",
    "+ **The choice of models** from the feature selection we did in our last notebook in EDA we did a process of looking through the relationship of the features where the relationship strenght of linear and non linear and in the heatmap we saw that most of the features and the newly created ones are actually pretty low in linear correlation and when we did non-linear relationship we see that our newly created features are more on non-linear relationship thus the result of our choice of ensemble models **Random Forest, XGBOOST,LightGBM and catboost** are ensemble models that are good at handling non-linear relationship and are also good at classification tasks/problem that we are facing right now i have included a **logistic regression** to make a comparison of how a linear model will do despite some of feature's non-linearity and also we get to see its impact compared to other models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "544b4d40-b179-4dc4-a19c-78c7deb9c30e",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = y_train.to_numpy().ravel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3e058c01-8aa7-4fff-b157-bae6c95cc5d4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<catboost.core.CatBoostClassifier at 0x297b32ed0d0>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#importing our models\n",
    "from sklearn.ensemble import RandomForestClassifier ,GradientBoostingClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from lightgbm import LGBMClassifier\n",
    "from catboost import CatBoostClassifier\n",
    "from xgboost import XGBClassifier\n",
    "\n",
    "# Ensure y_train is in the correct shape (1D)\n",
    "y_train = y_train.to_numpy().ravel()\n",
    "\n",
    "#initializing model with basic parameters\n",
    "rf_model = RandomForestClassifier(random_state=42)\n",
    "xgb_model = XGBClassifier(random_state=42, eval_metric='logloss', device='cuda')\n",
    "logreg_model = LogisticRegression(max_iter=1000, random_state=42)\n",
    "lgbm_model = LGBMClassifier(random_state=42,device='gpu' , verbose=-1)\n",
    "catboost_model = CatBoostClassifier(silent=True, random_state=42)\n",
    "\n",
    "\n",
    "#training our models\n",
    "rf_model.fit(X_train, y_train)\n",
    "xgb_model.fit(X_train, y_train)\n",
    "logreg_model.fit(X_train, y_train)\n",
    "lgbm_model.fit(X_train,y_train)\n",
    "catboost_model.fit(X_train,  y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d23b4072-cab2-4b4b-bf0a-904116aabb7f",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## **First we will be training a baseline model to see how a model that is not tuned will do in our problem and then we'll later do the tuning on the models to see how much it improved**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "140dde95-7d40-404d-bdee-160bceca9414",
   "metadata": {},
   "source": [
    "## **Testing predictions of each of our models**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d147ed80-25bb-4a18-ac54-73a60d5db8a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest:\n",
      " - Accuracy: 0.9600031979997965\n",
      " - F1 Score: 0.5677480166522662\n",
      " - Recall: 0.4688026981450253\n",
      " - Precision: 0.7196336121067304\n",
      " - ROC AUC: 0.893719304509785\n",
      "\n",
      "XGBoost:\n",
      " - Accuracy: 0.9467823761138487\n",
      " - F1 Score: 0.29392478302796526\n",
      " - Recall: 0.19769101050719937\n",
      " - Precision: 0.5727170236753101\n",
      " - ROC AUC: 0.8711887616693137\n",
      "\n",
      "Logistic Regression:\n",
      " - Accuracy: 0.9445292398935938\n",
      " - F1 Score: 0.28632878249485694\n",
      " - Recall: 0.19859904008301985\n",
      " - Precision: 0.5128978224455611\n",
      " - ROC AUC: 0.8604121294830824\n",
      "\n",
      "LightGBM:\n",
      " - Accuracy: 0.9462372625121742\n",
      " - F1 Score: 0.25992996498249127\n",
      " - Recall: 0.16850434557011285\n",
      " - Precision: 0.568241469816273\n",
      " - ROC AUC: 0.8699606222015185\n",
      "\n",
      "CatBoost:\n",
      " - Accuracy: 0.947872603317198\n",
      " - F1 Score: 0.30945503562487964\n",
      " - Recall: 0.20845764690621352\n",
      " - Precision: 0.6002988419872992\n",
      " - ROC AUC: 0.8719678178239574\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score, roc_auc_score, recall_score, precision_score, accuracy_score\n",
    "\n",
    "# Making predictions on unseen data (X_test)\n",
    "rf_preds = rf_model.predict(X_test)\n",
    "xgb_preds = xgb_model.predict(X_test)  # Consistent variable name\n",
    "logreg_preds = logreg_model.predict(X_test)\n",
    "lgbm_preds = lgbm_model.predict(X_test)\n",
    "catboost_preds = catboost_model.predict(X_test)\n",
    "\n",
    "# Printing each accuracy metric for each model\n",
    "print(\"Random Forest:\")\n",
    "print(\" - Accuracy:\", accuracy_score(y_test, rf_preds))\n",
    "print(\" - F1 Score:\", f1_score(y_test, rf_preds))\n",
    "print(\" - Recall:\", recall_score(y_test, rf_preds))\n",
    "print(\" - Precision:\", precision_score(y_test, rf_preds))\n",
    "print(\" - ROC AUC:\", roc_auc_score(y_test, rf_model.predict_proba(X_test)[:, 1]))\n",
    "\n",
    "print(\"\\nXGBoost:\")\n",
    "print(\" - Accuracy:\", accuracy_score(y_test, xgb_preds))\n",
    "print(\" - F1 Score:\", f1_score(y_test, xgb_preds))\n",
    "print(\" - Recall:\", recall_score(y_test, xgb_preds))\n",
    "print(\" - Precision:\", precision_score(y_test, xgb_preds))\n",
    "print(\" - ROC AUC:\", roc_auc_score(y_test, xgb_model.predict_proba(X_test)[:, 1]))\n",
    "\n",
    "print(\"\\nLogistic Regression:\")\n",
    "print(\" - Accuracy:\", accuracy_score(y_test, logreg_preds))\n",
    "print(\" - F1 Score:\", f1_score(y_test, logreg_preds))\n",
    "print(\" - Recall:\", recall_score(y_test, logreg_preds))\n",
    "print(\" - Precision:\", precision_score(y_test, logreg_preds))\n",
    "print(\" - ROC AUC:\", roc_auc_score(y_test, logreg_model.predict_proba(X_test)[:, 1]))\n",
    "\n",
    "print(\"\\nLightGBM:\")\n",
    "print(\" - Accuracy:\", accuracy_score(y_test, lgbm_preds))\n",
    "print(\" - F1 Score:\", f1_score(y_test, lgbm_preds))\n",
    "print(\" - Recall:\", recall_score(y_test, lgbm_preds))\n",
    "print(\" - Precision:\", precision_score(y_test, lgbm_preds))\n",
    "print(\" - ROC AUC:\", roc_auc_score(y_test, lgbm_model.predict_proba(X_test)[:, 1]))\n",
    "\n",
    "print(\"\\nCatBoost:\")\n",
    "print(\" - Accuracy:\", accuracy_score(y_test, catboost_preds))\n",
    "print(\" - F1 Score:\", f1_score(y_test, catboost_preds))\n",
    "print(\" - Recall:\", recall_score(y_test, catboost_preds))\n",
    "print(\" - Precision:\", precision_score(y_test, catboost_preds))\n",
    "print(\" - ROC AUC:\", roc_auc_score(y_test, catboost_model.predict_proba(X_test)[:, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4868ba6a-82d7-4e8b-bc86-cf4af5e0b103",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cce32d73-8440-4486-8aff-5e71ad95e625",
   "metadata": {},
   "source": [
    "### The results give us a baseline accuracy of our models but of course there is still room for improvement as we still need to adjust our hyper parameters our model are doing well so far as it has a average f1 and recall score While ROC AUC score on the other hand is really good meaning our model generalizes well to better visualize this result lets plot it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "002960f0-d1ae-4de7-bc71-45397e0bac0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAIhCAYAAAB5deq6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABa10lEQVR4nO3deXxM9/7H8ffIMtlDLBFEKLXXFkW4do2i6IaW2qmtVLW9pVpaXfTqYum1VGtt0VQtrVra1K60RaMURW2xJHWlJHaSfH9/eGR+RpYTEcbyej4e83hkvud7znzOzHeWd86Z79iMMUYAAAAAgEzlcXUBAAAAAHC7IzgBAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBuO3NmDFDNpvNcXF3d1exYsXUrVs3HT169JbX07VrV5UoUeK61jl48KBsNptmzJhxU2rKjnXr1qldu3YqWrSoPD09FRgYqDp16mjSpEk6e/asy+q6VRo2bKiGDRu6ugxL48ePl81mU6VKlVxdyk3TsGFD2Ww23XfffTLGpFu+du1ax/M9N58zaa8lBw8evO5133jjDdlstlyrBcCdx93VBQBAdk2fPl3lypXT+fPntXbtWo0aNUpr1qzR9u3b5evre8vqeP311/X8889f1zohISHauHGjSpUqdZOqytqIESM0cuRI1alTR2+99ZZKlSqlc+fOacOGDXrjjTe0Z88ejRkzxiW13SoTJ050dQnZMm3aNEnSjh079Msvv6hWrVourujm8Pf314EDB7Ry5Uo1adLEadm0adMUEBCgpKQkF1UHAOkRnADcMSpVqqQaNWpIkho1aqSUlBS99dZbWrRokTp27JjhOufOnZOPj0+u1pGT8GO321W7du1crSO75s2bp5EjR6pHjx769NNPnf5r3rx5c/373//Wxo0bXVLbrZA2BipUqODqUixt3rxZv//+u1q2bKklS5Zo6tSpuRacLl++7DhiezsoXry4/P39NW3aNKfgdPr0ac2bN08dO3bUp59+6sIKAcAZp+oBuGOlBZFDhw5JunIKnZ+fn7Zv367IyEj5+/s7PpBdunRJb7/9tsqVKye73a6CBQuqW7du+t///pduu3PmzFFERIT8/Pzk5+enqlWraurUqY7lGZ2qN2/ePNWqVUuBgYHy8fHRfffdp+7duzuWZ3aq3vr169WkSRP5+/vLx8dHderU0ZIlS5z6pJ1etGrVKvXt21cFChRQ/vz59fjjj+vYsWOW99PIkSOVL18+xylg1/L391dkZKTj+oULFzR06FCVLFlSnp6eKlq0qPr3769Tp045rVeiRAk98sgj+u6771StWjV5e3urfPny+u677xx1ly9fXr6+vqpZs6Y2b97stH7a47Vjxw41adJEvr6+KliwoJ577jmdO3fOqe+ECRNUv359FSpUSL6+vnrggQc0evRoXb582alfw4YNValSJa1du1Z16tSRj4+P43HI6FS9SZMmqUqVKvLz85O/v7/KlSunV1991anPH3/8oTZt2ihfvnzy8vJS1apVNXPmTKc+q1evls1m09y5czVs2DAVKVJEAQEBatq0qXbv3p3JI5Ne2jh77733VKdOHX355Zfp7gtJOnr0qJ599lmFhobK09NTRYoU0ZNPPqm///7bqZ7PP/9cL774oooWLSq73a6//vpL0pUjOlWqVJGXl5eCgoL02GOPadeuXU63sX//fj311FMqUqSI7Ha7goOD1aRJE23dutXRZ+XKlWrYsKHy588vb29vFS9eXE888USGNWeke/fuWrBggdPY+vLLLyVJTz31VIbrZOc5I0k///yz6tatKy8vLxUpUkRDhw5NN17SREVFKSIiQr6+vvLz81OzZs0UExNjWf+N7j+AOwvBCcAdK+1DYMGCBR1tly5dUuvWrdW4cWN98803evPNN5Wamqo2bdrovffeU4cOHbRkyRK99957io6OVsOGDXX+/HnH+sOHD1fHjh1VpEgRzZgxQwsXLlSXLl0c4SwjGzduVPv27XXffffpyy+/1JIlSzR8+HAlJydnWf+aNWvUuHFjJSYmaurUqZo7d678/f3VqlUrRUVFpevfs2dPeXh4aM6cORo9erRWr16tZ555JsvbiIuL0x9//KHIyMhsHXkzxujRRx/VBx98oE6dOmnJkiUaPHiwZs6cqcaNG+vixYtO/X///XcNHTpUr7zyihYsWKDAwEA9/vjjGjFihD777DO9++67mj17thITE/XII4843dfSlaMgLVq0UJMmTbRo0SI999xz+uSTT9S+fXunfvv27VOHDh30+eef67vvvlOPHj30/vvvq3fv3hnu8zPPPKMOHTpo6dKl6tevX4b7+uWXX6pfv35q0KCBFi5cqEWLFumFF15w+r7X7t27VadOHe3YsUPjx4/XggULVKFCBXXt2lWjR49Ot81XX31Vhw4d0meffaYpU6Zo7969atWqlVJSUizv+/Pnz2vu3Ll68MEHValSJXXv3t1x9OVqR48e1YMPPqiFCxdq8ODBWrZsmcaOHavAwECdPHnSqe/QoUMVGxuryZMna/HixSpUqJBGjRqlHj16qGLFilqwYIHGjRunbdu2KSIiQnv37nWs26JFC23ZskWjR49WdHS0Jk2apGrVqjlCzsGDB9WyZUt5enpq2rRpWr58ud577z35+vrq0qVLlvsrXQlHbm5umjt3rqNt6tSpevLJJxUQEJCuf3afMzt37lSTJk106tQpzZgxQ5MnT1ZMTIzefvvtdNt899139fTTT6tChQr66quv9Pnnn+v06dOqV6+edu7cmWntubH/AO4wBgBuc9OnTzeSzM8//2wuX75sTp8+bb777jtTsGBB4+/vb+Lj440xxnTp0sVIMtOmTXNaf+7cuUaSmT9/vlP7pk2bjCQzceJEY4wx+/fvN25ubqZjx45Z1tOlSxcTFhbmuP7BBx8YSebUqVOZrnPgwAEjyUyfPt3RVrt2bVOoUCFz+vRpR1tycrKpVKmSKVasmElNTXXa/379+jltc/To0UaSiYuLy/R2f/75ZyPJDBkyJMt9SrN8+XIjyYwePdqpPSoqykgyU6ZMcbSFhYUZb29vc+TIEUfb1q1bjSQTEhJizp4962hftGiRkWS+/fZbR1va4zVu3Din23rnnXeMJLN+/foMa0xJSTGXL182s2bNMm5ubuaff/5xLGvQoIGRZFasWJFuvQYNGpgGDRo4rj/33HMmb968Wd4fTz31lLHb7SY2NtapvXnz5sbHx8fxmK9atcpIMi1atHDq99VXXxlJZuPGjVnejjHGzJo1y0gykydPNsYYc/r0aePn52fq1avn1K979+7Gw8PD7Ny5M9NtpdVTv359p/aTJ08ab2/vdHXGxsYau91uOnToYIwx5sSJE0aSGTt2bKa38fXXXxtJZuvWrZb7dq0GDRqYihUrGmOujIMaNWoYY4zZsWOHkWRWr17teH7m5DnTvn174+3t7XhtSOtXrlw5I8kcOHDAsd/u7u5mwIABTvWdPn3aFC5c2LRr187RNmLECHP1x6Yb2X8AdyaOOAG4Y9SuXVseHh7y9/fXI488osKFC2vZsmUKDg526vfEE084Xf/uu++UN29etWrVSsnJyY5L1apVVbhwYa1evVqSFB0drZSUFPXv3/+66nrwwQclSe3atdNXX32VrZn+zp49q19++UVPPvmk/Pz8HO1ubm7q1KmTjhw5ku4Ur9atWztdr1y5siRleTTseq1cuVLSldPorta2bVv5+vpqxYoVTu1Vq1ZV0aJFHdfLly8v6cppcVcf4Uprz6jWa7+f1qFDB0nSqlWrHG0xMTFq3bq18ufPLzc3N3l4eKhz585KSUnRnj17nNbPly+fGjdubLmvNWvW1KlTp/T000/rm2++0YkTJ9L1SZu4IDQ01Km9a9euOnfuXLrvht3IYzR16lR5e3s7TlHz8/NT27ZttW7dOqcjQcuWLVOjRo0c92lWrn0ubNy4UefPn0/3+IaGhqpx48aOxzcoKEilSpXS+++/r48++kgxMTFKTU11Wqdq1ary9PTUs88+q5kzZ2r//v2W9WSke/fu2rx5s7Zv366pU6eqVKlSql+/frp+1/OcWbVqlZo0aeL02uDm5pbuSOb333+v5ORkde7c2em1wcvLSw0aNHC8NmQkt/YfwJ2D4ATgjjFr1ixt2rRJMTExOnbsmLZt26a6des69fHx8Ul3is/ff/+tU6dOydPTUx4eHk6X+Ph4xwfmtO87FStW7Lrqql+/vhYtWuT4AFasWDFVqlTJ6fSja508eVLGGIWEhKRbVqRIEUlSQkKCU3v+/PmdrtvtdklKd/rb1YoXLy5JOnDgQLb2JSEhQe7u7k6nP0qSzWZT4cKF09UUFBTkdN3T0zPL9gsXLji1u7u7p9uvwoULO2qRpNjYWNWrV09Hjx7VuHHjtG7dOm3atEkTJkyQlH7/M7pPM9KpUydNmzZNhw4d0hNPPKFChQqpVq1aio6OdvRJSEi46Y+RdOW007Vr16ply5YyxujUqVM6deqUnnzySUn/P9OedGWcZneMXlt7Wr2Z7VPacpvNphUrVqhZs2YaPXq0qlevroIFC2rgwIE6ffq0pCuTpPz4448qVKiQ+vfvr1KlSqlUqVIaN25ctmpLU79+fd1///365JNP9Pnnn6t79+4Zfhfvep4zCQkJjnF0tWvb0r4T9uCDD6Z7bYiKisowTKfJrf0HcOe4PabWAYBsKF++vGNWvcxk9IErbTKF5cuXZ7iOv7+/pP//rtSRI0fSHWGw0qZNG7Vp00YXL17Uzz//rFGjRqlDhw4qUaKEIiIi0vXPly+f8uTJo7i4uHTL0iZ8KFCgwHXVkJGQkBA98MAD+uGHH7I1w2D+/PmVnJys//3vf07hyRij+Ph4x9G13JKcnKyEhASnwBEfH++oRZIWLVqks2fPasGCBQoLC3P0u3qSgqtdz2/tdOvWTd26ddPZs2e1du1ajRgxQo888oj27NmjsLAw5c+f/6Y/RtKVYGSM0ddff62vv/463fKZM2fq7bfflpubmwoWLKgjR45ka7vX3hdp92lm+3T1/oSFhTkmq9izZ4+++uorvfHGG7p06ZImT54sSapXr57q1aunlJQUbd68WR9//LEGDRqk4ODgTCd3yEi3bt302muvyWazqUuXLhn2uZ7nTP78+R3j6GrXtqX1//rrr53GVnbl1v4DuDNwxAnAXe+RRx5RQkKCUlJSVKNGjXSXsmXLSpIiIyPl5uamSZMm5fi27Ha7GjRooP/85z+SlOnMXL6+vqpVq5YWLFjgdDQiNTVVX3zxhYoVK6YyZcrkuI6rvf766zp58qQGDhyY4Y+NnjlzRj/88IMkOWYh/OKLL5z6zJ8/X2fPnk33ezu5Yfbs2U7X58yZI0mOGfDSPvynHb2RrgS53Jyq2tfXV82bN9ewYcN06dIl7dixQ9KV+2PlypXpZi+cNWuWfHx8cmWK+ZSUFM2cOVOlSpXSqlWr0l1efPFFxcXFadmyZZKuTCG/atWq65qtL01ERIS8vb3TPb5HjhzJ8PeU0pQpU0avvfaaHnjgAf3222/plru5ualWrVqOo4AZ9clKly5d1KpVK7388stOp35e7XqeM40aNdKKFSscR5SkK/fztZOuNGvWTO7u7tq3b1+Grw1W/6jJrf0HcGfgiBOAu95TTz2l2bNnq0WLFnr++edVs2ZNeXh46MiRI1q1apXatGmjxx57TCVKlNCrr76qt956S+fPn9fTTz+twMBA7dy5UydOnNCbb76Z4faHDx+uI0eOqEmTJipWrJhOnTqlcePGycPDQw0aNMi0rlGjRumhhx5So0aN9NJLL8nT01MTJ07UH3/8oblz517XkZOstG3bVq+//rreeust/fnnn+rRo4fjB3B/+eUXxyx2kZGReuihh9SsWTO98sorSkpKUt26dbVt2zaNGDFC1apVU6dOnXKlpjSenp768MMPdebMGT344IPasGGD3n77bTVv3lz/+te/JEkPPfSQPD099fTTT+vf//63Lly4oEmTJqWbQe569erVS97e3qpbt65CQkIUHx+vUaNGKTAw0HFkbcSIEfruu+/UqFEjDR8+XEFBQZo9e7aWLFmi0aNHKzAw8Ibvg2XLlunYsWP6z3/+k266dOnK75f997//1dSpU/XII49o5MiRWrZsmerXr69XX31VDzzwgE6dOqXly5dr8ODBKleuXKa3lTdvXr3++ut69dVX1blzZz399NNKSEjQm2++KS8vL40YMUKStG3bNj333HNq27at7r//fnl6emrlypXatm2bhgwZIkmaPHmyVq5cqZYtW6p48eK6cOGC45TCpk2bXtd9UKRIES1atMiyX3afM6+99pq+/fZbNW7cWMOHD5ePj48mTJjgNGOidGVK/ZEjR2rYsGHav3+/Hn74YeXLl09///23fv31V/n6+mb6vM/N/Qdwh3DhxBQAkC1ps8pt2rQpy35dunQxvr6+GS67fPmy+eCDD0yVKlWMl5eX8fPzM+XKlTO9e/c2e/fudeo7a9Ys8+CDDzr6VatWzWlmr2tn1fvuu+9M8+bNTdGiRY2np6cpVKiQadGihVm3bp2jT0az6hljzLp160zjxo2Nr6+v8fb2NrVr1zaLFy/O1v6nzZy2atWqLO+XNGvWrDFPPvmkCQkJMR4eHiYgIMBERESY999/3yQlJTn6nT9/3rzyyismLCzMeHh4mJCQENO3b19z8uRJp+2FhYWZli1bprsdSaZ///5ObWn7//777zva0h6vbdu2mYYNGxpvb28TFBRk+vbta86cOeO0/uLFix2PXdGiRc3LL79sli1blm7/r56t7VrXzqo3c+ZM06hRIxMcHGw8PT1NkSJFTLt27cy2bduc1tu+fbtp1aqVCQwMNJ6enqZKlSrpHse0x2LevHkZ7ve1/a/26KOPGk9PT3P8+PFM+zz11FPG3d3dMUvc4cOHTffu3U3hwoWNh4eHo/a///47y3rSfPbZZ6Zy5crG09PTBAYGmjZt2pgdO3Y4lv/999+ma9euply5csbX19f4+fmZypUrmzFjxpjk5GRjjDEbN240jz32mAkLCzN2u93kz5/fNGjQwGnmxMxk9TilyWhWPWOy95wxxpiffvrJ1K5d29jtdlO4cGHz8ssvmylTpjjNqpdm0aJFplGjRiYgIMDY7XYTFhZmnnzySfPjjz86+lw7q96N7D+AO5PNmAzO2wAA4Cbr2rWrvv76a505c8bVpQAAYInvOAEAAACABYITAAAAAFjgVD0AAAAAsMARJwAAAACwQHACAAAAAAsEJwAAAACwcM/9AG5qaqqOHTsmf3//XPtxSQAAAAB3HmOMTp8+rSJFiihPnqyPKd1zwenYsWMKDQ11dRkAAAAAbhOHDx9WsWLFsuxzzwUnf39/SVfunICAABdXAwAAAMBVkpKSFBoa6sgIWbnnglPa6XkBAQEEJwAAAADZ+goPk0MAAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBAAAAgAWCEwAAAABYIDgBAAAAgAV3VxcASXNsrq4Aua2DcXUFAAAAyEUccQIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACy4PThMnTlTJkiXl5eWl8PBwrVu3LtO+Xbt2lc1mS3epWLHiLawYAAAAwL3GpcEpKipKgwYN0rBhwxQTE6N69eqpefPmio2NzbD/uHHjFBcX57gcPnxYQUFBatu27S2uHAAAAMC9xKXB6aOPPlKPHj3Us2dPlS9fXmPHjlVoaKgmTZqUYf/AwEAVLlzYcdm8ebNOnjypbt263eLKAQAAANxLXBacLl26pC1btigyMtKpPTIyUhs2bMjWNqZOnaqmTZsqLCws0z4XL15UUlKS0wUAAAAArofLgtOJEyeUkpKi4OBgp/bg4GDFx8dbrh8XF6dly5apZ8+eWfYbNWqUAgMDHZfQ0NAbqhsAAADAvcflk0PYbDan68aYdG0ZmTFjhvLmzatHH300y35Dhw5VYmKi43L48OEbKRcAAADAPcjdVTdcoEABubm5pTu6dPz48XRHoa5ljNG0adPUqVMneXp6ZtnXbrfLbrffcL0AAAAA7l0uO+Lk6emp8PBwRUdHO7VHR0erTp06Wa67Zs0a/fXXX+rRo8fNLBEAAAAAJLnwiJMkDR48WJ06dVKNGjUUERGhKVOmKDY2Vn369JF05TS7o0ePatasWU7rTZ06VbVq1VKlSpVcUTYAAACAe4xLg1P79u2VkJCgkSNHKi4uTpUqVdLSpUsds+TFxcWl+02nxMREzZ8/X+PGjXNFyQAAAADuQTZjjHF1EbdSUlKSAgMDlZiYqICAAFeXc8Uc68kwcIfpcE89rQAAAO5I15MNXD6rHgAAAADc7ghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGCB4AQAAAAAFghOAAAAAGDB5cFp4sSJKlmypLy8vBQeHq5169Zl2f/ixYsaNmyYwsLCZLfbVapUKU2bNu0WVQsAAADgXuTuyhuPiorSoEGDNHHiRNWtW1effPKJmjdvrp07d6p48eIZrtOuXTv9/fffmjp1qkqXLq3jx48rOTn5FlcOAAAA4F5iM8YYV914rVq1VL16dU2aNMnRVr58eT366KMaNWpUuv7Lly/XU089pf379ysoKChHt5mUlKTAwEAlJiYqICAgx7Xnqjk2V1eA3NbBZU8rAAAAZNP1ZAOXnap36dIlbdmyRZGRkU7tkZGR2rBhQ4brfPvtt6pRo4ZGjx6tokWLqkyZMnrppZd0/vz5TG/n4sWLSkpKcroAAAAAwPVw2al6J06cUEpKioKDg53ag4ODFR8fn+E6+/fv1/r16+Xl5aWFCxfqxIkT6tevn/75559Mv+c0atQovfnmm7lePwAAAG4Rzs65+9yBZ+e4fHIIm835iWCMSdeWJjU1VTabTbNnz1bNmjXVokULffTRR5oxY0amR52GDh2qxMREx+Xw4cO5vg8AAAAA7m4uO+JUoEABubm5pTu6dPz48XRHodKEhISoaNGiCgwMdLSVL19exhgdOXJE999/f7p17Ha77HZ77hYPAAAA4J7isiNOnp6eCg8PV3R0tFN7dHS06tSpk+E6devW1bFjx3TmzBlH2549e5QnTx4VK1bsptYLAAAA4N7l0lP1Bg8erM8++0zTpk3Trl279MILLyg2NlZ9+vSRdOU0u86dOzv6d+jQQfnz51e3bt20c+dOrV27Vi+//LK6d+8ub29vV+0GAAAAgLucS3/HqX379kpISNDIkSMVFxenSpUqaenSpQoLC5MkxcXFKTY21tHfz89P0dHRGjBggGrUqKH8+fOrXbt2evvtt121CwAAAADuAS79HSdX4HeccEvcgTPFAABw2+Kz0t3nNvmsdEf8jhMAAAAA3CkITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABgwd3VBQDIJXNsrq4AN0MH4+oKAACAOOIEAAAAAJY44gQAAG4OjoTffTgKjnsYR5wAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwIK7qwsAANxm5thcXQFuhg7G1RUAwB2NI04AAAAAYIHgBAAAAAAWCE4AAAAAYMHlwWnixIkqWbKkvLy8FB4ernXr1mXad/Xq1bLZbOkuf/755y2sGAAAAMC9xqXBKSoqSoMGDdKwYcMUExOjevXqqXnz5oqNjc1yvd27dysuLs5xuf/++29RxQAAAADuRS4NTh999JF69Oihnj17qnz58ho7dqxCQ0M1adKkLNcrVKiQChcu7Li4ubndoooBAAAA3ItcFpwuXbqkLVu2KDIy0qk9MjJSGzZsyHLdatWqKSQkRE2aNNGqVauy7Hvx4kUlJSU5XQAAAADgergsOJ04cUIpKSkKDg52ag8ODlZ8fHyG64SEhGjKlCmaP3++FixYoLJly6pJkyZau3ZtprczatQoBQYGOi6hoaG5uh8AAAAA7n4u/wFcm835hxaNMena0pQtW1Zly5Z1XI+IiNDhw4f1wQcfqH79+hmuM3ToUA0ePNhxPSkpifAEAAAA4Lq47IhTgQIF5Obmlu7o0vHjx9MdhcpK7dq1tXfv3kyX2+12BQQEOF0AAAAA4Hq4LDh5enoqPDxc0dHRTu3R0dGqU6dOtrcTExOjkJCQ3C4PAAAAABxceqre4MGD1alTJ9WoUUMRERGaMmWKYmNj1adPH0lXTrM7evSoZs2aJUkaO3asSpQooYoVK+rSpUv64osvNH/+fM2fP9+VuwEAAADgLufS4NS+fXslJCRo5MiRiouLU6VKlbR06VKFhYVJkuLi4px+0+nSpUt66aWXdPToUXl7e6tixYpasmSJWrRo4apdAAAAAHAPsBljjKuLuJWSkpIUGBioxMTE2+f7TnMyngwDd7AOLnhaMY7uTowl5BbGEnKDK8aRxFi6G7lqLF3jerKBS38AFwAAAADuBAQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAAC+45Wens2bN67733tGLFCh0/flypqalOy/fv358rxQEAAADA7SBHwalnz55as2aNOnXqpJCQENlsttyuCwAAAABuGzkKTsuWLdOSJUtUt27d3K4HAAAAAG47OfqOU758+RQUFJTbtQAAAADAbSlHwemtt97S8OHDde7cudyuBwAAAABuOzk6Ve/DDz/Uvn37FBwcrBIlSsjDw8Np+W+//ZYrxQEAAADA7SBHwenRRx/N5TIAAAAA4PaVo+A0YsSI3K4DAAAAAG5bOQpOabZs2aJdu3bJZrOpQoUKqlatWm7VBQAAAAC3jRxNDnH8+HE1btxYDz74oAYOHKjnnntO4eHhatKkif73v/9d17YmTpyokiVLysvLS+Hh4Vq3bl221vvpp5/k7u6uqlWr5mAPAAAAACD7chScBgwYoKSkJO3YsUP//POPTp48qT/++ENJSUkaOHBgtrcTFRWlQYMGadiwYYqJiVG9evXUvHlzxcbGZrleYmKiOnfurCZNmuSkfAAAAAC4LjkKTsuXL9ekSZNUvnx5R1uFChU0YcIELVu2LNvb+eijj9SjRw/17NlT5cuX19ixYxUaGqpJkyZluV7v3r3VoUMHRURE5KR8AAAAALguOQpOqamp6aYglyQPDw+lpqZmaxuXLl3Sli1bFBkZ6dQeGRmpDRs2ZLre9OnTtW/fvmxPUHHx4kUlJSU5XQAAAADgeuQoODVu3FjPP/+8jh075mg7evSoXnjhhWyfPnfixAmlpKQoODjYqT04OFjx8fEZrrN3714NGTJEs2fPlrt79ua1GDVqlAIDAx2X0NDQbK0HAAAAAGlyFJz++9//6vTp0ypRooRKlSql0qVLq2TJkjp9+rQ+/vjj69qWzWZzum6MSdcmSSkpKerQoYPefPNNlSlTJtvbHzp0qBITEx2Xw4cPX1d9AAAAAJCj6chDQ0P122+/KTo6Wn/++aeMMapQoYKaNm2a7W0UKFBAbm5u6Y4uHT9+PN1RKEk6ffq0Nm/erJiYGD333HOSrpwyaIyRu7u7fvjhBzVu3Djdena7XXa7/Tr3EAAAAAD+3w39jtNDDz2khx56KEfrenp6Kjw8XNHR0Xrssccc7dHR0WrTpk26/gEBAdq+fbtT28SJE7Vy5Up9/fXXKlmyZI7qAAAAAAAr2Q5O48eP17PPPisvLy+NHz8+y77ZnZJ88ODB6tSpk2rUqKGIiAhNmTJFsbGx6tOnj6Qrp9kdPXpUs2bNUp48eVSpUiWn9QsVKiQvL6907QAAAACQm7IdnMaMGaOOHTvKy8tLY8aMybSfzWbLdnBq3769EhISNHLkSMXFxalSpUpaunSpwsLCJElxcXGWv+kEAAAAADebzRhjXF3ErZSUlKTAwEAlJiYqICDA1eVcMSf9ZBi4w3VwwdOKcXR3YiwhtzCWkBtcMY4kxtLdyFVj6RrXkw1yNKvetVJSUrR161adPHkyNzYHAAAAALeVHAWnQYMGaerUqZKuhKb69eurevXqCg0N1erVq3OzPgAAAABwuRwFp6+//lpVqlSRJC1evFgHDx7Un3/+qUGDBmnYsGG5WiAAAAAAuFqOgtOJEydUuHBhSdLSpUvVtm1blSlTRj169Eg3ZTgAAAAA3OlyFJyCg4O1c+dOpaSkaPny5Y4fvj137pzc3NxytUAAAAAAcLUc/QBut27d1K5dO4WEhMhmszl+BPeXX35RuXLlcrVAAAAAAHC1HAWnN954Q5UqVdLhw4fVtm1b2e12SZKbm5uGDBmSqwUCAAAAgKvlKDhJ0pNPPpmurUuXLjdUDAAAAADcjrIdnMaPH69nn31WXl5eGj9+fJZ9Bw4ceMOFAQAAAMDtItvBacyYMerYsaO8vLw0ZsyYTPvZbDaCEwAAAIC7SraD04EDBzL8GwAAAADudjmajhwAAAAA7iU5Ck5PPvmk3nvvvXTt77//vtq2bXvDRQEAAADA7SRHwWnNmjVq2bJluvaHH35Ya9euveGiAAAAAOB2kqPgdObMGXl6eqZr9/DwUFJS0g0XBQAAAAC3kxwFp0qVKikqKipd+5dffqkKFSrccFEAAAAAcDvJ0Q/gvv7663riiSe0b98+NW7cWJK0YsUKzZ07V/PmzcvVAgEAAADA1XIUnFq3bq1Fixbp3Xff1ddffy1vb29VrlxZP/74oxo0aJDbNQIAAACAS+UoOElSy5YtM5wgAgAAAADuNjn+HadTp07ps88+06uvvqp//vlHkvTbb7/p6NGjuVYcAAAAANwOcnTEadu2bWratKkCAwN18OBB9ezZU0FBQVq4cKEOHTqkWbNm5XadAAAAAOAyOTriNHjwYHXt2lV79+6Vl5eXo7158+b8jhMAAACAu06OgtOmTZvUu3fvdO1FixZVfHz8DRcFAAAAALeTHAUnLy+vDH/odvfu3SpYsOANFwUAAAAAt5McBac2bdpo5MiRunz5siTJZrMpNjZWQ4YM0RNPPJGrBQIAAACAq+UoOH3wwQf63//+p0KFCun8+fNq0KCBSpcuLX9/f73zzju5XSMAAAAAuFSOZtULCAjQ+vXrtXLlSv32229KTU1V9erV1bRp09yuDwAAAABc7rqDU3Jysry8vLR161Y1btxYjRs3vhl1AQAAAMBt47pP1XN3d1dYWJhSUlJuRj0AAAAAcNvJ0XecXnvtNQ0dOlT//PNPbtcDAAAAALedHH3Hafz48frrr79UpEgRhYWFydfX12n5b7/9livFAQAAAMDtIEfB6dFHH5XNZpMxJrfrAQAAAIDbznUFp3Pnzunll1/WokWLdPnyZTVp0kQff/yxChQocLPqAwAAAACXu67vOI0YMUIzZsxQy5Yt9fTTT+vHH39U3759b1ZtAAAAAHBbuK4jTgsWLNDUqVP11FNPSZI6duyounXrKiUlRW5ubjelQAAAAABwtes64nT48GHVq1fPcb1mzZpyd3fXsWPHcr0wAAAAALhdXFdwSklJkaenp1Obu7u7kpOTc7UoAAAAALidXNepesYYde3aVXa73dF24cIF9enTx2lK8gULFuRehQAAAADgYtcVnLp06ZKu7Zlnnsm1YgAAAADgdnRdwWn69Ok3qw4AAAAAuG1d13ecAAAAAOBeRHACAAAAAAsEJwAAAACwQHACAAAAAAsEJwAAAACwQHACAAAAAAsEJwAAAACwQHACAAAAAAsEJwAAAACwQHACAAAAAAsuD04TJ05UyZIl5eXlpfDwcK1bty7TvuvXr1fdunWVP39+eXt7q1y5chozZswtrBYAAADAvcjdlTceFRWlQYMGaeLEiapbt64++eQTNW/eXDt37lTx4sXT9ff19dVzzz2nypUry9fXV+vXr1fv3r3l6+urZ5991gV7AAAAAOBe4NIjTh999JF69Oihnj17qnz58ho7dqxCQ0M1adKkDPtXq1ZNTz/9tCpWrKgSJUromWeeUbNmzbI8SgUAAAAAN8plwenSpUvasmWLIiMjndojIyO1YcOGbG0jJiZGGzZsUIMGDTLtc/HiRSUlJTldAAAAAOB6uCw4nThxQikpKQoODnZqDw4OVnx8fJbrFitWTHa7XTVq1FD//v3Vs2fPTPuOGjVKgYGBjktoaGiu1A8AAADg3uHyySFsNpvTdWNMurZrrVu3Tps3b9bkyZM1duxYzZ07N9O+Q4cOVWJiouNy+PDhXKkbAAAAwL3DZZNDFChQQG5ubumOLh0/fjzdUahrlSxZUpL0wAMP6O+//9Ybb7yhp59+OsO+drtddrs9d4oGAAAAcE9y2REnT09PhYeHKzo62qk9OjpaderUyfZ2jDG6ePFibpcHAAAAAA4unY588ODB6tSpk2rUqKGIiAhNmTJFsbGx6tOnj6Qrp9kdPXpUs2bNkiRNmDBBxYsXV7ly5SRd+V2nDz74QAMGDHDZPgAAAAC4+7k0OLVv314JCQkaOXKk4uLiVKlSJS1dulRhYWGSpLi4OMXGxjr6p6amaujQoTpw4IDc3d1VqlQpvffee+rdu7erdgEAAADAPcBmjDGuLuJWSkpKUmBgoBITExUQEODqcq6Yk/VkGLgDdXDB04pxdHdiLCG3MJaQG1wxjiTG0t3IVWPpGteTDVw+qx4AAAAA3O4ITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABYITgAAAABggeAEAAAAABZcHpwmTpyokiVLysvLS+Hh4Vq3bl2mfRcsWKCHHnpIBQsWVEBAgCIiIvT999/fwmoBAAAA3ItcGpyioqI0aNAgDRs2TDExMapXr56aN2+u2NjYDPuvXbtWDz30kJYuXaotW7aoUaNGatWqlWJiYm5x5QAAAADuJTZjjHHVjdeqVUvVq1fXpEmTHG3ly5fXo48+qlGjRmVrGxUrVlT79u01fPjwDJdfvHhRFy9edFxPSkpSaGioEhMTFRAQcGM7kFvm2FxdAXJbBxc8rRhHdyfGEnILYwm5wRXjSGIs3Y1cNZaukZSUpMDAwGxlA5cdcbp06ZK2bNmiyMhIp/bIyEht2LAhW9tITU3V6dOnFRQUlGmfUaNGKTAw0HEJDQ29oboBAAAA3HtcFpxOnDihlJQUBQcHO7UHBwcrPj4+W9v48MMPdfbsWbVr1y7TPkOHDlViYqLjcvjw4RuqGwAAAMC9x93VBdhszodejTHp2jIyd+5cvfHGG/rmm29UqFChTPvZ7XbZ7fYbrhMAAADAvctlwalAgQJyc3NLd3Tp+PHj6Y5CXSsqKko9evTQvHnz1LRp05tZJgAAAAC47lQ9T09PhYeHKzo62qk9OjpaderUyXS9uXPnqmvXrpozZ45atmx5s8sEAAAAANeeqjd48GB16tRJNWrUUEREhKZMmaLY2Fj16dNH0pXvJx09elSzZs2SdCU0de7cWePGjVPt2rUdR6u8vb0VGBjosv0AAAAAcHdzaXBq3769EhISNHLkSMXFxalSpUpaunSpwsLCJElxcXFOv+n0ySefKDk5Wf3791f//v0d7V26dNGMGTNudfkAAAAA7hEunxyiX79+6tevX4bLrg1Dq1evvvkFAQAAAMA1XPYdJwAAAAC4UxCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMACwQkAAAAALBCcAAAAAMCCy4PTxIkTVbJkSXl5eSk8PFzr1q3LtG9cXJw6dOigsmXLKk+ePBo0aNCtKxQAAADAPculwSkqKkqDBg3SsGHDFBMTo3r16ql58+aKjY3NsP/FixdVsGBBDRs2TFWqVLnF1QIAAAC4V7k0OH300Ufq0aOHevbsqfLly2vs2LEKDQ3VpEmTMuxfokQJjRs3Tp07d1ZgYOAtrhYAAADAvcplwenSpUvasmWLIiMjndojIyO1YcOGXLudixcvKikpyekCAAAAANfDZcHpxIkTSklJUXBwsFN7cHCw4uPjc+12Ro0apcDAQMclNDQ017YNAAAA4N7g8skhbDab03VjTLq2GzF06FAlJiY6LocPH861bQMAAAC4N7i76oYLFCggNze3dEeXjh8/nu4o1I2w2+2y2+25tj0AAAAA9x6XHXHy9PRUeHi4oqOjndqjo6NVp04dF1UFAAAAAOm57IiTJA0ePFidOnVSjRo1FBERoSlTpig2NlZ9+vSRdOU0u6NHj2rWrFmOdbZu3SpJOnPmjP73v/9p69at8vT0VIUKFVyxCwAAAADuAS4NTu3bt1dCQoJGjhypuLg4VapUSUuXLlVYWJikKz94e+1vOlWrVs3x95YtWzRnzhyFhYXp4MGDt7J0AAAAAPcQlwYnSerXr5/69euX4bIZM2akazPG3OSKAAAAAMCZy2fVAwAAAIDbHcEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACwQnAAAAADAAsEJAAAAACy4PDhNnDhRJUuWlJeXl8LDw7Vu3bos+69Zs0bh4eHy8vLSfffdp8mTJ9+iSgEAAADcq1wanKKiojRo0CANGzZMMTExqlevnpo3b67Y2NgM+x84cEAtWrRQvXr1FBMTo1dffVUDBw7U/Pnzb3HlAAAAAO4lLg1OH330kXr06KGePXuqfPnyGjt2rEJDQzVp0qQM+0+ePFnFixfX2LFjVb58efXs2VPdu3fXBx98cIsrBwAAAHAvcXfVDV+6dElbtmzRkCFDnNojIyO1YcOGDNfZuHGjIiMjndqaNWumqVOn6vLly/Lw8Ei3zsWLF3Xx4kXH9cTERElSUlLSje5C7jnn6gKQ61wxvhhHdyfGEnILYwm5wVWfnxhLd5/b5LN4WiYwxlj2dVlwOnHihFJSUhQcHOzUHhwcrPj4+AzXiY+Pz7B/cnKyTpw4oZCQkHTrjBo1Sm+++Wa69tDQ0BuoHrDQK9DVFeBuwVhCbmEsITcwjpBbbrOxdPr0aQUGZl2Ty4JTGpvN5nTdGJOuzap/Ru1phg4dqsGDBzuup6am6p9//lH+/PmzvB3krqSkJIWGhurw4cMKCAhwdTm4gzGWkFsYS8gtjCXkBsaRaxhjdPr0aRUpUsSyr8uCU4ECBeTm5pbu6NLx48fTHVVKU7hw4Qz7u7u7K3/+/BmuY7fbZbfbndry5s2b88JxQwICAngxQK5gLCG3MJaQWxhLyA2Mo1vP6khTGpdNDuHp6anw8HBFR0c7tUdHR6tOnToZrhMREZGu/w8//KAaNWpk+P0mAAAAAMgNLp1Vb/Dgwfrss880bdo07dq1Sy+88IJiY2PVp08fSVdOs+vcubOjf58+fXTo0CENHjxYu3bt0rRp0zR16lS99NJLrtoFAAAAAPcAl37HqX379kpISNDIkSMVFxenSpUqaenSpQoLC5MkxcXFOf2mU8mSJbV06VK98MILmjBhgooUKaLx48friSeecNUuIJvsdrtGjBiR7rRJ4HoxlpBbGEvILYwl5AbG0e3PZrIz9x4AAAAA3MNceqoeAAAAANwJCE4AAAAAYIHgBAAAAAAWCE7IUokSJTR27FhXlwHgDnSjrx8zZszgd/cy0bBhQw0aNMjVZdwRbDabFi1alO3+q1evls1m06lTp25aTQDuTASn21zXrl1ls9lks9nk7u6u4sWLq2/fvjp58qSrS7up3njjDcd+X3358ccfXVpT1apVXXb7t6uUlBTVqVMn3eyWiYmJCg0N1WuvveZomz9/vho3bqx8+fLJx8dHZcuWVffu3RUTE+PoM2PGDKfH3M/PT+Hh4VqwYMEt2yfp7v9g2rVrVz366KM39TY2bdqkZ599Nlt9MwpZ7du31549e3J8+9eOpeDgYLVq1Uo7duzI8TZvFwsWLNBbb73l6jJuG1mN57i4ODVv3jxXby+r94OYmBi1b99eISEhstvtCgsL0yOPPKLFixcrbT6ugwcPOo1NT09PlS5dWm+//baunrMr7b3w4YcfTnc7o0ePls1mU8OGDXN13+AsPj5eAwYM0H333Se73a7Q0FC1atVKK1asyNb6mf0DqGHDho7HP0+ePAoODlbbtm116NChXN6DzKWNw61bt96y27zTEZzuAA8//LDi4uJ08OBBffbZZ1q8eLH69evn6rJuuooVKyouLs7pUr9+/Rxt69KlS7lcHdK4ublp5syZWr58uWbPnu1oHzBggIKCgjR8+HBJ0iuvvKL27duratWq+vbbb7Vjxw5NmTJFpUqV0quvvuq0zYCAAMdjHhMTo2bNmqldu3bavXv3Ld033JiCBQvKx8cnx+t7e3urUKFCN1RD2lg6duyYlixZorNnz6ply5Y3/TXh8uXLN3X7QUFB8vf3v6m3cbcoXLjwLZve+ZtvvlHt2rV15swZzZw5Uzt37tS8efP06KOP6rXXXlNiYqJT/x9//FFxcXHau3ev3nzzTb3zzjuaNm2aU5+QkBCtWrVKR44ccWqfPn26ihcvftP36V528OBBhYeHa+XKlRo9erS2b9+u5cuXq1GjRurfv/8Nb79Xr16Ki4vT0aNH9c033+jw4cN65plncqFy3DQGt7UuXbqYNm3aOLUNHjzYBAUFOa4nJyeb7t27mxIlShgvLy9TpkwZM3bs2Ay38/7775vChQuboKAg069fP3Pp0iVHn7///ts88sgjxsvLy5QoUcJ88cUXJiwszIwZM8bR59ChQ6Z169bG19fX+Pv7m7Zt25r4+HjH8hEjRpgqVaqYqVOnmtDQUOPr62v69OljkpOTzX/+8x8THBxsChYsaN5+++0s9zttO5nZtm2badSokfHy8jJBQUGmV69e5vTp0+n299133zUhISEmLCzMGGPMkSNHTLt27UzevHlNUFCQad26tTlw4IBjvVWrVpkHH3zQ+Pj4mMDAQFOnTh1z8OBBM336dCPJ6TJ9+vQs9+FeM27cOJMvXz5z9OhRs2jRIuPh4WFiYmKMMcZs3LjRSDLjxo3LcN3U1FTH39OnTzeBgYFOy1NSUoyHh4f56quvHG3//POP6dSpk8mbN6/x9vY2Dz/8sNmzZ4/Tel9//bWpUKGC8fT0NGFhYeaDDz5wWj5hwgRTunRpY7fbTaFChcwTTzxhjLkyfq59vK8eJ3eDjF5brrZ69Wrz4IMPGk9PT1O4cGHzyiuvmMuXLzuWJyUlmQ4dOhgfHx9TuHBh89FHH5kGDRqY559/3tHn2tePESNGmNDQUOPp6WlCQkLMgAEDjDHGNGjQIN39bUzGY+Gbb74x4eHhxm63m/z585vHHnss033IaP1vv/3WSDLbtm1ztP3000+mXr16xsvLyxQrVswMGDDAnDlzxrH82LFjpkWLFo7XxtmzZ6fbN0lm0qRJpnXr1sbHx8cMHz7ccXvVq1c3drvdlCxZ0rzxxhtO92Nm94kxmY/PtPvs6vva6vmQdl8sX77clCtXzvj6+ppmzZqZY8eOZXr/3UmyGs+SzMKFCx3Xf/rpJ1OlShVjt9tNeHi4WbhwoZHkeL1atWqVkWR+/PFHEx4ebry9vU1ERIT5888/jTEm0/eDM2fOWI7JtNe6AwcOON1mmsaNG5t+/fo5rqe9Fz7yyCNO75s//fSTKVCggOnbt69p0KBB9u8oXJfmzZubokWLOr0epDl58qQxxpgPP/zQVKpUyfj4+JhixYqZvn37Oj6PpI2lqy8jRowwxqR/DhtjzKxZs4yPj49Tm9Vr8YULF8yAAQNMwYIFjd1uN3Xr1jW//vqrY/k///xjOnToYAoUKGC8vLxM6dKlzbRp04wxJl1tjCVrBKfb3LVvBvv27TMVKlQwwcHBjrZLly6Z4cOHm19//dXs37/ffPHFF8bHx8dERUU5bScgIMD06dPH7Nq1yyxevNj4+PiYKVOmOPo0b97cVKpUyWzYsMFs3rzZ1KlTx3h7ezs+HKSmpppq1aqZf/3rX2bz5s3m559/NtWrV3d6oo0YMcL4+fmZJ5980uzYscN8++23xtPT0zRr1swMGDDA/Pnnn2batGlGktm4cWOm+51VcDp79qwpUqSIefzxx8327dvNihUrTMmSJU2XLl2c9tfPz8906tTJ/PHHH2b79u3m7Nmz5v777zfdu3c327ZtMzt37jQdOnQwZcuWNRcvXjSXL182gYGB5qWXXjJ//fWX2blzp5kxY4Y5dOiQOXfunHnxxRdNxYoVTVxcnImLizPnzp3L3oN4j0hNTTUNGzY0TZo0MYUKFTJvvfWWY9nAgQONn5+f04t9Zq79sJucnGymTZtmPDw8zF9//eVob926tSlfvrxZu3at2bp1q2nWrJkpXbq0458BmzdvNnny5DEjR440u3fvNtOnTzfe3t6OwLtp0ybj5uZm5syZYw4ePGh+++03R7A7deqUiYiIML169XI83snJyblwL90+svqgeeTIEePj42P69etndu3aZRYuXGgKFCjgeMM3xpiePXuasLAw8+OPP5rt27ebxx57zPj7+2canObNm2cCAgLM0qVLzaFDh8wvv/zieP1JSEgwxYoVMyNHjnTc38akHwvfffedcXNzM8OHDzc7d+40W7duNe+8806m+3jt+idPnjRPPfWUkWR27dpljLnyTxg/Pz8zZswYs2fPHvPTTz+ZatWqma5duzrWa9q0qalatar5+eefzZYtW0yDBg2cXhuNufIBpFChQmbq1Klm37595uDBg2b58uUmICDAzJgxw+zbt8/88MMPpkSJEuaNN96wvE+yGp/GpP/QZfV8mD59uvHw8DBNmzY1mzZtMlu2bDHly5c3HTp0yPT+u5NkNzglJSWZoKAg88wzz5gdO3aYpUuXmjJlymQYnGrVqmVWr15tduzYYerVq2fq1KljjDGZvh8sWLDA8r0tTUbBadOmTSZv3rxm5syZjra098IFCxaY0qVLO9p79Ohhnn/+efP888/zYfcmSUhIMDabzbz77rtZ9hszZoxZuXKl2b9/v1mxYoUpW7as6du3rzHGmIsXL5qxY8eagIAAx1hJC1XXPocTEhJMq1atTKNGjRxt2XktHjhwoClSpIhZunSp2bFjh+nSpYvJly+fSUhIMMYY079/f1O1alWzadMmc+DAARMdHW2+/fZbY4wxv/76q+OfBHFxcY51kDmC022uS5cuxs3Nzfj6+hovLy/HfwU++uijLNfr16+f038nu3TpYsLCwpw+/LVt29a0b9/eGGPM7t27jSTz888/O5bv2rXLSHJ8OPjhhx+Mm5ubiY2NdfTZsWOHkeT478aIESOMj4+PSUpKcvRp1qyZKVGihElJSXG0lS1b1owaNSrT+keMGGHy5MljfH19HZcHH3zQGGPMlClTTL58+Zz+A7RkyRKTJ08ex9GvLl26mODgYHPx4kVHn6lTp5qyZcs6Hd24ePGi8fb2Nt9//71JSEgwkszq1aszrSmro2D4/zHzwAMPOIWkhx9+2FSuXNmp74cffuj0+J46dcoY8///zU1rz5Mnj7Hb7U5H+Pbs2WMkmZ9++snRduLECePt7e04KtWhQwfz0EMPOd3myy+/bCpUqGCMMWb+/PkmICDAaaxeLaP/Bt5Nsvqg+eqrr6Z7rkyYMMH4+fmZlJQUk5SUZDw8PMy8efMcy0+dOmV8fHwyDU4ffvihKVOmjNNR7qtdewTHmPTBJyIiwnTs2DHb+3j1WPLx8XG8frZu3drRp1OnTubZZ591Wm/dunUmT5485vz5844xvWnTJsfyvXv3Or02GnPlw/mgQYOctlOvXr10H7o+//xzExISYozJ+j65nvGZnedD2n1x9T8fJkyY4PRPuDtZdoPTpEmTTP78+c358+cdyz/99NNMjzilWbJkiZHkWC+j94P33nvPSDL//POPo+3XX391ep1bvHixMeb/g5O3t7fx9fU1Hh4eRlK6sZh2O5cuXTKFChUya9asMWfOnDH+/v7m999/JzjdRL/88ouRZBYsWHBd63311Vcmf/78jusZHfk25spz2MPDw+n1qUyZMk5nN1i9Fp85c8Z4eHiY2bNnO5ZfunTJFClSxIwePdoYY0yrVq1Mt27dMqw1syOfyBzfcboDNGrUSFu3btUvv/yiAQMGqFmzZhowYIBTn8mTJ6tGjRoqWLCg/Pz89Omnnyo2NtapT8WKFeXm5ua4HhISouPHj0uSdu3aJXd3d9WoUcOxvFy5ck5faNy1a5dCQ0MVGhrqaKtQoYLy5s2rXbt2OdpKlCjhdO59cHCwKlSooDx58ji1pd12ZsqWLautW7c6LvPnz3fUUaVKFfn6+jr61q1bV6mpqU7fgXnggQfk6enpuL5lyxb99ddf8vf3l5+fn/z8/BQUFKQLFy5o3759CgoKUteuXdWsWTO1atVK48aNU1xcXJY1wtm0adPk4+OjAwcOpDsf32azOV3v3r27tm7dqk8++URnz551+kK0v7+/43GPiYnRu+++q969e2vx4sWS/n+81qpVy7FO/vz5VbZsWcdY3LVrl+rWret0m3Xr1tXevXuVkpKihx56SGFhYbrvvvvUqVMnzZ49W+fOncvV++NOtWvXLkVERDg9ZnXr1tWZM2d05MgR7d+/X5cvX1bNmjUdywMDA1W2bNlMt9m2bVudP39e9913n3r16qWFCxcqOTn5uuraunWrmjRpcl3rpI2lLVu2aPLkySpVqpQmT57sWL5lyxbNmDHD8Zrg5+enZs2aKTU1VQcOHNDu3bvl7u6u6tWrO9YpXbq08uXLl+62rn79TNv2yJEjnbad9p2Gc+fOZXmfXM/4zM7zQZJ8fHxUqlQpx/Wr3wPuFbt371blypXl5eXlaLt6HF+tcuXKjr9DQkIk6brvr8qVKztey86ePZtuzEdFRWnr1q36/fffFRUVpW+++UZDhgxJtx0PDw8988wzmj59uubNm6cyZco41Yfcl/aedO1717VWrVqlhx56SEWLFpW/v786d+6shIQEnT171vI2Onbs6Hj8169fr9KlSysyMlKnT5+WZP1avG/fPl2+fNnpvc7Dw0M1a9Z0PPf79u2rL7/8UlWrVtW///1vbdiw4brvC/w/gtMdwNfXV6VLl1blypU1fvx4Xbx4UW+++aZj+VdffaUXXnhB3bt31w8//KCtW7eqW7du6b787OHh4XTdZrMpNTVVUvZeIIwxGS6/tj2j28nqtjOTNstQ2iUtsGVWx7X1Xx2sJCk1NVXh4eFOYWzr1q3as2ePOnToIOnKl203btyoOnXqKCoqSmXKlNHPP/+cZZ24YuPGjRozZoy++eYbRUREqEePHo5xdf/99zte4NPkzZtXpUuXVtGiRdNtK0+ePI7HvXLlyho8eLAaNWqk//znP5LkFLKudvXYyGicXBvOfvvtN82dO1chISEaPny4qlSpwhTEyvq+s9lsmb5eZPa4SFJoaKh2796tCRMmyNvbW/369VP9+vWvaxIFb2/vbPdNkzaWypUrp969e6tTp05q3769Y3lqaqp69+7t9Jrw+++/a+/evSpVqlSWY+1aGb3mvPnmm07b3r59u/bu3SsvL68s75PrGZ/ZeT5IGb82Z/WY3Y2sXheudvX9lbZOVu9b999/vyQ5/QPPbrc7XssyEhoaqtKlS6t8+fJq166dBg0apA8//FAXLlxI17d79+6aN2+eJkyYoO7du2daB3LH/fffL5vN5vTPh2sdOnRILVq0UKVKlTR//nxt2bJFEyZMkJS9CWICAwMd46Nu3bqaOnWq9u7dq6ioKEk39lqc1ta8eXMdOnRIgwYN0rFjx9SkSRO99NJL2bwXcC2C0x1oxIgR+uCDD3Ts2DFJ0rp161SnTh3169dP1apVU+nSpbVv377r2mb58uWVnJyszZs3O9p2797t9CZdoUIFxcbG6vDhw462nTt3KjExUeXLl7+xnboOFSpUcPz3Ls1PP/2kPHnyqEyZMpmuV716de3du1eFChVyCmSlS5dWYGCgo1+1atU0dOhQbdiwQZUqVdKcOXMkXQlyKSkpN2/H7mDnz59Xly5d1Lt3bzVt2lSfffaZNm3apE8++USS9PTTT+vMmTOaOHFijm/Dzc1N58+fl3RlDCQnJ+uXX35xLE9ISNCePXscY7FChQpav3690zY2bNigMmXKOI68uru7q2nTpho9erS2bdumgwcPauXKlZLu7ce7QoUK2rBhg9MHyg0bNsjf319FixZVqVKl5OHhoV9//dWxPCkpSXv37s1yu97e3mrdurXGjx+v1atXa+PGjdq+fbuk7N3flStXzvYUwJl54YUX9Pvvv2vhwoWSrrwu7NixI91rQunSpeXp6aly5copOTnZacr8v/76K1sBu3r16tq9e3eG2047Ap/VfZLV+Lxadp4PuKJcuXLatm2bLl686Gi7+n0vuzIar5GRkQoKCnL8gycn3NzclJycnOGsjxUrVlTFihX1xx9/OP7Zh5snKChIzZo104QJEzI8enTq1Clt3rxZycnJ+vDDD1W7dm2VKVPG8dkszfW8l6S9N139XpfVa3Ha69TV73WXL1/W5s2bnZ77BQsWVNeuXfXFF19o7NixmjJliqM2Sffse11OEJzuQA0bNlTFihX17rvvSrpy2sjmzZv1/fffa8+ePXr99de1adOm69pm2bJl9fDDD6tXr1765ZdftGXLFvXs2dPpP7xNmzZV5cqV1bFjR/3222/69ddf1blzZzVo0CDdKSo3U8eOHeXl5aUuXbrojz/+0KpVqzRgwAB16tRJwcHBWa5XoEABtWnTRuvWrdOBAwe0Zs0aPf/88zpy5IgOHDigoUOHauPGjTp06JB++OEHpw8eJUqU0IEDB7R161adOHHC6Y33XjdkyBClpqY6PjAUL15cH374oV5++WUdPHhQERERevHFF/Xiiy9q8ODBWr9+vQ4dOqSff/5ZU6dOdfyORRpjjOLj4xUfH68DBw5oypQp+v7779WmTRtJV/4T2KZNG/Xq1Uvr16/X77//rmeeeUZFixZ19HnxxRe1YsUKvfXWW9qzZ49mzpyp//73v47/tH333XcaP368tm7dqkOHDmnWrFlKTU11nG5WokQJ/fLLLzp48KBOnDhheYT0TpSYmJjuCGxsbKz69eunw4cPa8CAAfrzzz/1zTffaMSIERo8eLDy5Mkjf39/denSRS+//LJWrVqlHTt2qHv37sqTJ0+mR4NnzJihqVOn6o8//tD+/fv1+eefy9vbW2FhYZKu3N9r167V0aNHdeLEiQy3MWLECM2dO1cjRozQrl27tH37do0ePfq69jkgIEA9e/bUiBEjZIzRK6+8oo0bN6p///7aunWr9u7dq2+//dZxOnS5cuXUtGlTPfvss/r1118VExOjZ599Vt7e3pan8AwfPlyzZs3SG2+8oR07dmjXrl2Kiopy/LZZVveJ1fi8WnaeD/eCzMbz1Tp06KDU1FQ9++yz2rVrl77//nt98MEHkqxPybpaRu8Hfn5++uyzz7RkyRK1bNlS33//vfbv369t27Y5xunVp8tLVwJufHy8jhw5omXLlmncuHFq1KiRAgICMrzdlStXKi4ujh+GvkUmTpyolJQU1axZU/Pnz9fevXu1a9cujR8/XhERESpVqpSSk5P18ccfO57DV58KLF0ZK2fOnNGKFSt04sQJp1Nuz50753iv+/3339WvXz95eXkpMjJSkixfi319fdW3b1+9/PLLWr58uXbu3KlevXrp3Llz6tGjh6Qrr0PffPON/vrrL+3YsUPfffed43NNoUKF5O3treXLl+vvv/9ON10+MnArvkiFnMvsC6+zZ882np6eJjY21ly4cMF07drVBAYGmrx585q+ffuaIUOGOH1xNaPtXPul0ri4ONOyZUtjt9tN8eLFzaxZs3I8HbnVPlh98T63piO/VlxcnOncubMpUKCAsdvt5r777jO9evUyiYmJJj4+3jz66KMmJCTEMX318OHDHZNaXLhwwTzxxBMmb968TEd+ldWrVxs3Nzezbt26dMsiIyNN48aNHV9sjYqKMg0bNjSBgYHGw8PDFCtWzHTo0MFpUpJrp/q12+2mTJky5p133nGa3CRt+uXAwEDj7e1tmjVrlul05B4eHqZ48eLm/fffdyxbt26dadCggcmXL5/x9vY2lStXdpqJcvfu3aZ27drG29v7rp2O/Or7Oe2SNjtlTqYjr1mzphkyZIijz9WvHwsXLjS1atUyAQEBxtfX19SuXdvpy/cbN240lStXNna7PcvpyOfPn2+qVq1qPD09TYECBczjjz+e6T5m9qXsQ4cOGXd3d8fj/euvv5qHHnrI+Pn5GV9fX1O5cmWn2fqOHTtmmjdvbux2uwkLCzNz5swxhQoVMpMnT3b00TVTXqdZvny5Y4bSgIAAU7NmTcfMeVndJ1bjM7PpyDN7PmR0X6RNw303yGo8X/vY/PTTT6Zy5crG09PThIeHmzlz5hhJjunG0yaHSJtu2hhjYmJinF4Hsno/2LRpk3nyySdNoUKFjLu7u8mfP79p1qyZ+fLLL9NNR552cXNzM8WKFTO9evUyx48fd2zL6r2QySFuvmPHjpn+/fubsLAw4+npaYoWLWpat25tVq1aZYwx5qOPPjIhISGO592sWbPSjZ8+ffqY/Pnzp5uO/OoxkC9fPtOgQQOzcuVKp9u3ei0+f/68GTBggONzzbXTkb/11lumfPnyxtvb2wQFBZk2bdqY/fv3O5Z/+umnJjQ01OTJk4exlA02Y+6xE5wBALnu7NmzKlq0qD788EPHfzrvVkeOHFFoaKh+/PHH656sAref2bNnq1u3bkpMTMzR9+gA3DvcXV0AAODOExMToz///FM1a9ZUYmKiRo4cKUl35alhK1eu1JkzZ/TAAw8oLi5O//73v1WiRAnVr1/f1aUhB2bNmqX77rtPRYsW1e+//65XXnlF7dq1IzQBsERwAgDkyAcffKDdu3fL09NT4eHhWrdunQoUKODqsnLd5cuX9eqrr2r//v3y9/dXnTp1NHv27HSz1OHOEB8fr+HDhys+Pl4hISFq27at3nnnHVeXBeAOwKl6AAAAAGCBWfUAAAAAwALBCQAAAAAsEJwAAAAAwALBCQAAAAAsEJwAAAAAwALBCQBwT1u9erVsNptOnTqV7XVKlCihsWPH3rSaAAC3H4ITAOC21rVrV9lsNvXp0yfdsn79+slms6lr1663vjAAwD2F4AQAuO2Fhobqyy+/1Pnz5x1tFy5c0Ny5c1W8eHEXVgYAuFcQnAAAt73q1aurePHiWrBggaNtwYIFCg0NVbVq1RxtFy9e1MCBA1WoUCF5eXnpX//6lzZt2uS0raVLl6pMmTLy9vZWo0aNdPDgwXS3t2HDBtWvX1/e3t4KDQ3VwIEDdfbs2Uzre+ONN1S8eHHZ7XYVKVJEAwcOvPGdBgDcVghOAIA7Qrdu3TR9+nTH9WnTpql79+5Off79739r/vz5mjlzpn777TeVLl1azZo10z///CNJOnz4sB5//HG1aNFCW7duVc+ePTVkyBCnbWzfvl3NmjXT448/rm3btikqKkrr16/Xc889l2FdX3/9tcaMGaNPPvlEe/fu1aJFi/TAAw/k8t4DAFyN4AQAuCN06tRJ69ev18GDB3Xo0CH99NNPeuaZZxzLz549q0mTJun9999X8+bNVaFCBX366afy9vbW1KlTJUmTJk3SfffdpzFjxqhs2bLq2LFjuu9Hvf/+++rQoYMGDRqk+++/X3Xq1NH48eM1a9YsXbhwIV1dsbGxKly4sJo2barixYurZs2a6tWr1029LwAAtx7BCQBwRyhQoIBatmypmTNnavr06WrZsqUKFCjgWL5v3z5dvnxZdevWdbR5eHioZs2a2rVrlyRp165dql27tmw2m6NPRESE0+1s2bJFM2bMkJ+fn+PSrFkzpaam6sCBA+nqatu2rc6fP6/77rtPvXr10sKFC5WcnJzbuw8AcDF3VxcAAEB2de/e3XHK3IQJE5yWGWMkySkUpbWntaX1yUpqaqp69+6d4feUMpqIIjQ0VLt371Z0dLR+/PFH9evXT++//77WrFkjDw+P7O0YAOC2xxEnAMAd4+GHH9alS5d06dIlNWvWzGlZ6dKl5enpqfXr1zvaLl++rM2bN6t8+fKSpAoVKujnn392Wu/a69WrV9eOHTtUunTpdBdPT88M6/L29lbr1q01fvx4rV69Whs3btT27dtzY5cBALcJjjgBAO4Ybm5ujtPu3NzcnJb5+vqqb9++evnllxUUFKTixYtr9OjROnfunHr06CFJ6tOnjz788EMNHjxYvXv3dpyWd7VXXnlFtWvXVv/+/dWrVy/5+vpq165dio6O1scff5yuphkzZiglJUW1atWSj4+PPv/8c3l7eyssLOzm3AkAAJfgiBMA4I4SEBCggICADJe99957euKJJ9SpUydVr15df/31l77//nvly5dP0pVT7ebPn6/FixerSpUqmjx5st59912nbVSuXFlr1qzR3r17Va9ePVWrVk2vv/66QkJCMrzNvHnz6tNPP1XdunVVuXJlrVixQosXL1b+/Plzd8cBAC5lM9k54RsAAAAA7mEccQIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAACwQnAAAAALBAcAIAAAAAC/8HNDe9oC0vHSYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import f1_score, recall_score, precision_score, accuracy_score, roc_auc_score, roc_curve, auc\n",
    "\n",
    "# Calculate metrics for each model\n",
    "accuracy_scores = [\n",
    "                   accuracy_score(y_test, rf_preds), accuracy_score(y_test, xgb_preds), accuracy_score(y_test, logreg_preds),\n",
    "                   accuracy_score(y_test, lgbm_preds), accuracy_score(y_test, catboost_preds)\n",
    "                  ]\n",
    "\n",
    "\n",
    "precision_scores = [\n",
    "                    precision_score(y_test, rf_preds), precision_score(y_test, xgb_preds), precision_score(y_test, logreg_preds),\n",
    "                    precision_score(y_test, lgbm_preds), precision_score(y_test, catboost_preds)\n",
    "                   ]\n",
    "\n",
    "\n",
    "f1_scores = [\n",
    "            f1_score(y_test, rf_preds), f1_score(y_test, xgb_preds), f1_score(y_test, logreg_preds),\n",
    "            f1_score(y_test, lgbm_preds), f1_score(y_test, catboost_preds)\n",
    "            ]\n",
    "\n",
    "\n",
    "recalls = [\n",
    "           recall_score(y_test, rf_preds), recall_score(y_test, xgb_preds), recall_score(y_test, logreg_preds),\n",
    "           recall_score(y_test, lgbm_preds), recall_score(y_test, catboost_preds)\n",
    "          ]\n",
    "\n",
    "\n",
    "roc_aucs = [\n",
    "            roc_auc_score(y_test, rf_model.predict_proba(X_test)[:, 1]), \n",
    "            roc_auc_score(y_test, xgb_model.predict_proba(X_test)[:, 1]), \n",
    "            roc_auc_score(y_test, logreg_model.predict_proba(X_test)[:, 1]), \n",
    "            roc_auc_score(y_test, lgbm_model.predict_proba(X_test)[:, 1]), \n",
    "            roc_auc_score(y_test, catboost_model.predict_proba(X_test)[:, 1])\n",
    "           ]\n",
    "\n",
    "# Models names\n",
    "models = ['Random Forest', 'XGBoost', 'Logistic Regression', 'LightGBM', 'CatBoost']\n",
    "\n",
    "# Barplot for Accuracy\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, accuracy_scores, color='purple')\n",
    "plt.xlabel('Models')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Accuracy Comparison Across Models')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "# Scatter Plot for Recall\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(models, recalls, color='green', s=100, edgecolor='black', label='Recall')\n",
    "plt.xlabel('Models')\n",
    "plt.ylabel('Recall')\n",
    "plt.title('Recall Score Comparison Across Models')\n",
    "plt.show()\n",
    "\n",
    "# Barplot for Precision\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, precision_scores, color='orange')\n",
    "plt.xlabel('Models')\n",
    "plt.ylabel('Precision')\n",
    "plt.title('Precision Comparison Across Models')\n",
    "plt.show()\n",
    "\n",
    "# Barplot for F1 Score\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, f1_scores, color='blue')\n",
    "plt.xlabel('Models')\n",
    "plt.ylabel('F1 Score')\n",
    "plt.title('F1 Score Comparison Across Models')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "# 2. ROC Curve Plot\n",
    "plt.figure(figsize=(10, 6))\n",
    "for model, model_name in zip([rf_model, xgb_model, logreg_model, lgbm_model, catboost_model], models):\n",
    "    fpr, tpr, thresholds = roc_curve(y_test, model.predict_proba(X_test)[:, 1])\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    plt.plot(fpr, tpr, label=f'{model_name} (AUC = {roc_auc:.4f})')\n",
    "    \n",
    "plt.plot([0, 1], [0, 1], linestyle='--', color='gray')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('ROC Curve Comparison Across Models')\n",
    "plt.legend(loc='lower right')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db3cf877-6e58-43bc-b1f4-302e1735f649",
   "metadata": {},
   "source": [
    "### from the accuracy metrics plot it seems like random forest is performing the best in our baseline model scores again the recall is mostly our important target here but at the same time we have to have a close precision to the score of our recall so that we classify the minority because from this result it is clearly not handling the imbalance well as we see in the recall most models are at 0.2 while 0.4 for random forest now lets try improving this baseline score with hyperparameter tuning"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "235c51a0-cd39-4bee-aaf4-85f33343842a",
   "metadata": {},
   "source": [
    "# **Performing Hyperparameter tunings and Stratified Cross Validation Technique**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe4f6135-30d4-4885-bf25-625c8c9404f1",
   "metadata": {},
   "source": [
    "- ### **first we will be signifying class ratio for out xg_boost since it does not have a class_balance paramaeter this is so that xgboost can put weights to the minority class**\n",
    "- ### **we will split our dataset again into a subset into training in our hyperparameter space to reduce the computational time 20% of out 500k which will be around 100k**\n",
    "- ### **our cross validation score metric will be f1_score, again using accuracy as metric score will be inaccurate and biased because our dataset is very heavily imbalanced choosing f1_score gives more balance but retains high recall to correctly classify the minority class**\n",
    "- ### **We will be using a stratified cross validation technique this is very important to make sure our folds each contain the minority class so our model can learn better**\n",
    "- ### **finally we will be using random search for tuning as this will be computationally faster and still have good results**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5be04dbe-b335-4bd9-8711-3dcb7e7a5fca",
   "metadata": {},
   "source": [
    "### The class weights account for the class imbalance in order to adjust the model because a higher ratio of healthy people compared those with heart disease will lead to the model being biased or favoring the majority class and it will just start answering 'no' heart disease to everything this leads to the model performing badly as we see on our baseline model the recall is very bad (0.2 score) thus in order to improve this we will have to use some strategy either by giving the models **Class weights or a Resampling technique**\n",
    "\n",
    "\n",
    "### **The class weight will take into account of the minority class by giving it a higher value of importance signifying the parameter class_weight=balanced will automatically adjust the class imbalance based on their frequency**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df163317-757a-4a35-8f68-2ca0441a9c07",
   "metadata": {},
   "source": [
    "# **CLASS WEIGHTS**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b59890d3-287c-433d-bcc3-5d488531d61b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class ratio: 16.84963674104826\n"
     ]
    }
   ],
   "source": [
    "# Calculate class ratio for xgboost class weight balancing\n",
    "class_ratio = sum(y_train == 0) / sum(y_train == 1)\n",
    "print(f'Class ratio: {class_ratio}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6f437750-7cfd-4fc1-8910-71f8c8c3cb82",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the dataset with stratified split\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train_sub, X_test, y_train_sub, y_test = train_test_split(\n",
    "    X_train, y_train, test_size=0.2, random_state=42, stratify=y_train\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0beb5d4e-ac2a-4034-b08e-f13f9609823e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running RandomizedSearchCV for RandomForest...\n",
      "Fitting 5 folds for each of 50 candidates, totalling 250 fits\n",
      "Best Hyperparameters for RandomForest: {'class_weight': 'balanced', 'max_depth': 14, 'min_samples_leaf': 10, 'min_samples_split': 5, 'n_estimators': 234}\n",
      "Cross-validation F1 Score (best_score_): 0.36285022324120547\n",
      "Final F1 Score for RandomForest: 0.36305410416315526\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for XGBoost...\n",
      "Fitting 5 folds for each of 50 candidates, totalling 250 fits\n",
      "Best Hyperparameters for XGBoost: {'colsample_bytree': 0.9325398470083344, 'learning_rate': 0.1039498941564189, 'max_depth': 9, 'n_estimators': 369, 'scale_pos_weight': 16.84963674104826, 'subsample': 0.9181815987569262}\n",
      "Cross-validation F1 Score (best_score_): 0.3654280485038538\n",
      "Final F1 Score for XGBoost: 0.3630663768600568\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for LogisticRegression...\n",
      "Fitting 5 folds for each of 50 candidates, totalling 250 fits\n",
      "Best Hyperparameters for LogisticRegression: {'C': 0.34488521115218396, 'class_weight': 'balanced', 'penalty': 'l1', 'solver': 'liblinear'}\n",
      "Cross-validation F1 Score (best_score_): 0.31746350532546075\n",
      "Final F1 Score for LogisticRegression: 0.3213466518682945\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for LightGBM...\n",
      "Fitting 5 folds for each of 50 candidates, totalling 250 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\anaconda3\\Lib\\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"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Hyperparameters for LightGBM: {'class_weight': 'balanced', 'learning_rate': 0.07174815096277165, 'max_depth': 14, 'min_data_in_leaf': 41, 'n_estimators': 352, 'num_leaves': 93}\n",
      "Cross-validation F1 Score (best_score_): 0.32954361815185956\n",
      "Final F1 Score for LightGBM: 0.3294134727061556\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for CatBoost...\n",
      "Fitting 5 folds for each of 50 candidates, totalling 250 fits\n",
      "Best Hyperparameters for CatBoost: {'class_weights': [1.0, 3.0], 'depth': 7, 'iterations': 655, 'l2_leaf_reg': 3.9155696350925635, 'learning_rate': 0.09832802589188683}\n",
      "Cross-validation F1 Score (best_score_): 0.47255433412195585\n",
      "Final F1 Score for CatBoost: 0.48232584001906426\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#IMPORTING\n",
    "from sklearn.model_selection import train_test_split\n",
    "from imblearn.pipeline import Pipeline as imPipeline\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from imblearn.combine import SMOTEENN\n",
    "from sklearn.model_selection import RandomizedSearchCV, StratifiedKFold\n",
    "from sklearn.metrics import make_scorer, f1_score\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from lightgbm import LGBMClassifier\n",
    "from catboost import CatBoostClassifier\n",
    "from scipy.stats import randint, uniform\n",
    "from sklearn.model_selection import train_test_split, StratifiedKFold, RandomizedSearchCV\n",
    "from sklearn.metrics import make_scorer, recall_score\n",
    "from scipy.stats import randint, uniform\n",
    "\n",
    "\n",
    "# hyperparameter space \n",
    "#Adding our class weight balanced to account for the class imbalance\n",
    "param_distributions = {\n",
    "    'RandomForest': {\n",
    "        'n_estimators': randint(100, 700), \n",
    "        'max_depth': randint(5, 15),\n",
    "        'min_samples_split': randint(2, 10),\n",
    "        'min_samples_leaf': randint(2, 20),\n",
    "        'class_weight': ['balanced'],  \n",
    "   },\n",
    "    'XGBoost': {\n",
    "        'n_estimators': randint(100, 700),  \n",
    "        'learning_rate': uniform(0.01, 0.1),\n",
    "        'max_depth': randint(4, 10),\n",
    "       'scale_pos_weight': [class_ratio], \n",
    "        'subsample': uniform(0.7, 0.3),\n",
    "        'colsample_bytree': uniform(0.7, 0.3)\n",
    "    },\n",
    "    'LogisticRegression': {\n",
    "        'C': uniform(0.001, 10),\n",
    "        'penalty': ['l2', 'l1'],\n",
    "        'solver': ['liblinear', 'saga'],\n",
    "        'class_weight': ['balanced'],  \n",
    "   },\n",
    "    'LightGBM': {\n",
    "       'n_estimators': randint(100, 700), \n",
    "        'learning_rate': uniform(0.01, 0.1),\n",
    "        'max_depth': randint(5, 15),\n",
    "        'num_leaves': randint(50, 100),\n",
    "        'min_data_in_leaf': randint(20, 500),\n",
    "        'class_weight': ['balanced'],  \n",
    "    },\n",
    "    'CatBoost': {\n",
    "        'iterations': randint(100, 700),  \n",
    "        'learning_rate': uniform(0.01, 0.1),\n",
    "        'depth': randint(6, 8),\n",
    "        'l2_leaf_reg': uniform(1, 7),\n",
    "        'class_weights': [[1.0, 3.0]],  \n",
    "    }\n",
    "}\n",
    "\n",
    "# Defining models\n",
    "models = {\n",
    "    'RandomForest': RandomForestClassifier( random_state=42),\n",
    "    'XGBoost': XGBClassifier(\n",
    "        random_state=42, \n",
    "        eval_metric='logloss', \n",
    "        device='cuda' \n",
    "     \n",
    "    ),\n",
    "    'LogisticRegression': LogisticRegression( random_state=42),\n",
    "    'LightGBM': LGBMClassifier(\n",
    "        random_state=42, \n",
    "        device='gpu', \n",
    "        verbose=-1\n",
    "    ),\n",
    "    'CatBoost': CatBoostClassifier(\n",
    "      random_state=42, \n",
    "        verbose=0, \n",
    "\n",
    "    )\n",
    "}\n",
    "# Stratified\n",
    "cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
    "scorer = make_scorer(f1_score, average='binary')\n",
    "\n",
    "# doing randomsearchCV passing our stratified fold and our f1-score metric to be used\n",
    "best_model = {}\n",
    "for model_name, model in models.items():\n",
    "    print(f\"Running RandomizedSearchCV for {model_name}...\")\n",
    "\n",
    "    random_search = RandomizedSearchCV(\n",
    "        estimator=model,\n",
    "        param_distributions=param_distributions[model_name],\n",
    "        scoring=scorer,  # Prioritizing F1 score\n",
    "        n_iter=50,  # Adjust n_iter for quicker tuning (personally choose between 40-70)\n",
    "        cv=cv, #stratified cv\n",
    "        verbose=1, \n",
    "        random_state=42,\n",
    "        n_jobs=7  # Use parallelization can use (-1 to use all of your cores)\n",
    "    )\n",
    "\n",
    "    # Fit on the subset of 100k data\n",
    "    random_search.fit(X_train_sub, y_train_sub)\n",
    "    best_model[model_name] = {\n",
    "        'model': random_search.best_estimator_,\n",
    "        'best_score': random_search.best_score_,  # Cross-validation F1 score\n",
    "        'best_params': random_search.best_params_  # Best hyperparameters\n",
    "    }\n",
    "\n",
    "    # Print best hyperparameters for the model and the cross validation f1 score \n",
    "    print(f\"Best Hyperparameters for {model_name}: {random_search.best_params_}\")\n",
    "    print(f\"Cross-validation F1 Score (best_score_): {random_search.best_score_}\")\n",
    "\n",
    "    # Test final model on original X_test and y_test (no resampling)\n",
    "    final_predictions = best_model[model_name]['model'].predict(X_test)\n",
    "\n",
    "    # Calculate final F1 score for the model\n",
    "    final_f1 = f1_score(y_test, final_predictions)\n",
    "    print(f\"Final F1 Score for {model_name}: {final_f1}\")\n",
    "    print(\"-\" * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faa01ff9-6e7f-4445-b0e8-359fb73efc84",
   "metadata": {},
   "source": [
    "## Now that we have completed our hyperparameter tuning lets test it on our test data and examine the results!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "955676e3-ba17-403a-9e28-e2617503bbe8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training the best RandomForest model on the full training set...\n",
      "Metrics for RandomForest:\n",
      " - Accuracy: 0.8664\n",
      " - Recall: 0.7922\n",
      " - Precision: 0.2667\n",
      " - F1 Score: 0.3991\n",
      " - ROC AUC: 0.9148559527384187\n",
      "\n",
      "Training the best XGBoost model on the full training set...\n",
      "Metrics for XGBoost:\n",
      " - Accuracy: 0.8746\n",
      " - Recall: 0.8477\n",
      " - Precision: 0.2889\n",
      " - F1 Score: 0.4310\n",
      " - ROC AUC: 0.9407210558068914\n",
      "\n",
      "Training the best LogisticRegression model on the full training set...\n",
      "Metrics for LogisticRegression:\n",
      " - Accuracy: 0.8334\n",
      " - Recall: 0.7037\n",
      " - Precision: 0.2081\n",
      " - F1 Score: 0.3212\n",
      " - ROC AUC: 0.8623349883023396\n",
      "\n",
      "Training the best LightGBM model on the full training set...\n",
      "Metrics for LightGBM:\n",
      " - Accuracy: 0.8386\n",
      " - Recall: 0.8042\n",
      " - Precision: 0.2305\n",
      " - F1 Score: 0.3583\n",
      " - ROC AUC: 0.9081465978573475\n",
      "\n",
      "Training the best CatBoost model on the full training set...\n",
      "Metrics for CatBoost:\n",
      " - Accuracy: 0.9429\n",
      " - Recall: 0.5109\n",
      " - Precision: 0.4905\n",
      " - F1 Score: 0.5005\n",
      " - ROC AUC: 0.8839544522832599\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, recall_score, precision_score, f1_score, roc_auc_score\n",
    "\n",
    "# Iterate through the models stored in the best_model dictionary\n",
    "for model_name, details in best_model.items():\n",
    "    print(f\"Training the best {model_name} model on the full training set...\")\n",
    "\n",
    "    # Access the best model from RandomizedSearchCV\n",
    "    model = details['model']\n",
    "\n",
    "    # Train the model on the full training dataset\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    # Make predictions on the test dataset\n",
    "    y_pred = model.predict(X_test)\n",
    "    y_pred_proba = model.predict_proba(X_test)[:, 1] if hasattr(model, \"predict_proba\") else None\n",
    "\n",
    "    # Calculate metrics\n",
    "    accuracy = accuracy_score(y_test, y_pred)\n",
    "    recall = recall_score(y_test, y_pred)\n",
    "    precision = precision_score(y_test, y_pred)\n",
    "    f1 = f1_score(y_test, y_pred)\n",
    "    roc_auc = roc_auc_score(y_test, y_pred_proba) if y_pred_proba is not None else \"N/A\"\n",
    "\n",
    "    # Print metrics\n",
    "    print(f\"Metrics for {model_name}:\")\n",
    "    print(f\" - Accuracy: {accuracy:.4f}\")\n",
    "    print(f\" - Recall: {recall:.4f}\")\n",
    "    print(f\" - Precision: {precision:.4f}\")\n",
    "    print(f\" - F1 Score: {f1:.4f}\")\n",
    "    print(f\" - ROC AUC: {roc_auc if roc_auc != 'N/A' else 'Not Applicable'}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa6a6f66-56a2-4aee-84f6-5aed1d8a76c7",
   "metadata": {},
   "source": [
    "### Now as we can see in the result the recall became higher due to adjusting the class weights it went from the baseline of 0.2 up to 0.70 but the **precision** dropped extremely what does this mean? the reason behind this is that the model is that the model now game much more importance to the minority class and that its overclassifying most of the cases answering it as 'yes' gaining much more false positive(a person has no heart disease but the model answered 'yes')\n",
    "\n",
    "### This is a clear sign of overfitting to the minority class as such since we see that class weight is effective in increasing the **recall score** which is our main target we just need to find the right class weight so my strategy  is its learning too much from the minority cldue to **(class_weights=balanced)** instead of automatically calcualting the class weight lets give a class weight manually and search which is the best one in there\n",
    "\n",
    "### So far Xgboost is the best model we have right now  followed by random forest and lightgbm , logistic regression and catboost is performing the worst as we talked about linear models doesnt capture all of the relationship "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d47c0cb5-6595-46a2-9e58-6089a0e7ea1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running RandomizedSearchCV for RandomForest...\n",
      "Fitting 3 folds for each of 55 candidates, totalling 165 fits\n",
      "Best Hyperparameters for RandomForest: {'class_weight': {0: 1, 1: 6.5}, 'max_depth': 22, 'min_samples_leaf': 2, 'min_samples_split': 7, 'n_estimators': 610}\n",
      "Test F1 Score for RandomForest: 0.5055\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for XGBoost...\n",
      "Fitting 3 folds for each of 55 candidates, totalling 165 fits\n",
      "Best Hyperparameters for XGBoost: {'colsample_bytree': 0.7469926038510866, 'learning_rate': 0.1323306320976562, 'max_depth': 7, 'n_estimators': 847, 'scale_pos_weight': 3.392061225704068, 'subsample': 0.7099098641033557}\n",
      "Test F1 Score for XGBoost: 0.4896\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for LogisticRegression...\n",
      "Fitting 3 folds for each of 55 candidates, totalling 165 fits\n",
      "Best Hyperparameters for LogisticRegression: {'C': 0.46675663213615426, 'class_weight': {0: 1, 1: 4}, 'max_iter': 1000, 'penalty': 'l1', 'solver': 'saga'}\n",
      "Test F1 Score for LogisticRegression: 0.4707\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for LightGBM...\n",
      "Fitting 3 folds for each of 55 candidates, totalling 165 fits\n",
      "Best Hyperparameters for LightGBM: {'class_weight': {0: 1, 1: 4}, 'learning_rate': 0.07334772679288173, 'max_depth': 22, 'min_data_in_leaf': 39, 'n_estimators': 430, 'num_leaves': 147}\n",
      "Test F1 Score for LightGBM: 0.4895\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for CatBoost...\n",
      "Fitting 3 folds for each of 55 candidates, totalling 165 fits\n",
      "Best Hyperparameters for CatBoost: {'class_weights': [1.0, 3.0], 'depth': 9, 'iterations': 745, 'l2_leaf_reg': 5.565345704829102, 'learning_rate': 0.07334772679288173}\n",
      "Test F1 Score for CatBoost: 0.4845\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import StratifiedKFold, train_test_split, RandomizedSearchCV\n",
    "from sklearn.metrics import make_scorer, precision_recall_curve, auc, f1_score\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from xgboost import XGBClassifier\n",
    "from lightgbm import LGBMClassifier\n",
    "from catboost import CatBoostClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from scipy.stats import randint, uniform\n",
    "\n",
    "\n",
    "# now we are gonna try manual class weights we have also increased the n_estimators a bit now lets see how this will turn out\n",
    "param_distributions = { \n",
    "    'RandomForest': { \n",
    "        'n_estimators': randint(100, 1000),\n",
    "        'max_depth': randint(3, 30),\n",
    "        'min_samples_split': randint(2, 20),\n",
    "        'min_samples_leaf': randint(1, 20),\n",
    "        'class_weight': [None,'balanced', {0: 1, 1: 3}, {0: 1, 1: 5}, {0: 1, 1: 6.5}], \n",
    "    },\n",
    "    'XGBoost': {\n",
    "        'n_estimators': randint(100, 1000),\n",
    "        'learning_rate': uniform(0.01, 0.20),\n",
    "        'max_depth': randint(3, 10),\n",
    "        'scale_pos_weight': uniform(3, 17),\n",
    "        'subsample': uniform(0.5, 0.4),\n",
    "        'colsample_bytree': uniform(0.5, 0.4),\n",
    "    },\n",
    "    'LogisticRegression': {\n",
    "        'C': uniform(0.0001, 10),\n",
    "        'penalty': ['l1', 'l2'],\n",
    "        'solver': ['liblinear', 'saga'],\n",
    "        'class_weight': [None, 'balanced', {0: 1, 1: 3}, {0: 1, 1: 4}, {0: 1, 1: 5}],\n",
    "        'max_iter': [100, 300, 500, 1000],\n",
    "    },\n",
    "    'LightGBM': {\n",
    "        'n_estimators': randint(100, 1000),\n",
    "        'learning_rate': uniform(0.01, 0.29),\n",
    "        'max_depth': randint(3, 30),\n",
    "        'num_leaves': randint(20, 150),\n",
    "        'min_data_in_leaf': randint(10, 250),\n",
    "        'class_weight': [None, 'balanced', {0: 1, 1: 2}, {0: 1, 1: 4}, {0: 1, 1: 6}],\n",
    "    },\n",
    "    'CatBoost': {\n",
    "        'iterations': randint(100, 1000),\n",
    "        'learning_rate': uniform(0.01, 0.29),\n",
    "        'depth': randint(4, 10),\n",
    "        'l2_leaf_reg': uniform(1, 10),\n",
    "        'class_weights': [[1.0, 3.0], [1.0, 5.0], [1.0, 6.0]],\n",
    "    }\n",
    "}\n",
    "\n",
    "f1_scorer = make_scorer(f1_score)\n",
    "\n",
    "# Models\n",
    "models = {\n",
    "    'RandomForest': RandomForestClassifier(random_state=42),\n",
    "    'XGBoost': XGBClassifier(random_state=42, eval_metric='logloss'),\n",
    "    'LogisticRegression': LogisticRegression(random_state=42),\n",
    "    'LightGBM': LGBMClassifier(random_state=42, device='gpu', verbose=-1),\n",
    "    'CatBoost': CatBoostClassifier(random_state=42, verbose=0)\n",
    "}\n",
    "\n",
    "cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n",
    "\n",
    "# Randomized Search with F1 score as the metric\n",
    "best_model_2 = {}\n",
    "for model_name, model in models.items():\n",
    "    print(f\"Running RandomizedSearchCV for {model_name}...\")\n",
    "    \n",
    "    random_search = RandomizedSearchCV(\n",
    "        estimator=model,\n",
    "        param_distributions=param_distributions[model_name],\n",
    "        scoring=f1_scorer,\n",
    "        n_iter=55,\n",
    "        cv=cv,\n",
    "        verbose=1,\n",
    "        random_state=42,\n",
    "        n_jobs=7\n",
    "    )\n",
    "    \n",
    "    random_search.fit(X_train_sub, y_train_sub)\n",
    "    \n",
    "    best_model_2[model_name] = {\n",
    "        'model': random_search.best_estimator_,\n",
    "        'best_score': random_search.best_score_,\n",
    "        'best_params': random_search.best_params_\n",
    "    }\n",
    "    \n",
    "    # F1 score on the test set\n",
    "    test_predictions = best_model_2[model_name]['model'].predict(X_test)\n",
    "    test_f1_score = f1_score(y_test, test_predictions)\n",
    "    \n",
    "    \n",
    "    print(f\"Best Hyperparameters for {model_name}: {random_search.best_params_}\")\n",
    "    print(f\"Test F1 Score for {model_name}: {test_f1_score:.4f}\")\n",
    "    print(\"-\" * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f703fffc-78d2-48d9-9403-c2641f4372f2",
   "metadata": {},
   "source": [
    "## Looking at the average f1_score it was a success!! now lets check the result on our test data and see how it improved"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "f3891172-8dee-402e-9b60-f07eeddd6029",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training the best RandomForest model on the full training set...\n",
      "Metrics for RandomForest:\n",
      " - Accuracy: 0.9609\n",
      " - Recall: 0.7817\n",
      " - Precision: 0.6199\n",
      " - F1 Score: 0.6915\n",
      " - ROC AUC: 0.9760341758142527\n",
      "\n",
      "Training the best XGBoost model on the full training set...\n",
      "Metrics for XGBoost:\n",
      " - Accuracy: 0.9494\n",
      " - Recall: 0.5699\n",
      " - Precision: 0.5464\n",
      " - F1 Score: 0.5579\n",
      " - ROC AUC: 0.9199166953417949\n",
      "\n",
      "Training the best LogisticRegression model on the full training set...\n",
      "Metrics for LogisticRegression:\n",
      " - Accuracy: 0.9386\n",
      " - Recall: 0.4873\n",
      " - Precision: 0.4554\n",
      " - F1 Score: 0.4709\n",
      " - ROC AUC: 0.861478791209559\n",
      "\n",
      "Training the best LightGBM model on the full training set...\n",
      "Metrics for LightGBM:\n",
      " - Accuracy: 0.9454\n",
      " - Recall: 0.5709\n",
      " - Precision: 0.5110\n",
      " - F1 Score: 0.5393\n",
      " - ROC AUC: 0.9261127590269712\n",
      "\n",
      "Training the best CatBoost model on the full training set...\n",
      "Metrics for CatBoost:\n",
      " - Accuracy: 0.9453\n",
      " - Recall: 0.5234\n",
      " - Precision: 0.5113\n",
      " - F1 Score: 0.5173\n",
      " - ROC AUC: 0.893150817694907\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, recall_score, precision_score, f1_score, roc_auc_score\n",
    "\n",
    "for model_name, details in best_model_3.items():\n",
    "    print(f\"Training the best {model_name} model on the full training set...\")\n",
    "\n",
    "    # Access the best model from RandomizedSearchCV\n",
    "    model = details['model']\n",
    "\n",
    "    # Train the model on the full training dataset\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    # Make predictions on the test dataset\n",
    "    y_pred = model.predict(X_test)\n",
    "    y_pred_proba = model.predict_proba(X_test)[:, 1] if hasattr(model, \"predict_proba\") else None\n",
    "\n",
    "    # Calculate metrics\n",
    "    accuracy = accuracy_score(y_test, y_pred)\n",
    "    recall = recall_score(y_test, y_pred)\n",
    "    precision = precision_score(y_test, y_pred)\n",
    "    f1 = f1_score(y_test, y_pred)\n",
    "    roc_auc = roc_auc_score(y_test, y_pred_proba) if y_pred_proba is not None else \"N/A\"\n",
    "\n",
    "    # Print metrics\n",
    "    print(f\"Metrics for {model_name}:\")\n",
    "    print(f\" - Accuracy: {accuracy:.4f}\")\n",
    "    print(f\" - Recall: {recall:.4f}\")\n",
    "    print(f\" - Precision: {precision:.4f}\")\n",
    "    print(f\" - F1 Score: {f1:.4f}\")\n",
    "    print(f\" - ROC AUC: {roc_auc if roc_auc != 'N/A' else 'Not Applicable'}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bffaf00b-89a7-4477-97a9-8cf09f29cedb",
   "metadata": {},
   "source": [
    "## **Examining the results**\n",
    "\n",
    "### a very good improvement of our model as we see in the metrics above now it gained alot of precision as we talked about earlier it was simply overfitting to the minority class thus we have resorted to manual class weights and it did work random forest have such a good recall score and decent precision just what we are aiming for as for the rest they much more became decent also xgboost earlier was the better model now it is simply decent the same goes for the logistic, lightgbm and catboost..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72914a77-5476-4915-8107-402b6efa689e",
   "metadata": {},
   "source": [
    "## now i will try to do one last hyper parameter tuning with some little changes on the class weights expanding options for the tuning lets see if there will be some minor improvements!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "624d58a6-9bdc-48b4-a9f1-a908b61a6cda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running RandomizedSearchCV for RandomForest...\n",
      "Fitting 5 folds for each of 60 candidates, totalling 300 fits\n",
      "Best Hyperparameters for RandomForest: {'class_weight': {0: 1, 1: 6}, 'max_depth': 20, 'min_samples_leaf': 2, 'min_samples_split': 4, 'n_estimators': 819}\n",
      "Test F1 Score for RandomForest: 0.5142\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for XGBoost...\n",
      "Fitting 5 folds for each of 60 candidates, totalling 300 fits\n",
      "Best Hyperparameters for XGBoost: {'colsample_bytree': 0.7469926038510866, 'learning_rate': 0.1323306320976562, 'max_depth': 7, 'n_estimators': 847, 'scale_pos_weight': 4.915123650745484, 'subsample': 0.7099098641033557}\n",
      "Test F1 Score for XGBoost: 0.4850\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for LogisticRegression...\n",
      "Fitting 5 folds for each of 60 candidates, totalling 300 fits\n",
      "Best Hyperparameters for LogisticRegression: {'C': 2.9349817471803816, 'class_weight': {0: 1, 1: 4}, 'max_iter': 500, 'penalty': 'l1', 'solver': 'saga'}\n",
      "Test F1 Score for LogisticRegression: 0.4707\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for LightGBM...\n",
      "Fitting 5 folds for each of 60 candidates, totalling 300 fits\n",
      "Best Hyperparameters for LightGBM: {'class_weight': {0: 1, 1: 6}, 'learning_rate': 0.16081972614156514, 'max_depth': 12, 'min_data_in_leaf': 13, 'n_estimators': 921, 'num_leaves': 63}\n",
      "Test F1 Score for LightGBM: 0.4973\n",
      "--------------------------------------------------\n",
      "Running RandomizedSearchCV for CatBoost...\n",
      "Fitting 5 folds for each of 60 candidates, totalling 300 fits\n",
      "Best Hyperparameters for CatBoost: {'class_weights': [1.0, 4.0], 'depth': 9, 'iterations': 826, 'l2_leaf_reg': 6.208342600258237, 'learning_rate': 0.2887398870613112}\n",
      "Test F1 Score for CatBoost: 0.4974\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import StratifiedKFold, train_test_split, RandomizedSearchCV\n",
    "from sklearn.metrics import make_scorer, f1_score\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from xgboost import XGBClassifier\n",
    "from lightgbm import LGBMClassifier\n",
    "from catboost import CatBoostClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from scipy.stats import randint, uniform\n",
    "\n",
    "# Param distributions (same as before)\n",
    "param_distributions = { \n",
    "    'RandomForest': { \n",
    "        'n_estimators': randint(100, 1000),\n",
    "        'max_depth': randint(3, 30),\n",
    "        'min_samples_split': randint(2, 20),\n",
    "        'min_samples_leaf': randint(1, 20),\n",
    "        'class_weight': ['balanced', {0: 1, 1: 3},{0: 1, 1: 4.5}, {0: 1, 1: 5}, {0: 1, 1: 5.5},{0: 1, 1: 6}],\n",
    "    },\n",
    "    'XGBoost': {\n",
    "        'n_estimators': randint(100, 1000),\n",
    "        'learning_rate': uniform(0.01, 0.20),\n",
    "        'max_depth': randint(3, 10),\n",
    "        'scale_pos_weight': uniform(4.5, 18),\n",
    "        'subsample': uniform(0.5, 0.4),\n",
    "        'colsample_bytree': uniform(0.5, 0.4),\n",
    "    },\n",
    "    'LogisticRegression': {\n",
    "        'C': uniform(0.0001, 10),\n",
    "        'penalty': ['l1', 'l2'],\n",
    "        'solver': ['liblinear', 'saga'],\n",
    "        'class_weight': ['balanced', {0: 1, 1: 3}, {0: 1, 1: 4}, {0: 1, 1: 5},{0: 1, 1: 5.5},{0: 1, 1: 6}],\n",
    "        'max_iter': [100, 300, 500, 1000],\n",
    "    },\n",
    "    'LightGBM': {\n",
    "        'n_estimators': randint(100, 1000),\n",
    "        'learning_rate': uniform(0.01, 0.29),\n",
    "        'max_depth': randint(3, 30),\n",
    "        'num_leaves': randint(20, 150),\n",
    "        'min_data_in_leaf': randint(10, 250),\n",
    "        'class_weight': ['balanced', {0: 1, 1: 2},{0: 1, 1: 3}, {0: 1, 1: 4},{0: 1, 1: 5}, {0: 1, 1: 6}],\n",
    "    },\n",
    "    'CatBoost': {\n",
    "        'iterations': randint(100, 1000),\n",
    "        'learning_rate': uniform(0.01, 0.29),\n",
    "        'depth': randint(4, 10),\n",
    "        'l2_leaf_reg': uniform(1, 10),\n",
    "        'class_weights': [[1.0, 3.0],[1.0, 4.0], [1.0, 5.0], [1.0, 6.0]],\n",
    "    }\n",
    "}\n",
    "\n",
    "f1_scorer = make_scorer(f1_score)\n",
    "\n",
    "# Models \n",
    "models_2 = {\n",
    "    'RandomForest': RandomForestClassifier(random_state=42),\n",
    "    'XGBoost': XGBClassifier(random_state=42),\n",
    "    'LogisticRegression': LogisticRegression(random_state=42),\n",
    "    'LightGBM': LGBMClassifier(random_state=42, device='gpu', verbose=-1),\n",
    "    'CatBoost': CatBoostClassifier(random_state=42, verbose=0)\n",
    "}\n",
    "\n",
    "cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
    "\n",
    "# Randomized Search with F1 score as the metric\n",
    "best_model_3 = {}\n",
    "for model_name, model in models_2.items():\n",
    "    print(f\"Running RandomizedSearchCV for {model_name}...\")\n",
    "    \n",
    "    random_search = RandomizedSearchCV(\n",
    "        estimator=model,\n",
    "        param_distributions=param_distributions[model_name],\n",
    "        scoring=f1_scorer,\n",
    "        n_iter=60,\n",
    "        cv=cv,\n",
    "        verbose=1,\n",
    "        random_state=42,\n",
    "        n_jobs=7\n",
    "    )\n",
    "    \n",
    "    random_search.fit(X_train_sub, y_train_sub)\n",
    "    \n",
    "    best_model_3[model_name] = {\n",
    "        'model': random_search.best_estimator_,\n",
    "        'best_score': random_search.best_score_,\n",
    "        'best_params': random_search.best_params_\n",
    "    }\n",
    "    \n",
    "    # F1 score on the test set\n",
    "    test_predictions = best_model_3[model_name]['model'].predict(X_test)\n",
    "    test_f1_score = f1_score(y_test, test_predictions)\n",
    "    \n",
    "    print(f\"Best Hyperparameters for {model_name}: {random_search.best_params_}\")\n",
    "    print(f\"Test F1 Score for {model_name}: {test_f1_score:.4f}\")\n",
    "    print(\"-\" * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e99159c8-1c4a-4862-8f1c-be739a38eaa6",
   "metadata": {},
   "source": [
    "## For our last tuning on class weights we can see that it found a combination that performed a bit better the f1 score is a bit higher lets check on the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "401a16cb-f4a3-4a26-a2d1-140b74ead8c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training the best RandomForest model on the full training set...\n",
      "Metrics for RandomForest:\n",
      " - Accuracy: 0.9643\n",
      " - Recall: 0.7559\n",
      " - Precision: 0.6583\n",
      " - F1 Score: 0.7038\n",
      " - ROC AUC: 0.9748931426518936\n",
      "\n",
      "Training the best XGBoost model on the full training set...\n",
      "Metrics for XGBoost:\n",
      " - Accuracy: 0.9450\n",
      " - Recall: 0.6100\n",
      " - Precision: 0.5078\n",
      " - F1 Score: 0.5542\n",
      " - ROC AUC: 0.9219157955443342\n",
      "\n",
      "Training the best LogisticRegression model on the full training set...\n",
      "Metrics for LogisticRegression:\n",
      " - Accuracy: 0.9386\n",
      " - Recall: 0.4873\n",
      " - Precision: 0.4554\n",
      " - F1 Score: 0.4709\n",
      " - ROC AUC: 0.8614789707120222\n",
      "\n",
      "Training the best LightGBM model on the full training set...\n",
      "Metrics for LightGBM:\n",
      " - Accuracy: 0.9500\n",
      " - Recall: 0.6748\n",
      " - Precision: 0.5434\n",
      " - F1 Score: 0.6020\n",
      " - ROC AUC: 0.9419928221741273\n",
      "\n",
      "Training the best CatBoost model on the full training set...\n",
      "Metrics for CatBoost:\n",
      " - Accuracy: 0.9531\n",
      " - Recall: 0.6224\n",
      " - Precision: 0.5753\n",
      " - F1 Score: 0.5980\n",
      " - ROC AUC: 0.9285866174901094\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, recall_score, precision_score, f1_score, roc_auc_score\n",
    "\n",
    "for model_name, details in best_model_4.items():\n",
    "    print(f\"Training the best {model_name} model on the full training set...\")\n",
    "\n",
    "    # Access the best model from RandomizedSearchCV\n",
    "    models_2 = details['model']\n",
    "\n",
    "    # Train the model on the full training dataset\n",
    "    models_2.fit(X_train, y_train)\n",
    "\n",
    "    # Make predictions on the test dataset\n",
    "    y_pred = models_2.predict(X_test)\n",
    "    y_pred_proba = models_2.predict_proba(X_test)[:, 1] if hasattr(model, \"predict_proba\") else None\n",
    "\n",
    "    # Calculate metrics\n",
    "    accuracy = accuracy_score(y_test, y_pred)\n",
    "    recall = recall_score(y_test, y_pred)\n",
    "    precision = precision_score(y_test, y_pred)\n",
    "    f1 = f1_score(y_test, y_pred)\n",
    "    roc_auc = roc_auc_score(y_test, y_pred_proba) if y_pred_proba is not None else \"N/A\"\n",
    "\n",
    "    # Print metrics\n",
    "    print(f\"Metrics for {model_name}:\")\n",
    "    print(f\" - Accuracy: {accuracy:.4f}\")\n",
    "    print(f\" - Recall: {recall:.4f}\")\n",
    "    print(f\" - Precision: {precision:.4f}\")\n",
    "    print(f\" - F1 Score: {f1:.4f}\")\n",
    "    print(f\" - ROC AUC: {roc_auc if roc_auc != 'N/A' else 'Not Applicable'}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "936f082f-6373-4b8f-bfbf-58f324a1409a",
   "metadata": {},
   "source": [
    "## And finally we have these results random forest performed the best in the end with a very good score 75% recall and 65% precision 70% f1 score and 97% roc auc a fairly big difference compared to our other models here and as such we will be saving it and using random forest for now along with other models because now we will try the other method which is resampling techniques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6c7436f8-2e54-4111-a5c1-ddf68881c09a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RandomForest saved to saved_models\\RandomForest_best_model.pkl\n",
      "XGBoost saved to saved_models\\XGBoost_best_model.pkl\n",
      "LogisticRegression saved to saved_models\\LogisticRegression_best_model.pkl\n",
      "LightGBM saved to saved_models\\LightGBM_best_model.pkl\n",
      "CatBoost saved to saved_models\\CatBoost_best_model.pkl\n"
     ]
    }
   ],
   "source": [
    "import joblib\n",
    "import os\n",
    "\n",
    "# Directory to save models\n",
    "model_save_dir = \"saved_models\"\n",
    "os.makedirs(model_save_dir, exist_ok=True)\n",
    "\n",
    "for model_name, model_info in best_model_4.items():\n",
    "    # Save the best model to a file\n",
    "    model_path = os.path.join(model_save_dir, f\"{model_name}_best_model.pkl\")\n",
    "    joblib.dump(model_info['model'], model_path)\n",
    "    print(f\"{model_name} saved to {model_path}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e756e846-dfe6-4e85-9a8d-fe524ef09fb7",
   "metadata": {},
   "source": [
    "# **RESAMPLING TECHNIQUE**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8336f39a-313d-48b2-805f-26c54f0a5f36",
   "metadata": {},
   "source": [
    "## Resampling technique involves a technique of generating synthetic data(called oversampling) or removing data(undersampling) these methods helps address the class imbalance \n",
    "\n",
    "- ### **Oversampling** is a technique by generating a synthetic sample of the xtrain and leveling the class imbalance so lets say you have a 90% to 10% class imbalance a oversampling will turn the minority to the size of the majority making it balanced now this method works but it can introduce alot of noise synthetic data that the model might overfit with so we have a bunch of methods Smote,KNNSmote,Adasyn\n",
    "- ### **Undersampling** is a technique by removing samples from the majority to balance the data so if again its from 90 to 10% instead of generating synthetic data from the minority we will be removing samples from the majority to maintain the same ratio but yes this also has disadvantages such as losing an important information on your data because you removed some but this is also a technique to address imbalance\n",
    "- ### in the code i did below i tried a bunch of combination of Smote, KnnSmote, Adaysyn oversampling and near_miss undersampling technique, take note that here we dont have our class weight adjusted so this is just a model with the resampling technique.\n",
    "    - #### **Macro average** Uses an unweighted mean to calculate the average of all per-class scores. This method can penalize a model if it performs poorly in minority classes.\n",
    "    - #### **Weighted average** Calculates the average of all per-class scores, but also considers the number of actual instances of each class in the dataset. This method favors the majority class and can help with class imbalance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "018ca5f5-6046-4520-9a64-0107c102943e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Random Forest...\n",
      "Random Forest Metrics:\n",
      "Accuracy: 0.1287194918087596\n",
      "F1 Score: 0.10778665952157668\n",
      "Recall: 0.93929173693086\n",
      "Precision: 0.05717376370914891\n",
      "ROC AUC: 0.5809456556645286\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.96      0.08      0.15    129877\n",
      "         1.0       0.06      0.94      0.11      7709\n",
      "\n",
      "    accuracy                           0.13    137586\n",
      "   macro avg       0.51      0.51      0.13    137586\n",
      "weighted avg       0.91      0.13      0.15    137586\n",
      "\n",
      "\n",
      "Training XGBoost...\n",
      "XGBoost Metrics:\n",
      "Accuracy: 0.20449028244152748\n",
      "F1 Score: 0.11412291280523833\n",
      "Recall: 0.9145155013620444\n",
      "Precision: 0.060858755891645515\n",
      "ROC AUC: 0.5775048246477792\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.16      0.28    129877\n",
      "         1.0       0.06      0.91      0.11      7709\n",
      "\n",
      "    accuracy                           0.20    137586\n",
      "   macro avg       0.52      0.54      0.20    137586\n",
      "weighted avg       0.92      0.20      0.27    137586\n",
      "\n",
      "\n",
      "Training Logistic Regression...\n",
      "Logistic Regression Metrics:\n",
      "Accuracy: 0.4981175410288837\n",
      "F1 Score: 0.15582288075503067\n",
      "Recall: 0.8266960695291218\n",
      "Precision: 0.08601816733928114\n",
      "ROC AUC: 0.7095972785122946\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.48      0.64    129877\n",
      "         1.0       0.09      0.83      0.16      7709\n",
      "\n",
      "    accuracy                           0.50    137586\n",
      "   macro avg       0.53      0.65      0.40    137586\n",
      "weighted avg       0.93      0.50      0.62    137586\n",
      "\n",
      "\n",
      "Training LightGBM...\n",
      "LightGBM Metrics:\n",
      "Accuracy: 0.22681813556611866\n",
      "F1 Score: 0.11634339826390332\n",
      "Recall: 0.908418731352964\n",
      "Precision: 0.06215165607582804\n",
      "ROC AUC: 0.6254170263551185\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.19      0.31    129877\n",
      "         1.0       0.06      0.91      0.12      7709\n",
      "\n",
      "    accuracy                           0.23    137586\n",
      "   macro avg       0.52      0.55      0.21    137586\n",
      "weighted avg       0.92      0.23      0.30    137586\n",
      "\n",
      "\n",
      "Training CatBoost...\n",
      "CatBoost Metrics:\n",
      "Accuracy: 0.1937551785792159\n",
      "F1 Score: 0.11307267929959222\n",
      "Recall: 0.9172395900895057\n",
      "Precision: 0.060249997869820465\n",
      "ROC AUC: 0.5790462278721095\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.15      0.26    129877\n",
      "         1.0       0.06      0.92      0.11      7709\n",
      "\n",
      "    accuracy                           0.19    137586\n",
      "   macro avg       0.51      0.53      0.19    137586\n",
      "weighted avg       0.92      0.19      0.25    137586\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from imblearn.combine import SMOTEENN\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from imblearn.over_sampling import KMeansSMOTE\n",
    "from xgboost import XGBClassifier\n",
    "from imblearn.under_sampling import NearMiss\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "import lightgbm as lgb\n",
    "from catboost import CatBoostClassifier\n",
    "from sklearn.metrics import accuracy_score, f1_score, recall_score, precision_score, roc_auc_score, classification_report\n",
    "from imblearn.over_sampling import ADASYN\n",
    "from imblearn.over_sampling import SMOTE\n",
    "\n",
    "from imblearn.under_sampling import TomekLinks\n",
    "# Assuming you already have X_train and y_train\n",
    "# Create the SMOTE + ENN object\n",
    "smote_enn = SMOTEENN(sampling_strategy='auto',random_state=42)\n",
    "adasyn = ADASYN(sampling_strategy='auto', random_state=42)\n",
    "near_miss = NearMiss(sampling_strategy='auto')\n",
    "# Resample the data once using SMOTE + ENN\n",
    "\n",
    "smote = SMOTE(sampling_strategy='auto', random_state=42)\n",
    "knn_smote = KMeansSMOTE(sampling_strategy='auto',cluster_balance_threshold=0.2,k_neighbors=5, random_state=42)\n",
    "\n",
    "X_resampled, y_resampled = near_miss.fit_resample(X_train, y_train)\n",
    "\n",
    "\n",
    "\n",
    "# Create the models\n",
    "models = {\n",
    "    'Random Forest': RandomForestClassifier(random_state=42),\n",
    "    'XGBoost': XGBClassifier( random_state=42),\n",
    "    'Logistic Regression': LogisticRegression(random_state=42),\n",
    "    'LightGBM': lgb.LGBMClassifier(random_state=42, verbose=-1),\n",
    "    'CatBoost': CatBoostClassifier(verbose=0, random_state=42)\n",
    "}\n",
    "\n",
    "# Create a function to train models on the resampled data\n",
    "def evaluate_models(X_resampled, y_resampled, models, X_test, y_test):\n",
    "    for model_name, model in models.items():\n",
    "        print(f\"Training {model_name}...\")\n",
    "        \n",
    "        # Train the model on the resampled data\n",
    "        model.fit(X_resampled, y_resampled)\n",
    "        \n",
    "        # Make predictions on the test set (not the training set)\n",
    "        y_pred = model.predict(X_test)\n",
    "        \n",
    "        # Calculate the metrics\n",
    "        accuracy = accuracy_score(y_test, y_pred)\n",
    "        f1 = f1_score(y_test, y_pred)\n",
    "        recall = recall_score(y_test, y_pred)\n",
    "        precision = precision_score(y_test, y_pred)\n",
    "        roc_auc = roc_auc_score(y_test, model.predict_proba(X_test)[:, 1])\n",
    "        \n",
    "        # Print out the metrics for each model\n",
    "        print(f\"{model_name} Metrics:\")\n",
    "        print(f\"Accuracy: {accuracy}\")\n",
    "        print(f\"F1 Score: {f1}\")\n",
    "        print(f\"Recall: {recall}\")\n",
    "        print(f\"Precision: {precision}\")\n",
    "        print(f\"ROC AUC: {roc_auc}\")\n",
    "        print(f\"Classification Report:\\n{classification_report(y_test, y_pred)}\\n\")\n",
    "\n",
    "# Evaluate the models on the test set\n",
    "evaluate_models(X_resampled, y_resampled, models, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b24cc976-60c0-4e67-8763-4fa38ab92aac",
   "metadata": {},
   "source": [
    "## and it was not performing as good as the class weights after trying these resampling methods as you can see here in this score which is done by near-miss this didnt performed as well as the class weights so we will also try hyperparameter tuning along with oversampling technique SMOTE_ENN using a pipeline to see it will end in a good result "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "694b5bd4-5d28-442a-8eab-970060334390",
   "metadata": {},
   "source": [
    "### **Including class weight balanced or none the randomsearchCV can choose which is the best combination**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "d0583eb0-88d8-415b-916c-50ee54979b17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RandomForest...\n",
      "Fitting 3 folds for each of 50 candidates, totalling 150 fits\n",
      "Best Hyperparameters for RandomForest: {'classifier__class_weight': 'balanced', 'classifier__max_depth': 27, 'classifier__min_samples_leaf': 6, 'classifier__min_samples_split': 13, 'classifier__n_estimators': 743}\n",
      "Best F1 Score (from RandomizedSearchCV) for RandomForest: 0.41972305527004106\n",
      "--------------------------------------------------\n",
      "Training XGBoost...\n",
      "Fitting 3 folds for each of 50 candidates, totalling 150 fits\n",
      "Best Hyperparameters for XGBoost: {'classifier__colsample_bytree': 0.8085081386743783, 'classifier__learning_rate': 0.024808930346818074, 'classifier__max_depth': 9, 'classifier__n_estimators': 949, 'classifier__scale_pos_weight': 2.9269524762010377, 'classifier__subsample': 0.8452413703502375}\n",
      "Best F1 Score (from RandomizedSearchCV) for XGBoost: 0.4173400241792149\n",
      "--------------------------------------------------\n",
      "Training LogisticRegression...\n",
      "Fitting 3 folds for each of 50 candidates, totalling 150 fits\n",
      "Best Hyperparameters for LogisticRegression: {'classifier__C': 3.745501188473625, 'classifier__class_weight': 'balanced', 'classifier__max_iter': 500, 'classifier__penalty': 'l1', 'classifier__solver': 'saga'}\n",
      "Best F1 Score (from RandomizedSearchCV) for LogisticRegression: 0.30387042245314305\n",
      "--------------------------------------------------\n",
      "Training LightGBM...\n",
      "Fitting 3 folds for each of 50 candidates, totalling 150 fits\n",
      "Best Hyperparameters for LightGBM: {'classifier__class_weight': 'balanced', 'classifier__learning_rate': 0.06056626441144752, 'classifier__max_depth': 3, 'classifier__min_data_in_leaf': 177, 'classifier__n_estimators': 827, 'classifier__num_leaves': 58}\n",
      "Best F1 Score (from RandomizedSearchCV) for LightGBM: 0.4576387383962596\n",
      "--------------------------------------------------\n",
      "Training CatBoost...\n",
      "Fitting 3 folds for each of 50 candidates, totalling 150 fits\n",
      "Best Hyperparameters for CatBoost: {'classifier__class_weights': [1.0, 4.0], 'classifier__depth': 9, 'classifier__iterations': 884, 'classifier__l2_leaf_reg': 2.054942598302706, 'classifier__learning_rate': 0.14239502544004398}\n",
      "Best F1 Score (from RandomizedSearchCV) for CatBoost: 0.40583037399110083\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "from imblearn.combine import SMOTEENN\n",
    "from imblearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import RandomizedSearchCV, StratifiedKFold, train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from xgboost import XGBClassifier\n",
    "from lightgbm import LGBMClassifier\n",
    "from catboost import CatBoostClassifier\n",
    "from scipy.stats import randint, uniform\n",
    "\n",
    "# Sample data - replace this with your actual dataset\n",
    "# X and y are your features and target variable\n",
    "# Split a subset of the data (20%)\n",
    "X_train_sub, _, y_train_sub, _ = train_test_split(X_train, y_train, test_size=0.8, stratify=y_train, random_state=42)\n",
    "\n",
    "# Define your parameter distributions for each model\n",
    "param_distributions = { \n",
    "    'RandomForest': { \n",
    "        'classifier__n_estimators': randint(700, 950),\n",
    "        'classifier__max_depth': randint(3, 30),\n",
    "        'classifier__min_samples_split': randint(2, 20),\n",
    "        'classifier__min_samples_leaf': randint(1, 20),\n",
    "        'classifier__class_weight': [None, 'balanced', {0: 1, 1: 6}, {0: 1, 1: 7}],\n",
    "    },\n",
    "    'XGBoost': {\n",
    "        'classifier__n_estimators': randint(700, 950),\n",
    "        'classifier__learning_rate': uniform(0.01, 0.20),\n",
    "        'classifier__max_depth': randint(3, 10),\n",
    "        'classifier__scale_pos_weight': uniform(2, 8),\n",
    "        'classifier__subsample': uniform(0.5, 0.4),\n",
    "        'classifier__colsample_bytree': uniform(0.5, 0.4),\n",
    "    },\n",
    "    'LogisticRegression': {\n",
    "        'classifier__C': uniform(0.0001, 10),\n",
    "        'classifier__penalty': ['l1', 'l2'],\n",
    "        'classifier__solver': ['liblinear', 'saga'],\n",
    "        'classifier__class_weight': [None, 'balanced', {0: 1, 1: 4}, {0: 1, 1: 5}],\n",
    "        'classifier__max_iter': [100, 300, 500, 1000],\n",
    "    },\n",
    "    'LightGBM': {\n",
    "        'classifier__n_estimators': randint(700, 950),\n",
    "        'classifier__learning_rate': uniform(0.01, 0.29),\n",
    "        'classifier__max_depth': randint(3, 30),\n",
    "        'classifier__num_leaves': randint(20, 150),\n",
    "        'classifier__min_data_in_leaf': randint(10, 250),\n",
    "        'classifier__class_weight': [None, 'balanced', {0: 1, 1: 6}],\n",
    "    },\n",
    "    'CatBoost': {\n",
    "        'classifier__iterations': randint(700, 950),\n",
    "        'classifier__learning_rate': uniform(0.01, 0.29),\n",
    "        'classifier__depth': randint(4, 10),\n",
    "        'classifier__l2_leaf_reg': uniform(1, 10),\n",
    "    }\n",
    "}\n",
    "\n",
    "# Create a dictionary of classifiers\n",
    "classifiers = {\n",
    "    'RandomForest': RandomForestClassifier(random_state=42),\n",
    "    'XGBoost': XGBClassifier(random_state=42),\n",
    "    'LogisticRegression': LogisticRegression(random_state=42),\n",
    "    'LightGBM': LGBMClassifier(random_state=42, verbose=-1, device='gpu'),\n",
    "    'CatBoost': CatBoostClassifier(random_state=42, verbose=0)\n",
    "}\n",
    "\n",
    "# Iterate over each classifier, create a pipeline, and run RandomizedSearchCV\n",
    "for model_name, classifier in classifiers.items():\n",
    "    print(f\"Training {model_name}...\")\n",
    "\n",
    "    # Create the pipeline with SMOTE-ENN and the current classifier\n",
    "    pipeline = Pipeline([\n",
    "        ('sampling', SMOTEENN(random_state=42)),  # Apply SMOTE-ENN for resampling\n",
    "        ('classifier', classifier)  # Use the current classifier\n",
    "    ])\n",
    "\n",
    "    # Set the hyperparameter distribution for the current model\n",
    "    current_param_dist = param_distributions[model_name]\n",
    "\n",
    "    # Setup the stratified k-fold cross-validation\n",
    "    cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n",
    "\n",
    "    # Perform RandomizedSearchCV to tune hyperparameters with F1 score optimization\n",
    "    random_search = RandomizedSearchCV(\n",
    "        pipeline, \n",
    "        current_param_dist, \n",
    "        n_iter=50, \n",
    "        cv=cv, \n",
    "        scoring='f1',  # Optimize for F1 score\n",
    "        verbose=2, \n",
    "        random_state=42, \n",
    "        n_jobs=7\n",
    "    )\n",
    "\n",
    "    # Fit the model with the subset of data\n",
    "    random_search.fit(X_train_sub, y_train_sub)\n",
    "\n",
    "    # Get the best hyperparameters and the best F1 score\n",
    "    print(f\"Best Hyperparameters for {model_name}: {random_search.best_params_}\")\n",
    "    print(f\"Best F1 Score (from RandomizedSearchCV) for {model_name}: {random_search.best_score_}\")\n",
    "    print(\"-\" * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28e48ab6-9399-4d3a-89b3-4831cd311efe",
   "metadata": {},
   "source": [
    "## **Exaxmining the results and testing on test data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "83ba8b40-a4c8-4dd8-937b-57880b1e93f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating RandomForest...\n",
      "Accuracy: 0.9131\n",
      "F1 Score: 0.4238\n",
      "Recall: 0.5706\n",
      "Precision: 0.3371\n",
      "ROC-AUC: 0.8505\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.93      0.95    129877\n",
      "         1.0       0.34      0.57      0.42      7709\n",
      "\n",
      "    accuracy                           0.91    137586\n",
      "   macro avg       0.66      0.75      0.69    137586\n",
      "weighted avg       0.94      0.91      0.92    137586\n",
      "\n",
      "--------------------------------------------------\n",
      "Evaluating XGBoost...\n",
      "Accuracy: 0.9131\n",
      "F1 Score: 0.4238\n",
      "Recall: 0.5706\n",
      "Precision: 0.3371\n",
      "ROC-AUC: 0.8505\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.93      0.95    129877\n",
      "         1.0       0.34      0.57      0.42      7709\n",
      "\n",
      "    accuracy                           0.91    137586\n",
      "   macro avg       0.66      0.75      0.69    137586\n",
      "weighted avg       0.94      0.91      0.92    137586\n",
      "\n",
      "--------------------------------------------------\n",
      "Evaluating LogisticRegression...\n",
      "Accuracy: 0.9131\n",
      "F1 Score: 0.4238\n",
      "Recall: 0.5706\n",
      "Precision: 0.3371\n",
      "ROC-AUC: 0.8505\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.93      0.95    129877\n",
      "         1.0       0.34      0.57      0.42      7709\n",
      "\n",
      "    accuracy                           0.91    137586\n",
      "   macro avg       0.66      0.75      0.69    137586\n",
      "weighted avg       0.94      0.91      0.92    137586\n",
      "\n",
      "--------------------------------------------------\n",
      "Evaluating LightGBM...\n",
      "Accuracy: 0.9131\n",
      "F1 Score: 0.4238\n",
      "Recall: 0.5706\n",
      "Precision: 0.3371\n",
      "ROC-AUC: 0.8505\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.93      0.95    129877\n",
      "         1.0       0.34      0.57      0.42      7709\n",
      "\n",
      "    accuracy                           0.91    137586\n",
      "   macro avg       0.66      0.75      0.69    137586\n",
      "weighted avg       0.94      0.91      0.92    137586\n",
      "\n",
      "--------------------------------------------------\n",
      "Evaluating CatBoost...\n",
      "Accuracy: 0.9131\n",
      "F1 Score: 0.4238\n",
      "Recall: 0.5706\n",
      "Precision: 0.3371\n",
      "ROC-AUC: 0.8505\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.93      0.95    129877\n",
      "         1.0       0.34      0.57      0.42      7709\n",
      "\n",
      "    accuracy                           0.91    137586\n",
      "   macro avg       0.66      0.75      0.69    137586\n",
      "weighted avg       0.94      0.91      0.92    137586\n",
      "\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "best_models_4 = {}\n",
    "\n",
    "# Iterate over each classifier and evaluate the best model on the test set\n",
    "for model_name, classifier in classifiers.items():\n",
    "    print(f\"Evaluating {model_name}...\")\n",
    "\n",
    "    # Get the best pipeline from RandomizedSearchCV\n",
    "    best_model = random_search.best_estimator_\n",
    "\n",
    "    # Make predictions on the test data\n",
    "    y_pred = best_model.predict(X_test)\n",
    "    y_pred_proba = best_model.predict_proba(X_test)[:, 1] if hasattr(best_model, \"predict_proba\") else None\n",
    "\n",
    "    # Calculate metrics\n",
    "    accuracy = accuracy_score(y_test, y_pred)\n",
    "    f1 = f1_score(y_test, y_pred)\n",
    "    recall = recall_score(y_test, y_pred)\n",
    "    precision = precision_score(y_test, y_pred)\n",
    "    roc_auc = roc_auc_score(y_test, y_pred_proba) if y_pred_proba is not None else None\n",
    "\n",
    "    # Print and store the results\n",
    "    print(f\"Accuracy: {accuracy:.4f}\")\n",
    "    print(f\"F1 Score: {f1:.4f}\")\n",
    "    print(f\"Recall: {recall:.4f}\")\n",
    "    print(f\"Precision: {precision:.4f}\")\n",
    "    if roc_auc:\n",
    "        print(f\"ROC-AUC: {roc_auc:.4f}\")\n",
    "    print(classification_report(y_test, y_pred))\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    # Store metrics for comparison in best_models_4\n",
    "    best_models_4[model_name] = {\n",
    "        'Model': best_model,\n",
    "        'Accuracy': accuracy,\n",
    "        'F1 Score': f1,\n",
    "        'Recall': recall,\n",
    "        'Precision': precision,\n",
    "        'ROC-AUC': roc_auc\n",
    "    }\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2b701b0-ee52-4e55-8fcf-74d25fd014a6",
   "metadata": {},
   "source": [
    "### And Finally we come to this conclusion the oversampling technique smote+enn which basically performs smote synthetic sampling and uses enn to clean the noisy data that the smote mightve created and the results performed worse than the class weight method "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c287599-7d3f-48c4-9a4b-96df36d7040a",
   "metadata": {},
   "source": [
    "## with these results we have tried class weights and resampling technique to fix the imbalance and class weights seems to do better in this problem and as such we will be using the best model from that which is random forest and that is the one we will be deploying\n",
    "\n",
    "# **i hope you found this notebook insightful**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f13ba01b-dfd0-4061-9085-13d2f76bec98",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (Heart Disease Predictor)",
   "language": "python",
   "name": "heart_disease_predictor"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}