Classification with oversampling the dataset.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "In this notebook, we will apply oversampling technique and use the classification strategies we used in the notebook *Classification on imbalanced dataset.ipynb*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import time\n",
    "import datetime\n",
    "import seaborn as sn\n",
    "import matplotlib.pyplot as plt\n",
    "from imblearn.over_sampling import SMOTE\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.linear_model import LogisticRegression, SGDClassifier\n",
    "from sklearn.svm import LinearSVC\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, VotingClassifier, BaggingClassifier\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "\n",
    "# Sometimes sklearn gives ConvergenceWarnings. So we ignore those.\n",
    "from warnings import filterwarnings\n",
    "filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing and oversampling features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before oversampling, X_train: (19842, 14)\n",
      "Before oversampling, y_train: (19842,)\n",
      "After oversampling, X_train: (34800, 14)\n",
      "After oversampling, y_train: (34800,)\n",
      "x_train shape = (34800, 14) | y_train shape = (34800,)\n",
      "x_test shape  = (4961, 14)  | y_test shape = (4961,)\n"
     ]
    }
   ],
   "source": [
    "# Reading the dataset.\n",
    "df = pd.read_csv('LSD_data.csv', sep=',')\n",
    "\n",
    "# Getting features and labels.\n",
    "X = df[['x', 'y', 'cld', 'dtr', 'frs', 'pet', 'pre', 'tmn', 'tmp', 'tmx', 'vap', 'wet', 'elevation', 'dominant_land_cover']].values\n",
    "y = df['lumpy'].values\n",
    "\n",
    "# Splitting into train-test in the ratio of 80-20.\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=True)\n",
    "\n",
    "print(f\"Before oversampling, X_train: {x_train.shape}\")\n",
    "print(f\"Before oversampling, y_train: {y_train.shape}\")\n",
    "\n",
    "# Oversampling data\n",
    "oversampler = SMOTE(sampling_strategy=\"minority\")\n",
    "x_train, y_train = oversampler.fit_resample(x_train, y_train)\n",
    "\n",
    "print(f\"After oversampling, X_train: {x_train.shape}\")\n",
    "print(f\"After oversampling, y_train: {y_train.shape}\")\n",
    "\n",
    "# Scaling the features.\n",
    "scaler = StandardScaler()\n",
    "scaler.fit(x_train)\n",
    "x_train = scaler.transform(x_train)\n",
    "x_test = scaler.transform(x_test)\n",
    "\n",
    "print(f'x_train shape = {x_train.shape} | y_train shape = {y_train.shape}')\n",
    "print(f'x_test shape  = {x_test.shape}  | y_test shape = {y_test.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Core classifiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_reg_hyptune(x_train, y_train):\n",
    "    params = {\n",
    "        'penalty': ['l2'],\n",
    "        'C': [1.0, 1.5, 2.5, 3.0, 5.0, 10.0],\n",
    "    }\n",
    "\n",
    "    start_time = time.time()\n",
    "    print('Training started..')\n",
    "\n",
    "    clf = GridSearchCV(\n",
    "            estimator=LogisticRegression(), \n",
    "            param_grid=params, \n",
    "            cv=5, \n",
    "            return_train_score=True\n",
    "          )\n",
    "    clf.fit(x_train, y_train)\n",
    "\n",
    "    print('Training ended..')\n",
    "    end_time = time.time()\n",
    "\n",
    "    total_training_time = str(datetime.timedelta(seconds=end_time-start_time))\n",
    "    mean_train_score = np.mean(clf.cv_results_['mean_train_score'], axis=0)\n",
    "    mean_val_score = np.mean(clf.cv_results_['mean_test_score'], axis=0)\n",
    "\n",
    "    print('\\nResults:\\n')\n",
    "    print(f'Best params = {clf.best_params_}')\n",
    "    print(f'Best score = {clf.best_score_}')\n",
    "    print(f'Mean train score = {mean_train_score}')\n",
    "    print(f'Mean val  score = {mean_val_score}')\n",
    "    print(f'Total training time = {total_training_time}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started..\n",
      "Training ended..\n",
      "\n",
      "Results:\n",
      "\n",
      "Best params = {'C': 1.0, 'penalty': 'l2'}\n",
      "Best score = 0.8863505747126437\n",
      "Mean train score = 0.8863194444444445\n",
      "Mean val  score = 0.8863122605363984\n",
      "Total training time = 0:00:02.256830\n"
     ]
    }
   ],
   "source": [
    "log_reg_hyptune(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_log_reg(x_train, y_train, x_test, y_test):\n",
    "    log_reg = LogisticRegression(C=1.0, penalty='l2')\n",
    "    log_reg.fit(x_train, y_train)\n",
    "    y_pred = log_reg.predict(x_test)\n",
    "\n",
    "    # Results.\n",
    "    cm = confusion_matrix(y_test, y_pred)\n",
    "    cm_df = pd.DataFrame(cm)\n",
    "    \n",
    "    classif_rep = classification_report(y_pred, y_test)\n",
    "    print('Classification report:\\n')\n",
    "    print(classif_rep)\n",
    "    print()\n",
    "    \n",
    "    sn.heatmap(cm_df, annot=True, cmap='Blues', fmt='g')\n",
    "    plt.title('Confusion Matrix (Test Data)') \n",
    "    plt.xlabel('Predicted') \n",
    "    plt.ylabel('True') \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.90      0.98      0.94      4004\n",
      "           1       0.87      0.54      0.67       957\n",
      "\n",
      "    accuracy                           0.90      4961\n",
      "   macro avg       0.89      0.76      0.80      4961\n",
      "weighted avg       0.89      0.90      0.89      4961\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_evaluate_log_reg(x_train, y_train, x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def svm_hyptune(x_train, y_train):\n",
    "    params = {\n",
    "        'penalty': ['l2'],\n",
    "        'C': [1.0, 1.5, 2.5, 3.0, 5.0]\n",
    "    }\n",
    "\n",
    "    start_time = time.time()\n",
    "    print('Training started..')\n",
    "\n",
    "    clf = GridSearchCV(\n",
    "            estimator=LinearSVC(), \n",
    "            param_grid=params, \n",
    "            cv=5, \n",
    "            return_train_score=True\n",
    "          )\n",
    "    clf.fit(x_train, y_train)\n",
    "\n",
    "    print('Training ended..')\n",
    "    end_time = time.time()\n",
    "\n",
    "    total_training_time = str(datetime.timedelta(seconds=end_time-start_time))\n",
    "    mean_train_score = np.mean(clf.cv_results_['mean_train_score'], axis=0)\n",
    "    mean_val_score = np.mean(clf.cv_results_['mean_test_score'], axis=0)\n",
    "\n",
    "    print('\\nResults:\\n')\n",
    "    print(f'Best params = {clf.best_params_}')\n",
    "    print(f'Best score = {clf.best_score_}')\n",
    "    print(f'Mean train score = {mean_train_score}')\n",
    "    print(f'Mean val  score = {mean_val_score}')\n",
    "    print(f'Total training time = {total_training_time}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started..\n",
      "Training ended..\n",
      "\n",
      "Results:\n",
      "\n",
      "Best params = {'C': 3.0, 'penalty': 'l2'}\n",
      "Best score = 0.8851724137931034\n",
      "Mean train score = 0.8844382183908046\n",
      "Mean val  score = 0.8842241379310346\n",
      "Total training time = 0:00:32.885269\n"
     ]
    }
   ],
   "source": [
    "svm_hyptune(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_svm(x_train, y_train, x_test, y_test):\n",
    "    svm = LinearSVC(C=3.0, penalty='l2')\n",
    "    svm.fit(x_train, y_train)\n",
    "    y_pred = svm.predict(x_test)\n",
    "\n",
    "    # Results.\n",
    "    cm = confusion_matrix(y_test, y_pred)\n",
    "    cm_df = pd.DataFrame(cm)\n",
    "    \n",
    "    classif_rep = classification_report(y_pred, y_test)\n",
    "    print('Classification report:\\n')\n",
    "    print(classif_rep)\n",
    "    print()\n",
    "    \n",
    "    sn.heatmap(cm_df, annot=True, cmap='Blues', fmt='g')\n",
    "    plt.title('Confusion Matrix (Test Data)') \n",
    "    plt.xlabel('Predicted') \n",
    "    plt.ylabel('True') \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.89      0.98      0.93      3962\n",
      "           1       0.87      0.52      0.65       999\n",
      "\n",
      "    accuracy                           0.89      4961\n",
      "   macro avg       0.88      0.75      0.79      4961\n",
      "weighted avg       0.89      0.89      0.88      4961\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_evaluate_svm(x_train, y_train, x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Decision Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dt_hyptune(x_train, y_train):\n",
    "    params = {\n",
    "        'criterion': ['gini', 'entropy'],\n",
    "        'max_depth': [100, 150, 200],\n",
    "\n",
    "    }\n",
    "\n",
    "    start_time = time.time()\n",
    "    print('Training started..')\n",
    "\n",
    "    clf = GridSearchCV(\n",
    "            estimator=DecisionTreeClassifier(), \n",
    "            param_grid=params, \n",
    "            cv=5, \n",
    "            return_train_score=True\n",
    "          )\n",
    "    clf.fit(x_train, y_train)\n",
    "\n",
    "    print('Training ended..')\n",
    "    end_time = time.time()\n",
    "\n",
    "    total_training_time = str(datetime.timedelta(seconds=end_time-start_time))\n",
    "    mean_train_score = np.mean(clf.cv_results_['mean_train_score'], axis=0)\n",
    "    mean_val_score = np.mean(clf.cv_results_['mean_test_score'], axis=0)\n",
    "\n",
    "    print('\\nResults:\\n')\n",
    "    print(f'Best params = {clf.best_params_}')\n",
    "    print(f'Best score = {clf.best_score_}')\n",
    "    print(f'Mean train score = {mean_train_score}')\n",
    "    print(f'Mean val  score = {mean_val_score}')\n",
    "    print(f'Total training time = {total_training_time}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started..\n",
      "Training ended..\n",
      "\n",
      "Results:\n",
      "\n",
      "Best params = {'criterion': 'entropy', 'max_depth': 100}\n",
      "Best score = 0.9785057471264368\n",
      "Mean train score = 1.0\n",
      "Mean val  score = 0.9771503831417624\n",
      "Total training time = 0:00:04.496617\n"
     ]
    }
   ],
   "source": [
    "dt_hyptune(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_dt(x_train, y_train, x_test, y_test):\n",
    "    dt = DecisionTreeClassifier(criterion='entropy', max_depth=100)\n",
    "    dt.fit(x_train, y_train)\n",
    "    y_pred = dt.predict(x_test)\n",
    "\n",
    "    # Results.\n",
    "    cm = confusion_matrix(y_test, y_pred)\n",
    "    cm_df = pd.DataFrame(cm)\n",
    "    \n",
    "    classif_rep = classification_report(y_pred, y_test)\n",
    "    print('Classification report:\\n')\n",
    "    print(classif_rep)\n",
    "    print()\n",
    "    \n",
    "    sn.heatmap(cm_df, annot=True, cmap='Blues', fmt='g')\n",
    "    plt.title('Confusion Matrix (Test Data)') \n",
    "    plt.xlabel('Predicted') \n",
    "    plt.ylabel('True') \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.98      4310\n",
      "           1       0.92      0.84      0.88       651\n",
      "\n",
      "    accuracy                           0.97      4961\n",
      "   macro avg       0.95      0.92      0.93      4961\n",
      "weighted avg       0.97      0.97      0.97      4961\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_evaluate_dt(x_train, y_train, x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rf_hyptune(x_train, y_train):\n",
    "    params = {\n",
    "        'n_estimators': [10, 20, 30],\n",
    "        'criterion': ['gini', 'entropy'],\n",
    "        'max_depth': [50, 100],\n",
    "    }\n",
    "\n",
    "    start_time = time.time()\n",
    "    print('Training started..')\n",
    "\n",
    "    clf = GridSearchCV(\n",
    "            estimator=RandomForestClassifier(), \n",
    "            param_grid=params, \n",
    "            cv=5, \n",
    "            return_train_score=True\n",
    "          )\n",
    "    clf.fit(x_train, y_train)\n",
    "\n",
    "    print('Training ended..')\n",
    "    end_time = time.time()\n",
    "\n",
    "    total_training_time = str(datetime.timedelta(seconds=end_time-start_time))\n",
    "    mean_train_score = np.mean(clf.cv_results_['mean_train_score'], axis=0)\n",
    "    mean_val_score = np.mean(clf.cv_results_['mean_test_score'], axis=0)\n",
    "\n",
    "    print('\\nResults:\\n')\n",
    "    print(f'Best params = {clf.best_params_}')\n",
    "    print(f'Best score = {clf.best_score_}')\n",
    "    print(f'Mean train score = {mean_train_score}')\n",
    "    print(f'Mean val  score = {mean_val_score}')\n",
    "    print(f'Total training time = {total_training_time}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started..\n",
      "Training ended..\n",
      "\n",
      "Results:\n",
      "\n",
      "Best params = {'criterion': 'entropy', 'max_depth': 50, 'n_estimators': 30}\n",
      "Best score = 0.9795114942528735\n",
      "Mean train score = 0.999254070881226\n",
      "Mean val  score = 0.978043582375479\n",
      "Total training time = 0:00:31.880639\n"
     ]
    }
   ],
   "source": [
    "rf_hyptune(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_rf(x_train, y_train, x_test, y_test):\n",
    "    rf = RandomForestClassifier(criterion='entropy', max_depth=50, n_estimators=30)\n",
    "    rf.fit(x_train, y_train)\n",
    "    y_pred = rf.predict(x_test)\n",
    "\n",
    "    # Results.\n",
    "    cm = confusion_matrix(y_test, y_pred)\n",
    "    cm_df = pd.DataFrame(cm)\n",
    "    \n",
    "    classif_rep = classification_report(y_pred, y_test)\n",
    "    print('Classification report:\\n')\n",
    "    print(classif_rep)\n",
    "    print()\n",
    "    \n",
    "    sn.heatmap(cm_df, annot=True, cmap='Blues', fmt='g')\n",
    "    plt.title('Confusion Matrix (Test Data)') \n",
    "    plt.xlabel('Predicted') \n",
    "    plt.ylabel('True') \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.98      4324\n",
      "           1       0.90      0.85      0.87       637\n",
      "\n",
      "    accuracy                           0.97      4961\n",
      "   macro avg       0.94      0.92      0.93      4961\n",
      "weighted avg       0.97      0.97      0.97      4961\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_evaluate_rf(x_train, y_train, x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SGD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sgd_hyptune(x_train, y_train):\n",
    "    params = {\n",
    "        'penalty': ['l1', 'l2'],\n",
    "        'alpha': [0.0001, 0.001, 0.01],\n",
    "        'learning_rate': ['constant', 'optimal', 'invscaling'],\n",
    "        'max_iter': [1000, 2000, 3000]\n",
    "    }\n",
    "\n",
    "    start_time = time.time()\n",
    "    print('Training started..')\n",
    "\n",
    "    clf = GridSearchCV(\n",
    "            estimator=SGDClassifier(), \n",
    "            param_grid=params, \n",
    "            cv=5, \n",
    "            return_train_score=True\n",
    "          )\n",
    "    clf.fit(x_train, y_train)\n",
    "\n",
    "    print('Training ended..')\n",
    "    end_time = time.time()\n",
    "\n",
    "    total_training_time = str(datetime.timedelta(seconds=end_time-start_time))\n",
    "    mean_train_score = np.nanmean(clf.cv_results_['mean_train_score'], axis=0)\n",
    "    mean_val_score = np.nanmean(clf.cv_results_['mean_test_score'], axis=0)\n",
    "    \n",
    "    print('\\nResults:\\n')\n",
    "    print(f'Best params = {clf.best_params_}')\n",
    "    print(f'Best score = {clf.best_score_}')\n",
    "    print(f'Mean train score = {mean_train_score}')\n",
    "    print(f'Mean val  score = {mean_val_score}')\n",
    "    print(f'Total training time = {total_training_time}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started..\n",
      "Training ended..\n",
      "\n",
      "Results:\n",
      "\n",
      "Best params = {'alpha': 0.001, 'learning_rate': 'optimal', 'max_iter': 1000, 'penalty': 'l1'}\n",
      "Best score = 0.8926149425287356\n",
      "Mean train score = 0.888176883780332\n",
      "Mean val  score = 0.8879214559386973\n",
      "Total training time = 0:00:03.177487\n"
     ]
    }
   ],
   "source": [
    "sgd_hyptune(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_sgd(x_train, y_train, x_test, y_test):\n",
    "    sgd = SGDClassifier(alpha=0.001, learning_rate='optimal', penalty='l1', max_iter=1000)\n",
    "    sgd.fit(x_train, y_train)\n",
    "    y_pred = sgd.predict(x_test)\n",
    "\n",
    "    # Results.\n",
    "    cm = confusion_matrix(y_test, y_pred)\n",
    "    cm_df = pd.DataFrame(cm)\n",
    "    \n",
    "    classif_rep = classification_report(y_pred, y_test)\n",
    "    print('Classification report:\\n')\n",
    "    print(classif_rep)\n",
    "    print()\n",
    "    \n",
    "    sn.heatmap(cm_df, annot=True, cmap='Blues', fmt='g')\n",
    "    plt.title('Confusion Matrix (Test Data)') \n",
    "    plt.xlabel('Predicted') \n",
    "    plt.ylabel('True') \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.89      0.98      0.94      3970\n",
      "           1       0.89      0.53      0.67       991\n",
      "\n",
      "    accuracy                           0.89      4961\n",
      "   macro avg       0.89      0.76      0.80      4961\n",
      "weighted avg       0.89      0.89      0.88      4961\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_evaluate_sgd(x_train, y_train, x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oversampled results summary of core classifiers\n",
    "Here, recall & f1 are of label 1 only. Accuracy represents the overall models performance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Classifier                  \t| Recall \t| F1   \t| Accuracy \t|\n",
    "|-----------------------------\t|--------\t|------\t|----------\t|\n",
    "| Logistic Regression         \t| 0.54   \t| 0.67 \t| 0.90     \t|\n",
    "| SVM                         \t| 0.52   \t| 0.65 \t| 0.89     \t|\n",
    "| Decision Tree               \t| 0.84   \t| 0.88 \t| 0.97     \t|\n",
    "| Random Forest               \t| 0.85   \t| 0.87 \t| 0.97     \t|\n",
    "| Stochastic Gradient Descent \t| 0.53   \t| 0.67 \t| 0.89     \t|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Core ensemble methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_results(y_test, y_pred):\n",
    "    \"\"\"\n",
    "    Generate Confusion Matrix and Classification Report for\n",
    "    a given pair of y_pred and y_test values\n",
    "    \"\"\"\n",
    "    cm = confusion_matrix(y_test, y_pred)\n",
    "    cm_df = pd.DataFrame(cm)\n",
    "    \n",
    "    report = classification_report(y_pred, y_test)\n",
    "    print(f\"Classification Report: \\n{report}\\n\")\n",
    "    \n",
    "    sn.heatmap(cm_df, annot=True, cmap=\"Blues\", fmt=\"g\")\n",
    "    plt.title(\"Confustion Matrix (Test Data)\")\n",
    "    plt.xlabel(\"Predicted\")\n",
    "    plt.ylabel(\"True\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Voting classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_voting(x_train, y_train, x_test, y_test):\n",
    "    rf_clf = RandomForestClassifier(criterion=\"entropy\", max_depth=50, n_estimators=30)\n",
    "    lr_clf = LogisticRegression(C=1.0, penalty='l2')\n",
    "    dt_clf = DecisionTreeClassifier(criterion='entropy', max_depth=100)\n",
    "    \n",
    "    ensemble = [\n",
    "        (\"rf\", rf_clf),\n",
    "        (\"lr\", lr_clf),\n",
    "        (\"dt\", dt_clf)\n",
    "    ]\n",
    "\n",
    "    voting_clf = VotingClassifier(estimators=ensemble)\n",
    "    voting_clf.fit(x_train, y_train)\n",
    "    y_pred = voting_clf.predict(x_test)\n",
    "    \n",
    "    # Results\n",
    "    generate_results(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report: \n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.98      4313\n",
      "           1       0.92      0.85      0.88       648\n",
      "\n",
      "    accuracy                           0.97      4961\n",
      "   macro avg       0.95      0.92      0.93      4961\n",
      "weighted avg       0.97      0.97      0.97      4961\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_evaluate_voting(x_train, y_train, x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Adaboost classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_adaboost(x_train, y_train, x_test, y_test):\n",
    "    rf_clf = RandomForestClassifier(criterion=\"entropy\", max_depth=50, n_estimators=30)\n",
    "    adaboost_clf = AdaBoostClassifier(base_estimator=rf_clf)\n",
    "    \n",
    "    adaboost_clf.fit(x_train, y_train)\n",
    "    y_pred = adaboost_clf.predict(x_test)\n",
    "        \n",
    "    generate_results(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report: \n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.98      4331\n",
      "           1       0.89      0.85      0.87       630\n",
      "\n",
      "    accuracy                           0.97      4961\n",
      "   macro avg       0.94      0.92      0.93      4961\n",
      "weighted avg       0.97      0.97      0.97      4961\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_evaluate_adaboost(x_train, y_train, x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Bagging classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_bagging(x_train, y_train, x_test, y_test):\n",
    "    rf_clf = RandomForestClassifier(criterion=\"entropy\", max_depth=50, n_estimators=30)\n",
    "    bagging_clf = BaggingClassifier(base_estimator=rf_clf)\n",
    "    \n",
    "    bagging_clf.fit(x_train, y_train)\n",
    "    y_pred = bagging_clf.predict(x_test)\n",
    "    \n",
    "    generate_results(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report: \n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.98      4313\n",
      "           1       0.92      0.84      0.88       648\n",
      "\n",
      "    accuracy                           0.97      4961\n",
      "   macro avg       0.95      0.92      0.93      4961\n",
      "weighted avg       0.97      0.97      0.97      4961\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEWCAYAAACZnQc8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAlA0lEQVR4nO3deZzVZd3/8dd7BllcQEBAHDBR0VK8Q1HELMMt0FSoO7tpEW+jUMNcy6VN6xfl3aJmLoUr3KZE5kIuuaCkFgqoJAIu3GGKIBAIgQsKfH5/fK/B43TmzBmYmTN8fT99fB/zPdd3u74z+DnX+Xyvc12KCMzMLB+qKl0BMzNrOg7qZmY54qBuZpYjDupmZjnioG5mliMO6mZmOeKgvoWR1EHSHyWtkvT7Jj73ryV9rynPWQmS1kjadROP/ZSkO5q4Sq2WpP+Q9NdK18OajoN6M5H0RUkzU4BZLOleSR9vglN/DugBdI2I4zejfv8t6bHCsog4JSL+3+ZWsMi1LpIUkk6vU35mKr+ozPNMlfTVhvaLiG0j4u+bWN0fAxdL2jn97WqXkPRGwetPNPbEkl6SdESJ7YMlbSi4xkJJkyQd0IhrXCTppnL3j4hngJWSji33GGvdHNSbgaSzgcvIAkQPYGfgKmBYE5z+Q8ALEbGuCc7Vkl4ATqxTNjKVNwlJbTbz+AOAThHxeES8nN4cto2IbdMuHy0oe3Tza1zUonS97YBBwHPAo5IOb6brAfwWOLkZz28tKSK8NOECdALWAMeX2KcdWdBflJbLgHZp22BgIXAOsBRYDJyUtv0AeAd4N11jFHARcFPBuXcBAmiTXv838HdgNbAA+BLwEeBtYH06z8q0743AjwrO9TVgPrACmAzsVLAtgFOAF4HXgSsB1XO/FwE3AfOAvVPZ3un1TcBFqawzcBewLJ3zLqBX2jY21fftVOcrCuoxJtVjQUHZ7kBbYBbwjVReDfwF+H499fw+cG092wLYveDv93PgZWAJ8GugQ9q2Q6r3yvR7e5Ss8fS/wAbgrVT/c4tcYzCwsEj5FcDMgte/BF4B/gU8CXwilQ+t8+/jb6n8pPS7Xp3+LZxc5/w1qV7tKv3/j5fNX9xSb3oHAe2B20vs8x2yVlh/4KPAQOC7Bdt3JHtzqCEL3FdK6hwRF5K1/n8XWWvxulIVkbQNcDlwVERsB3wMmBUR88gC8rR0nu2LHHsY8BPg80BP4B/AxDq7HQMckO7h88CQUvUhC2wj0/qJwIQ626uAG8g+jexMFmiuAIiI75AFyNNSnU8rOG44cCCwV+HJIuId4MvADyV9BDifLLCPrad++wDPN3APAP8D7EH299ud7O/0/bTtHLI35W5kn9K+nVUlTiB7Ezg21f+nZVyn1m3AfunvCTAjXbsLcDPwe0ntI+JPvP/fx0fT/kvJ/lYdyQL8pZL2qz15RLxK9kawZyPqZK2Ug3rT6wr8M0qnR74E/DAilkbEMrIW+AkF299N29+NiHvIWl2b+j/cBqCfpA4RsTgi5pR53JeA6yPiqYhYC1wAHCRpl4J9Lo6IlRHxMvAwWaAp5SbgC5K2Akak1xtFxPKI+ENEvBkRq8mC7yfLqOtPImJFRLxVd0NEPAv8iOxN9pvACRGxvp7zbE/Wmq2XJJF9gjkrXXM1WSAdkXZ5l+xN8EPp7/doRGzuAEuLAKX6ERE3pd/Vuoj4Bdknh3r/fUTE3RHxf5H5M3A/UPeZwOra89uWzUG96S0Hdmggv7sTWcu31j9S2cZz1HlTeBPYlkaKiDeA/yJrlS+WdLekD5d5+PvqGBFryO6tpmCf1xpTxxT855MFwRcj4pXC7ZK2lvQbSf+Q9C/gEWB7SdUN1PWVBraPJ0tL3RMRL5bY73WyXHYp3YCtgSclrZS0EvhTKgf4Gdk93i/p75LOb+B85aghS/+sBJB0jqR5qQfUSrJPdTvUd7CkoyQ9LmlF2v/oIvtvV3t+27I5qDe9aWR53+El9llElmKotXMq2xRvkAWZWjsWboyI+yLiSLLW43PANbWbGjjv++qYPvp3BV7dxHrWmkCWoqibeiGV7wkcGBEdgUNqL59+1lfnhu7lKrI895AGeiA9Q5ZWKeWfZGmhvSNi+7R0ivQwNSJWR8Q5EbErcCxwdsFDzk1tsX8GeCoi3ki9bs4jS3d1TqmzVdTzO5LUDvgD2TOAHmn/ewr2R9JOZM8fykk9WSvnoN7EImIVWX71SknDU+tzq9Raqs2j3gJ8V1I3STuk/cvuhlbHLOCQ1AWvE1maBABJPSQdlwLyWrI0Tm3qYQnQS1Lbes57M3CSpP4pMPwYeCIiXtrEetb6HfApYFKRbduRBcyVkroAF9bZvgRoVP9zSScAA8geGJ8OjJdU3yeKe2gg3RMRG8jeGC+V1D1do0bSkLR+jKTdU5rmX2S/78LfeVn1V6ZG0oXAV8ly85D9jtaRPUxuI+n7ZLnyWkuAXSTV/r/dliw9swxYJ+kost9/ocHAQynNZls4B/VmEBGXAGeTPfxcRpYeOA24I+3yI2AmWctwNvBUKtuUaz1AFiifIesJcVfB5iqy1u8isp4YnwS+nrY9BMwBXpP0zyLnnQJ8j6yVtxjYjffyxpssIt6KiAeL5b/JegF1IGsNP06W1ij0S+Bzkl6XdHlD15K0czrnyIhYExE3k/3eL62nbk8BqyQd2MCpzyNLsTye0kQP8l5Ou296vYbsU9tVETE1bfsJ2Zv5SknfrOfcO0lak46fQfbwdnBE3J+23wfcS9YV9B9knwoL00+1X0hbLumplPM/nexN9HXgi2Q9mQp9iawHj+WANv8Zjll+SPoU8PWIGF7purQESfsA4yLioErXxZqGg7qZWY44/WJmliMO6mZmOeKgbmaWI5s1AFJz6rDvaU72279Z/sSvKl0Fa4W2bis1vFdpjYk5bz19xWZfr7m02qBuZtailI/EhYO6mRnA5jf2WwUHdTMzcEvdzCxX3FI3M8uRqoYGA90yOKibmYHTL2ZmueL0i5lZjrilbmaWI26pm5nlSE5a6vm4CzOzzVVVXf5SBknVkp6WdFd63UXSA5JeTD87F+x7gaT5kp6vnUUrlQ+QNDttuzzNqFX6Njbh1s3M8kdV5S/lOQOYV/D6fGBKRPQFpqTXSNqLbFaxvYGhwFUFk61fDYwmm1Grb9pekoO6mRlAlcpfGiCpF/Bp4NqC4mHA+LQ+nvcmpx8GTIyItRGxgGyqxIGSegIdI2JaZLMZTaD0hPbZbZR3t2ZmOdeIlrqk0ZJmFiyj65ztMuBcYENBWY+IWAyQfnZP5TW8f57ZhamsJq3XLS/JD0rNzKBRvV8iYhwwrvhpdAywNCKelDS4nCsXu0SJ8pIc1M3MoCmHCTgYOE7S0UB7oKOkm4AlknpGxOKUWlma9l8I9C44vhewKJX3KlJektMvZmbQZA9KI+KCiOgVEbuQPQB9KCK+DEwGTky7nQjcmdYnAyMktZPUh+yB6PSUolktaVDq9TKy4Jh6uaVuZgYt8eWji4FJkkYBLwPHA0TEHEmTgLnAOmBMRKxPx5wK3Ah0AO5NS0kO6mZm0CxfPoqIqcDUtL4cOLye/cYCY4uUzwT6NeaaDupmZuBhAszMciUnwwQ4qJuZgSfJMDPLFbfUzcxyxDl1M7MccUvdzCxH3FI3M8sRt9TNzPJDVQ7qZma5UcakQlsEB3UzMyg+0O0WyEHdzAy31M3McsVB3cwsR6r8oNTMLEfy0VB3UDczA6dfzMxyJS9BPR9JJDOzzSSp7KWB87SXNF3S3yTNkfSDVH6RpFclzUrL0QXHXCBpvqTnJQ0pKB8gaXbadrnKeOdxS93MjCZtqa8FDouINZK2Ah6TVDu36KUR8fM6192LbILqvYGdgAcl7ZHmKb0aGA08DtwDDKWBeUrdUjczA1SlspdSIrMmvdwqLVHikGHAxIhYGxELgPnAQEk9gY4RMS0iApgADG/oPhzUzcxoXPpF0mhJMwuW0XXOVS1pFrAUeCAinkibTpP0jKTrJXVOZTXAKwWHL0xlNWm9bnlJDupmZjQuqEfEuIjYv2AZV3iuiFgfEf2BXmSt7n5kqZTdgP7AYuAXtZcuUp0oUV6Sg7qZGWQhtNylTBGxEpgKDI2IJSnYbwCuAQam3RYCvQsO6wUsSuW9ipSX5KBuZkaT9n7pJmn7tN4BOAJ4LuXIa30GeDatTwZGSGonqQ/QF5geEYuB1ZIGpV4vI4E7G7oP934xM6NJe7/0BMZLqiZrOE+KiLsk/a+k/mQplJeAkwEiYo6kScBcYB0wJvV8ATgVuBHoQNbrpWTPF3BQNzMDmm7sl4h4Bti3SPkJJY4ZC4wtUj4T6NeY6zuom5mBx34xM8uTvAwT4KBuZoaDuplZrjiom5nlSENf/99SOKhXUFWV+Mtvz2XR0lX85xm/5sdnDufoQ/rxzrvrWbDwn4y+8CZWrXkLgH59d+KK736B7bZpz4YNwce//FPWvrOOO6/4Ojt260ib6mr+8vT/ceZPfseGDQ1+6cy2ABd979s88shUunTpyq23/xGAVatWct43z2bRolfZaacafvrzS+nYqRMrV77Ot84+gznPPstxw4Zz/ne+X+Hab3ny0lL3l48q6LQvHsrzC5ZsfD3l8ecYcPyPGfhfP+HFfyzlW1/5FADV1VVc/6MT+cbYiQz43FiGfO2XvLsu68b65fOu58D/upgBnxtLt87b8p9H7leRe7Gmd+ywz3Dl1de8r+yG665h4IGDmHz3fQw8cBA3XJdtb9e2HV8/7QzO+ua5lahqLjTVl48qzUG9Qmq6b8/Qj+/NDbf/dWPZlMefY/36DQBMn72Amh7bA3DEQR/m2RdfZfYLrwKwYtUbG1vjq994G4A2barYqk012WBulgcD9j+ATp06va9s6sNTOHbYcACOHTachx9+EIAOW2/NvvsNoF3bti1dzdzIS1BvtvSLpA+TDSlZQ/YNqkXA5IiY11zX3JL87Fv/yXd+eQfbbt2+6PaRww7i1vufAqDvzt2JgMlXjmGHztty631Pcsn4BzfuO/nKMezf70Pc/5e53Pbg0y1Sf6uM5cuX061bdwC6devOiuUrKlyjHGndsbpszdJSl3QeMJHs1zQdmJHWb5F0fonjNg5nue6fc5qjaq3CUZ/ox9IVq3l63itFt587agjr129g4j0zAGhTXc3H9t2Vk75zI4d/5RKOO+yjDB64x8b9jxtzJX2O/Dbt2rZh8AF7tsg9mOWNW+qljQL2joh3CwslXQLMAS4udlAavnIcQId9T8ttHuGg/rtyzCf3YejH96Zd263ouE17rv/RSL7y3Ql86dgDOfqQfhx18uUb93916UoefXI+y1e+AcCfHpvDvh/uzdTpL2zcZ+0767jrz7M5dvA+PPTEcy1+T9YyunbtyrJlS+nWrTvLli2lS9cula5SblTlpPdLc+XUN5BNy1RXz7TtA+37v5rM7kO/x4c/fSEjz7+BqTNe4CvfncCRH/sI5/z3EXzuzN/w1tvvvR8+8Ne59OtbQ4f2W1FdXcUnBuzOvL+/xjYd2rLjDh2B7GHq0IP34vmXltR3WcuBTw4+jD/eeQcAf7zzDgYfenhlK5QjbqmXdiYwRdKLvDejx87A7sBpzXTNLd6l532edm3bcNfV2a9o+uyXOH3sRFaufovLb3qIx246l4jgvsfm8KfH5tC9y3bcetnJtN2qDdXVVfx5xgtcc+tjFb4Layrnn3s2T86YwcqVrzPk8E9yyphvcNKor3HeN8/ijtv/QM+ePfnpLy7buP/RQw7jjTVv8O677/LwQ1O4atx17Lbb7pW7gS1MK4/VZVNz9ZaQVEU2CHwNWT59ITCjYEjJkvKcfrFNt/yJX1W6CtYKbd1280PynufdV3bMef5/hrTat4Bm6/2SZvd4vLnOb2bWlPLSUvc3Ss3M8INSM7NcqapS2UspktpLmi7pb5LmSPpBKu8i6QFJL6afnQuOuUDSfEnPSxpSUD5A0uy07XKV8ZTWQd3MjCz9Uu7SgLXAYRHxUaA/MFTSIOB8YEpE9AWmpNdI2gsYAewNDAWuSlPhAVwNjCabt7Rv2l6Sg7qZGU3XpTEya9LLrdISZN+wH5/KxwPD0/owYGJErI2IBcB8YGCaqLpjREyLrEfLhIJj6uWgbmZG0/ZTl1QtaRawFHggIp4AekTEYoD0s3vavYb3un5D1lOwJi0Li5SX5KBuZkbj0i+FQ5qkZXThuSJifUT0B3qRtbpLTR5d7F0iSpSX5N4vZmY0rvdL4ZAmDey3UtJUslz4Ekk9I2JxSq0sTbstBHoXHNaLbADEhWm9bnlJbqmbmdF06RdJ3SRtn9Y7AEcAzwGTgRPTbicCd6b1ycAISe0k9SF7IDo9pWhWSxqUer2MLDimXm6pm5nRpF8+6gmMTz1YqoBJEXGXpGnAJEmjgJeB4wEiYo6kScBcYB0wpuCb96cCNwIdgHvTUpKDupkZTTedXUQ8A+xbpHw5UHQEtogYC4wtUj4TKJWP/zcO6mZmeJgAM7Ncae1D6pbLQd3MjPyM/eKgbmaG0y9mZrni9IuZWY7kJKY7qJuZgVvqZma54qBuZpYj7v1iZpYjOWmoO6ibmYHTL2ZmuZKTmO6gbmYGUJWTqO6gbmaGH5SameVKTmK6g7qZGfhBqZlZruQkpnuOUjMzADXiv5LnkXpLeljSPElzJJ2Ryi+S9KqkWWk5uuCYCyTNl/S8pCEF5QMkzU7bLlcZHyfcUjczo0lz6uuAcyLiKUnbAU9KeiBtuzQifl64s6S9gBHA3sBOwIOS9kjzlF4NjAYeB+4BhtLAPKVuqZuZkfV+KXcpJSIWR8RTaX01MA+oKXHIMGBiRKyNiAXAfGCgpJ5Ax4iYFhEBTACGN3gfZd2tmVnOVUllL5JGS5pZsIwudk5Ju5BNQv1EKjpN0jOSrpfUOZXVAK8UHLYwldWk9brlpe+jcbdtZpZPUvlLRIyLiP0LlnH/fj5tC/wBODMi/kWWStkN6A8sBn5Ru2uR6kSJ8pKcUzczo2m7NEraiiyg/zYibgOIiCUF268B7kovFwK9Cw7vBSxK5b2KlJfklrqZGY1rqZc+jwRcB8yLiEsKynsW7PYZ4Nm0PhkYIamdpD5AX2B6RCwGVksalM45ErizoftwS93MDKhuupb6wcAJwGxJs1LZt4EvSOpPlkJ5CTgZICLmSJoEzCXrOTMm9XwBOBW4EehA1uulZM8XcFA3MwOaLv0SEY9RPB9+T4ljxgJji5TPBPo15voO6mZmeOwXM7Nc8dgvZmY5kpOY3nDvF2W+LOn76fXOkgY2f9XMzFqOsi8VlbW0ZuV0abwKOAj4Qnq9Griy2WpkZlYB1VUqe2nNykm/HBgR+0l6GiAiXpfUtpnrZWbWolp3qC5fOUH9XUnVpK+nSuoGbGjWWpmZtbC8zFFaTvrlcuB2oLukscBjwI+btVZmZi2sqb5RWmkNttQj4reSngQOJ/uEMjwi5jV7zczMWlBrfwBargaDuqSdgTeBPxaWRcTLzVkxM7OWlJOYXlZO/W7eGwayPdAHeJ5slg4zs1xo7b1aylVO+mWfwteS9iMNRGNmlhcfmPRLXWnevQOaozKFXp9xRXNfwrZAr616u9JVsFZol67tN/sceRmHvJyc+tkFL6uA/YBlzVYjM7MK+CC11LcrWF9HlmP/Q/NUx8ysMnKSUi8d1NOXjraNiG+1UH3MzCoi9w9KJbWJiHXpwaiZWa7lJKaXfDYwPf2cJWmypBMkfbZ2aYnKmZm1lCaco7S3pIclzZM0R9IZqbyLpAckvZh+di445gJJ8yU9L2lIQfkASbPTtstVRuK/nAe+XYDlwGHAMcCx6aeZWW5USWUvDVgHnBMRHwEGAWMk7QWcD0yJiL7AlPSatG0E2Xd/hgJXpdQ3wNXAaLLJqPum7SWVyql3Tz1fnuW9Lx/VioZObGa2JWmqLo0RsRhYnNZXS5oH1ADDgMFpt/HAVOC8VD4xItYCCyTNBwZKegnoGBHTACRNAIbTwOTTpYJ6NbAtxUekdFA3s1xpTI9GSaPJWtC1xkXEuCL77QLsCzwB9EgBn4hYLKl72q0GeLzgsIWp7N20Xre8pFJBfXFE/LChE5iZ5UFjer+kAP5vQbyQpG3Jun+fGRH/KpEOr6/hvEkN6lJBPSfPgs3MGtaUvV8kbUUW0H8bEbel4iWSeqZWek9gaSpfCPQuOLwXsCiV9ypSXlKpNNLhZdbfzGyL11QPSlMPleuAeRFxScGmycCJaf1E4M6C8hGS2knqQ/ZAdHpK1ayWNCidc2TBMfWqt6UeESsaOtjMLC+acJSAg4ETgNmSZqWybwMXA5MkjQJeBo4HiIg5kiYBc8l6zoyJiPXpuFOBG4EOZA9ISz4khU0Y0MvMLI+aKv0SEY9Rf/q6aAYkIsYCY4uUzwT6Neb6DupmZoBy8hjRQd3MDGiTk7F3HdTNzPhgDb1rZpZ7eRnQy0HdzIwP1sTTZma5V8ZAXVsEB3UzM6DaD0rNzPKjyl0azczyIyfZFwd1MzNw7xczs1zxg1IzsxzJSUx3UDczg8ZNktGaOaibmdF0c5RWmoO6mRke+8XMLFfyEdId1M3MgPz0fslLGsnMbLOoEUuD55Kul7RU0rMFZRdJelXSrLQcXbDtAknzJT0vaUhB+QBJs9O2y1VGjshB3cwMqKpS2UsZbgSGFim/NCL6p+UeAEl7ASOAvdMxV0mqTvtfDYwmm4y6bz3nfP99lFM7M7O8q2rE0pCIeARYUealhwETI2JtRCwA5gMDJfUEOkbEtIgIYAIwvJz7MDP7wJPUmGW0pJkFy+gyL3OapGdSeqZzKqsBXinYZ2Eqq0nrdctLclA3M6NxOfWIGBcR+xcs48q4xNXAbkB/YDHwi4JL1xUlykty7xczM5q/n3pELCm41jXAXenlQqB3wa69gEWpvFeR8pLcUjczA6qlspdNkXLktT4D1PaMmQyMkNROUh+yB6LTI2IxsFrSoNTrZSRwZ0PXcUvdzIym/fKRpFuAwcAOkhYCFwKDJfUnS6G8BJwMEBFzJE0C5gLrgDERsT6d6lSynjQdgHvTUvra2UPV1uftdQ3njuyD57VVb1e6CtYK7dK1/WbH5Dtnv1Z2zBm2z46t9ptKbqmbmeHp7MzMciUnowQ4qJuZAcgtdTOz/NjUXi2tjYO6mRlOv5iZ5YqDuplZjjinbmaWIzmZd9pB3cwM8jPzkYO6mRlOv1gzOurIw9h6m22orqqiuk01t0y6jVUrV3LuN89i0auvslNNDT/7xWV07NSp0lW1ZjTys0fRYeutqaquprq6miuuv2Xjtt/fPJ5rr7iESfdMpdP2nXnovrv5/c3jN25fMP8FrrxhIrvt8eFKVH2L5PSLNatrbxhP585dNr6+/tpxDDzwIEZ9bTTXXTOO664dx1nnfKuCNbSW8NMrrqXT9p3fV7Z0yWs8PX0a3Xu8N+jfYUM+zWFDPg3Agv97kYvOO8MBvZHy0lL30LtbiIcfnsJxw4cDcNzw4Tz80IOVrZBVzG9++TNGjTmr3vG/H37gXgYfcVQL12rLJ5W/tGYO6q2R4JSvjWLE8Z/l1km/A2DF8uV069YdgG7durNiRbnTH9oWS/DtM09hzEkjuOeOWwGY9uhUdujWnd367lnvYY88eB+HHtng/MRWR2NmPmrNWjz9IumkiLihnm2jyWbO5oqrfsOor5U77V++jL/pFrp378Hy5cs55asn0WfXXStdJauAS389nq7durNyxXLOP/MUen+oD7eMv4afXPbreo95bs4ztGvfnl1269uCNc0HDxOw6X4AFA3qaZ6/cfDBHk+9e/ceAHTt2pXDjjiSZ2c/Q5euXVm2bCndunVn2bKldOnSpYGz2Jaua/pktn2Xrhx8yGE8M2smry16lVNHfh6AZcuWMOakEVx+7W/p0nUHAKY+eB+Dj3TqZZPkI6Y3T/olzZZdbJkN9GiOa+bFm2++yRtvrNm4Pu2vf2H33fsy+NDDmHzHHQBMvuMODj308ArW0prb22+9yZtvvLFx/cnp09jjI/2YdM9UJtx2LxNuu5du3Xpw5Q0TNwb0DRs28OhD9zP4CKdeNoUa8V9r1lwt9R7AEOD1OuUC/tpM18yFFcuXc9bpYwBYt349R3/6GA7+xCHsvc8+fOvsM7njtlvZsWdPfn7JLytcU2tOr69YwQ8uOAuA9evXceiRR3PAoINLHjN71pPs0L0HPWt6ldzPimvK7Iuk64FjgKUR0S+VdQF+B+xCNp3d5yPi9bTtAmAUsB44PSLuS+UDeG86u3uAM6KB6eqaZTo7SdcBN0TEY0W23RwRX2zoHB/k9IvVz9PZWTFNMZ3djL+vKjvmHLBrp5LXk3QIsAaYUBDUfwqsiIiLJZ0PdI6I8yTtBdwCDAR2Ah4E9oiI9ZKmA2cAj5MF9csjouQ8pc2SfomIUcUCetrWYEA3M2txTdj9JSIeAep2URsG1H5DbDwwvKB8YkSsjYgFwHxgoKSeQMeImJZa5xMKjqmXuzSamZGN/VLuImm0pJkFSzld9XpExGKA9LN7Kq8BXinYb2Eqq0nrdctL8jdKzcxoXOeXwp56zXTpKFFeklvqZmbQEt8+WpJSKqSfS1P5QqB3wX69gEWpvFeR8pIc1M3MaJEujZOBE9P6icCdBeUjJLWT1AfoC0xPKZrVkgYpGxNiZMEx9XL6xcyMJu/SeAswGNhB0kLgQuBiYJKkUcDLwPEAETFH0iRgLrAOGBMR69OpTuW9Lo33pqX0tZujS2NTcJdGK8ZdGq2YpujS+LdXVpcdcz7ae7tW+w0kt9TNzMjP0LsO6mZmtP4hdcvloG5mRm7G83JQNzMDchPVHdTNzHBO3cwsVzzxtJlZnjiom5nlh9MvZmY54i6NZmY5kpOY7qBuZgbkJqo7qJuZkU2SkQcO6mZm5Kah7qBuZgbkJqo7qJuZ4S6NZma5kpOUuqezMzODLKiXuzR8Lr0kabakWZJmprIukh6Q9GL62blg/wskzZf0vKQhm3MfDupmZjTLHKWHRkT/iNg/vT4fmBIRfYEp6TWS9gJGAHsDQ4GrJFVv6n04qJuZ0bQt9XoMA8an9fHA8ILyiRGxNiIWAPOBgZt6EQd1MzOyzi/lLmUI4H5JT0oancp6RMRigPSzeyqvAV4pOHZhKtskflBqZkbjWuApUI8uKBoXEeMKXh8cEYskdQcekPRcqdMVKSt7Euy6HNTNzIDGdFRPAXxcie2L0s+lkm4nS6cskdQzIhZL6gksTbsvBHoXHN4LWNTIym/k9IuZGdkkGeUupUjaRtJ2tevAp4BngcnAiWm3E4E70/pkYISkdpL6AH2B6Zt6H26pm5nRpP3UewC3KzthG+DmiPiTpBnAJEmjgJeB4wEiYo6kScBcYB0wJiLWb+rFFbHJqZtm9fa6Tc8pWX69turtSlfBWqFdurbf7JD82qp3y445O3baqtV+VcktdTMz8NgvZmZ5kpOY7qBuZgb5GfvFQd3MDFBOorqDupkZTr+YmeVKThrqDupmZuBJMszMcsUtdTOzHHFQNzPLEadfzMxyxC11M7McyUlMd1A3MwNyE9Ud1M3McE7dzCxXGpr8YkvhoG5mBk6/mJnlidMvZmY5kpcuja12Ojt7j6TRafZys43878KKqap0BawsoytdAWuV/O/C/o2DuplZjjiom5nliIP6lsF5UyvG/y7s3/hBqZlZjrilbmaWIw7qZmY54qDeykkaKul5SfMlnV/p+ljlSbpe0lJJz1a6Ltb6OKi3YpKqgSuBo4C9gC9I2quytbJW4EZgaKUrYa2Tg3rrNhCYHxF/j4h3gInAsArXySosIh4BVlS6HtY6Oai3bjXAKwWvF6YyM7OiHNRbt2JDDLkPqpnVy0G9dVsI9C543QtYVKG6mNkWwEG9dZsB9JXUR1JbYAQwucJ1MrNWzEG9FYuIdcBpwH3APGBSRMypbK2s0iTdAkwD9pS0UNKoStfJWg8PE2BmliNuqZuZ5YiDuplZjjiom5nliIO6mVmOOKibmeWIg7o1C0nrJc2S9Kyk30vaejPOdaOkz6X1a0sNaiZpsKSPbcI1XpK0w6bW0ay1cFC35vJWRPSPiH7AO8AphRvTCJSNFhFfjYi5JXYZDDQ6qJvlhYO6tYRHgd1TK/phSTcDsyVVS/qZpBmSnpF0MoAyV0iaK+luoHvtiSRNlbR/Wh8q6SlJf5M0RdIuZG8eZ6VPCZ+Q1E3SH9I1Zkg6OB3bVdL9kp6W9BuKj7NjtsVpU+kKWL5JakM2HvyfUtFAoF9ELJA0GlgVEQdIagf8RdL9wL7AnsA+QA9gLnB9nfN2A64BDknn6hIRKyT9GlgTET9P+90MXBoRj0namezbuR8BLgQei4gfSvo0MLpZfxFmLcRB3ZpLB0mz0vqjwHVkaZHpEbEglX8K+I/afDnQCegLHALcEhHrgUWSHipy/kHAI7Xnioj6xhc/AthL2tgQ7yhpu3SNz6Zj75b0+qbdplnr4qBuzeWtiOhfWJAC6xuFRcA3IuK+OvsdTcNDDKuMfSBLMR4UEW8VqYvHyLDccU7dKuk+4FRJWwFI2kPSNsAjwIiUc+8JHFrk2GnAJyX1Scd2SeWrge0K9rufbFA00n790+ojwJdS2VFA56a6KbNKclC3SrqWLF/+VJpE+Tdknx5vB14EZgNXA3+ue2BELCPLg98m6W/A79KmPwKfqX1QCpwO7J8exM7lvV44PwAOkfQUWRro5Wa6R7MW5VEazcxyxC11M7MccVA3M8sRB3UzsxxxUDczyxEHdTOzHHFQNzPLEQd1M7Mc+f8qr+TMyY/oIwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_evaluate_bagging(x_train, y_train, x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oversampled results summary of core ensemble methods\n",
    "Here, recall & f1 are of label 1 only. Accuracy represents the overall models performance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Classifier          \t| Recall \t| F1   \t| Accuracy \t|\n",
    "|---------------------\t|--------\t|------\t|----------\t|\n",
    "| Voting Classifier   \t| 0.85   \t| 0.88 \t| 0.97     \t|\n",
    "| Adaboost Classifier \t| 0.85   \t| 0.87 \t| 0.97     \t|\n",
    "| Bagging Classifier  \t| 0.84   \t| 0.88 \t| 0.97    \t|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.4 ('venv': venv)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "faafacdf547457256517978ccd617e5232c831db2db3475f4239736a0901b48f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}