Classification with undersampling the dataset.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "In this notebook, we will apply undersampling 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.under_sampling import RandomUnderSampler\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 undersampling features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splitting into train and test sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before undersampling, X_train: (19842, 14)\n",
      "Before undersampling, y_train: (19842,)\n",
      "After undersampling, x_train: (4760, 14)\n",
      "After undersampling, y_train: (4760,)\n",
      "x_train shape = (4760, 14) | y_train shape = (4760,)\n",
      "x_test shape  = (4961, 14)  | y_test shape = (4961,)\n"
     ]
    }
   ],
   "source": [
    "# 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 undersampling, X_train: {x_train.shape}\")\n",
    "print(f\"Before undersampling, y_train: {y_train.shape}\")\n",
    "# Undersampling data\n",
    "undersampler = RandomUnderSampler(random_state=1)\n",
    "x_train, y_train = undersampler.fit_resample(x_train, y_train)\n",
    "print(f\"After undersampling, x_train: {x_train.shape}\")\n",
    "print(f\"After undersampling, 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": 7,
   "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": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started..\n",
      "Training ended..\n",
      "\n",
      "Results:\n",
      "\n",
      "Best params = {'C': 1.5, 'penalty': 'l2'}\n",
      "Best score = 0.8831932773109245\n",
      "Mean train score = 0.8828256302521007\n",
      "Mean val  score = 0.8829831932773109\n",
      "Total training time = 0:00:00.990300\n"
     ]
    }
   ],
   "source": [
    "log_reg_hyptune(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_log_reg(x_train, y_train, x_test, y_test):\n",
    "    log_reg = LogisticRegression(C=1.5, 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": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.87      0.98      0.92      3829\n",
      "           1       0.89      0.52      0.65      1132\n",
      "\n",
      "    accuracy                           0.87      4961\n",
      "   macro avg       0.88      0.75      0.79      4961\n",
      "weighted avg       0.88      0.87      0.86      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": 11,
   "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": 12,
   "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.8783613445378151\n",
      "Mean train score = 0.8790756302521008\n",
      "Mean val  score = 0.8774789915966388\n",
      "Total training time = 0:00:02.553754\n"
     ]
    }
   ],
   "source": [
    "svm_hyptune(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.87      0.98      0.92      3795\n",
      "           1       0.89      0.50      0.64      1166\n",
      "\n",
      "    accuracy                           0.87      4961\n",
      "   macro avg       0.88      0.74      0.78      4961\n",
      "weighted avg       0.87      0.87      0.85      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": 15,
   "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": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started..\n",
      "Training ended..\n",
      "\n",
      "Results:\n",
      "\n",
      "Best params = {'criterion': 'entropy', 'max_depth': 150}\n",
      "Best score = 0.9439075630252102\n",
      "Mean train score = 1.0\n",
      "Mean val  score = 0.9401260504201682\n",
      "Total training time = 0:00:00.688324\n"
     ]
    }
   ],
   "source": [
    "dt_hyptune(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_dt(x_train, y_train, x_test, y_test):\n",
    "    dt = DecisionTreeClassifier(criterion='entropy', max_depth=150)\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": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.93      0.99      0.96      4046\n",
      "           1       0.95      0.69      0.80       915\n",
      "\n",
      "    accuracy                           0.94      4961\n",
      "   macro avg       0.94      0.84      0.88      4961\n",
      "weighted avg       0.94      0.94      0.93      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": 21,
   "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": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started..\n",
      "Training ended..\n",
      "\n",
      "Results:\n",
      "\n",
      "Best params = {'criterion': 'gini', 'max_depth': 100, 'n_estimators': 30}\n",
      "Best score = 0.957563025210084\n",
      "Mean train score = 0.9980392156862745\n",
      "Mean val  score = 0.9544467787114845\n",
      "Total training time = 0:00:05.505907\n"
     ]
    }
   ],
   "source": [
    "rf_hyptune(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_rf(x_train, y_train, x_test, y_test):\n",
    "    rf = RandomForestClassifier(criterion='gini', max_depth=100, 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": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.95      0.99      0.97      4102\n",
      "           1       0.96      0.73      0.83       859\n",
      "\n",
      "    accuracy                           0.95      4961\n",
      "   macro avg       0.95      0.86      0.90      4961\n",
      "weighted avg       0.95      0.95      0.95      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": 25,
   "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": 26,
   "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': 3000, 'penalty': 'l1'}\n",
      "Best score = 0.8911764705882353\n",
      "Mean train score = 0.8845646591970122\n",
      "Mean val  score = 0.8834500466853409\n",
      "Total training time = 0:00:01.115307\n"
     ]
    }
   ],
   "source": [
    "sgd_hyptune(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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=3000)\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": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.88      0.98      0.93      3845\n",
      "           1       0.90      0.53      0.67      1116\n",
      "\n",
      "    accuracy                           0.88      4961\n",
      "   macro avg       0.89      0.76      0.80      4961\n",
      "weighted avg       0.88      0.88      0.87      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": [
    "### Undersampled 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.52  \t| 0.65 \t| 0.87     \t|\n",
    "| SVM                         \t| 0.50   \t| 0.64 \t| 0.87     \t|\n",
    "| Decision Trees              \t| 0.69   \t| 0.80 \t| 0.94     \t|\n",
    "| Random Forest               \t| 0.73   \t| 0.83 \t| 0.95     \t|\n",
    "| Stochastic Gradient Descent \t| 0.53   \t| 0.67 \t| 0.88     \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": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_voting(x_train, y_train, x_test, y_test):\n",
    "    sgd_clf = SGDClassifier(alpha=0.001, learning_rate='optimal', penalty='l1', max_iter=3000)\n",
    "    dt_clf = DecisionTreeClassifier(criterion='entropy', max_depth=150)\n",
    "    rf_clf = RandomForestClassifier(criterion='gini', max_depth=100, n_estimators=30)\n",
    "    \n",
    "    ensemble = [\n",
    "        ('sgd_clf', sgd_clf),\n",
    "        ('dt', dt_clf),\n",
    "        (\"rf\", rf_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": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report: \n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.94      0.99      0.97      4093\n",
      "           1       0.96      0.73      0.83       868\n",
      "\n",
      "    accuracy                           0.95      4961\n",
      "   macro avg       0.95      0.86      0.90      4961\n",
      "weighted avg       0.95      0.95      0.94      4961\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEWCAYAAACZnQc8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmCUlEQVR4nO3debxVVf3/8df7XnECZJAhQBRQNIcM/ano10qyZNK+qKmRpkgWVpKaWg6kOJaNJl+HxDS1VCKHRLMQp5QSBRFRxIFUZBKUKSYN8PP7Y6+LR7zDuXAu57J9P33sxz177bXXXvte/Jx1PnudvRURmJlZPlSUuwNmZlY6DupmZjnioG5mliMO6mZmOeKgbmaWIw7qZmY54qC+mZG0jaT7JS2V9OcSt/1bSReWss1ykLRcUrcN3LePpL+UuEuNlqS9Jf2r3P2w0nFQbyCSjpc0KQWYeZL+JulzJWj6GKA9sH1EHLsR/TtZ0vjCsoj4TkRctrEdrOZYF0sKSWesV35GKr+4yHYel/StuupFRLOIeH0Du3sFcKWkHdPfrmoJSSsK1j9f34YlvSnpy7Vs7yXpg4JjzJY0WtL+9TjGxZL+WGz9iJgKLJH0lWL3scbNQb0BSDoL+A3wE7IAvCNwHTCgBM3vBLwaEWtK0Nam9Cpw0nplg1J5SUjaYiP33x9oERETIuKt9ObQLCKapSqfLSh7cuN7XK256XjNgQOBl4EnJX2pgY4HcDtwagO2b5tSRHgp4QK0AJYDx9ZSZyuyoD83Lb8BtkrbegGzgbOBBcA8YHDadgnwX2B1OsYpwMXAHwva7gIEsEVaPxl4HVgGvAGcAOwOvAesTe0sSXVvAS4vaOvbwAxgETAG6FiwLYDvAK8BS4BrAdVwvhcDfwSmA3umsj2Bl1L5xamsFfAA8A6wOL3eIW27IvX3vdTnawr6cVrqxxsFZbsAWwJTgO+n8krgn8BFNfTzIuB3NWwLYJeCv98vgbeA+cBvgW3Stjap30vS7+1JssHTH4APgFWp/z+q5hi9gNnVlF8DTCpYvxqYBfwHeBb4fCrvu96/j+dT+eD0u1+W/i2cul77nVK/tir3/z9eNn7xSL30DgK2Bu6tpc4wslFYD+CzwAHAjwu2f4rszaETWeC+VlKriBhONvr/U2SjxZtq64ikpsAIoF9ENAf+B5gSEdPJAvJTqZ2W1ex7KPBT4DigAzATGLVetSOA/YG9U70+tfWHLLBVjdYHpfVCFcDvyT6N7EgWaK4BiIhhZAFyaOrz0IL9jgR6AnsUNhYR/wW+AVwqaXfgPLLAfkUN/fsM8Eod5wBwJbAr2d9vF7K/00Vp29lkb8ptyT6lXZB1JU4kexP4Sur/z4s4TpV7gH3T3xNgYjp2a+AO4M+Sto6Iv/PRfx+fTfUXkP2ttiML8FdJ2req8YiYQ/ZGsFs9+mSNlIN66W0PvBu1p0dOAC6NiAUR8Q7ZCPzEgu2r0/bVEfEg2ahrQ/+H+wDYS9I2ETEvIqYVud8JwM0RMTki3gfOBw6S1KWgzpURsSQi3gIeIws0tfkj8HVJTYCBaX2diFgYEXdHxMqIWEYWfA8poq8/jYhFEbFq/Q0R8SJwOfAX4BzgxIhYW0M7LclGszWSJGAI8IN0zGVkgXRgqrKa7E1wp/T3ezIiNvYGS3MBpf4REX9Mv6s1EfErsk8ONf77iIi/RsS/I/MP4CFg/WsCy6rat82bg3rpLQTa1JHf7Ug28q0yM5Wta2O9N4WVQDPqKSJWAF8jG5XPk/RXSZ8ucveP9DEilpOdW6eCOm/Xp48p+M8gC4KvRcSswu2StpV0g6SZkv4DPAG0lFRZR19n1bH9VrLR/4MR8Vot9RaT5bJr0xbYFnhW0hJJS4C/p3KAX5Cd40OSXpd0Xh3tFaMTWfpnCYCkcyRNTzOglpB9qmtT086S+kmaIGlRqt+/mvrNq9q3zZuDeuk9BbxPlhKoyVyyIFNlx1S2IVaQBZkqnyrcGBFjI+IwstHjy8CNVZvqaPcjfUwf/bcH5mxgP6vcRpaiuK2abWeTjTh7RsR2wBeqDp9+1tTnus7lOrI8d586ZiBNJUur1OZdsrTQnhHRMi0tIl1MjYhlEXF2RHQD/hc4q+Ai54aO2I8CJkfEijTr5kdk6a5WKXW2lBp+R5K2Au4muwbQPtV/sKA+kjqRXX8oJvVkjZyDeolFxFKy/Oq1ko5Mo88mabRUlUe9E/ixpLaS2qT6RU9DW88U4AtpCl4LsjQJAJLaSxqQAvL7ZGmcD9Lm+cAOkrasod07gcGSeqTA8BPg6Yh4cwP7WeVPQG9gdDXbmpMFzCWSWgPD19s+H6jX/HNJJwL/j+yC8enArZJq+kTxIHWkeyLiA7I3xqsktUvH6CSpT3p9hKRdUppmKdnF3cLfeVH9V6aTpOHAt8hy85D9jtaQXUzeQtJFZLnyKvOBLpKq/t/ekiw98w6wRlI/st9/oUOAR1OazTZzDuoNIOU5zyK7+PkOWXpgKFleF7Ic7ySykeELwORUtiHHGkcWKKeSzYR4oGBzRerHXLKZGIcA303bHgWmAW9Lereadh8GLiQb5c0DdubDvPEGi4hVEfFwdflvsllA25CNhieQpTUKXQ0cI2mxpBF1HUvSjqnNkyJieUTcQfZ7v6qGvk0GlkrqWUfT55KlWCakNNHDfJjT7p7Wl5N9arsuIh5L235K9ma+RNI5NbTdUdLytP9Esou3vSLiobR9LNnv5VWy9Nh7fDT9VPWFtIWSJqec/+lkb6KLgePJZjIVOoFsBo/lgDb+Go5ZfkjqDXwvIo4sd182BUl7AzdExEHl7ouVhoO6mVmOOP1iZpYjDupmZjnioG5mliMbdQOkhrTNPkOd7LePmTP+6nJ3wRqh1k0rVXet2tUn5qx67pqNPl5D8UjdzAxAFcUvxTQnVUp6TtIDab2rpKclzZD0p6rviEjaKq3PSNu7FLRxfip/peq7EHVxUDczA5CKX4pzBtndMav8DLgqInYh+87AKan8FGBxKr8q1UPSHmTfDdmT7A6c1xVxywwHdTMzoKQjdUk7AIcDv0vrAg4F7kpVbuXDW4kMSOuk7V9K9QcAoyLi/Yh4g+wLbwfUdWwHdTMzqNdIXdIQZU82q1qGrNfab8ju0VN1i4jtyZ5bUHWjvtl8eHO8TqRvBaftS1P9deXV7FOjRnuh1Mxsk6qoM7OxTkSMBEZWt03SEcCCiHhWUq+S9K0eHNTNzKDoC6BFOBj4X0n9yR6Ysx3ZfYtaStoijcZ34MM7ns4BOgOz0y27W5Dd5rqqvErhPjVy+sXMDEp2oTQizo+IHSKiC9mFzkcj4gSyB8kck6oNAu5Lr8ekddL2R9ODVcYAA9PsmK5kN4t7pq7T8EjdzAxKOVKvybnAKEmXA88BVY+jvAn4g6Sq5wEPBIiIaZJGkz3Ldw1wWi1P7VrHQd3MDOozVbFoEfE48Hh6/TrVzF6JiPeAY2vY/wpqfqZutRzUzcxgU4zUNwkHdTMzqNfsl8bMQd3MDDxSNzPLlYpGe4+uenFQNzMDj9TNzHKlAWa/lIODupkZ+EKpmVmuOP1iZpYjTr+YmeWIR+pmZjnikbqZWY54pG5mliOe/WJmliMeqZuZ5Yhz6mZmOeKRuplZjnikbmaWIzkZqefjLMzMNpIqKopeam1H2lrSM5KelzRN0iWp/BZJb0iakpYeqVySRkiaIWmqpH0L2hok6bW0DKrhkB/hkbqZGaDSpV/eBw6NiOWSmgDjJf0tbfthRNy1Xv1+QPe09ASuB3pKag0MB/YDAnhW0piIWFzbwT1SNzMDUD2WWkRmeVptkpaoZZcBwG1pvwlAS0kdgD7AuIhYlAL5OKBvXafhoG5mRjZSr8cyRNKkgmXIem1VSpoCLCALzE+nTVekFMtVkrZKZZ2AWQW7z05lNZXXyukXMzPql36JiJHAyFq2rwV6SGoJ3CtpL+B84G1gy7TvucClG9HlanmkbmYGVFRUFL0UKyKWAI8BfSNiXkqxvA/8HjggVZsDdC7YbYdUVlN57edRdO/MzPKsRDl1SW3TCB1J2wCHAS+nPDnKPhIcCbyYdhkDnJRmwRwILI2IecBYoLekVpJaAb1TWa2cfjEzo6SzXzoAt0qqJBs4j46IByQ9Kqkt2dvCFOA7qf6DQH9gBrASGAwQEYskXQZMTPUujYhFdR3cQd3MjNIF9YiYCuxTTfmhNdQP4LQatt0M3Fyf4zuom5lR0pF6WTmom5nhoG5mliuqcFA3M8sNj9TNzHLEQd3MLE/yEdMd1M3MwCN1M7NccVA3M8uR+tzTpTFzUDczA+fUzczyxOkXM7MccVA3M8sRB3UzsxzxbQJso1VUiH/e/iPmLljKV8/4LTt13J4/XDmY1i2a8tz0t/jmj29j9Zq1AHz1sH0Y9p3+RMALr87h5AtuWddO86Zb89zdw7j/san84Gd/LtPZWCnNf3sel150PosWvoskBhx9HF87/kRuuG4ETz7+KBUVolXr7fnxJT+hbdt2LF+2jIt/fC7z357H2rVrOP7EwRwx4Ohyn8ZmxSN122hDj/8ir7wxn+ZNtwbgijMG8H+3P8afxz7LiGEDOfmog7jxz+PZece2nPPN3hx68q9ZsmwVbVs1+0g7w793OOMn/7scp2ANpLJyC07/wY/Ybfc9WLFiBYNPOIYDDjyIb5z0TU793ukAjL7zD9w88jrOHXYxd42+g67dduaXV1/H4sWL+NpR/enT/wiaNNmyzGey+chLUM/HxMzNUKd2Len7uT35/b3/Wld2yP67cs/DzwFw+/1P85VenwXgm0f9DzeMfoIly1YB8M7i5ev22Wf3zrTbfjsefmr6Juy9NbQ2bduy2+57ANC0aVO6dO3GOwsW0LTZh2/oq1atWheIJLFy5QoiglUrV7Lddi2orPSYrT4kFb00Zg32V5f0aWAA0CkVzQHGRISjD/CLH36VYVf/hWbbZqP07Vs2ZemyVaxd+wEAc+YvpmO7FgB036kdAI/+/gdUVlRw+Q0PMu5f05HElWcdzTeH3coXe+5WnhOxBjdv7hxefWU6e+61NwC/veY3/O2vY2jWrBnXjLwFgGO+dgI/+sFpfKXPIaxcsYLLrvx1br5Ms8k07lhdtAb5q0s6FxhF9mt6Ji0C7pR0Xi37DZE0SdKkNe9Oa4iuNQr9Pr8XCxYt47nps4qqX1lZyS47tqP3t6/mpPNv4boLj6dFs2049bjPM3b8NOYsWNKwHbayWblyBeefcwZnnn3+ulH6d4aeyX1/e5Te/Y7grlG3A/D0U+PpvuunuX/sP7j1znv41c8uZ8Xy5bU1besp1Uhd0taSnpH0vKRpki5J5V0lPS1phqQ/SdoylW+V1mek7V0K2jo/lb8iqU8x59FQI/VTgD0jYnVhoaRfA9OAK6vbKSJGAiMBttlnaDRQ38ruoB7dOOKQz9D3c3uy1ZZN2K7p1vzyh8fQovk2VFZWsHbtB3Rq34q5C5YCMGfBEia+8CZr1nzAzLkLeW3mAnbZsS099+7KwfvszJDjPk/TbbZiyyaVLF/1PheOGFPmM7RSWLN6NReccyZ9+h9Bry8d9rHtffodwdmnf4dvf/f7/HXMvZx48reQROcdd6Jjxx14883X143urW4VpZv98j5waEQsl9QEGC/pb8BZwFURMUrSb8ni5PXp5+KI2EXSQOBnwNck7QEMBPYEOgIPS9o1ItbWeh6lOov1fJA6sb4Oadsn2kX/N4Zd+l7Ipw8fzknn/Z7HJ77K4GG38sSkVzn6y9nzak/4Sk8eeHwqAPc/9jxf2K87kKVpuu/UjjfmLGTwsFvZtf9FfPrw4Zx/1b3c8cAzDug5ERFccemF7NS1G1//xsnryme99ea610/+41F26tINgPaf6sCkZyYAsGjhu8yc+QadOnXelF3e7JVqpB6Zqo9JTdISwKHAXan8VuDI9HpAWidt/5KygwwARkXE+xHxBjADOKCu82iokfqZwCOSXgOqcgw7ArsAQxvomJu9YVffxx+uHMzw7x3B86/M4pa/PAXAuH9N58sH7c7ku4exdm1wwW/+wqKlK8rcW2tIU6dM5u9/HcPOu+zKSQOPArK0y/1/uYe3Zr6BVMGnOnTkR8OGAzD429/l8uEXcMJxAyCC004/i5atWpXzFDY79bn+KWkIMKSgaGTKNFRtrwSeJYt51wL/BpZExJpUZTYfXm/sRIqTEbFG0lJg+1Q+oeAYhfvU3LeIhslySKoge1cpvFA6sa6PDlXynH6xDTdn/NXl7oI1Qq2bVm507mS3c8cWHXNe+Vmfoo4nqSVwL3AhcEtE7JLKOwN/i4i9JL0I9I2I2Wnbv4GewMXAhIj4Yyq/Ke1z18cOVKDBZr9ExAd89F3GzKzRaoiZihGxRNJjwEFAS0lbpNH6DmQDXdLPzsBsSVsALYCFBeVVCvepkec8mZmRXSgtdqmNpLZphI6kbYDDgOnAY8Axqdog4L70ekxaJ21/NLIUyhhgYJod0xXoTjaTsFb+doKZGSWd/dIBuDXl1SuA0RHxgKSXgFGSLgeeA25K9W8C/iBpBrCIbMYLETFN0mjgJWANcFox6WsHdTMzSpd+iYipwD7VlL9ONbNXIuI94Nga2roCuKI+x3dQNzMjP/d+cVA3M8NB3cwsV3IS0x3UzcygpBdKy8pB3cwMp1/MzHIlJzHdQd3MDDxSNzPLlZzEdAd1MzPwSN3MLFc8+8XMLEdyMlB3UDczA6dfzMxyJScx3UHdzAw8UjczyxUHdTOzHPHsFzOzHMnJQN3PKDUzgyz9UuxSRzudJT0m6SVJ0ySdkcovljRH0pS09C/Y53xJMyS9IqlPQXnfVDZD0nnFnIdH6mZmlHSkvgY4OyImS2oOPCtpXNp2VUT88qPH1R5kzyXdE+gIPCxp17T5WrIHV88GJkoaExEv1XZwB3UzM6CiRFE9IuYB89LrZZKmA51q2WUAMCoi3gfeSA+grnqW6Yz0bFMkjUp1aw3qTr+YmZFdKC12KZakLmQPoX46FQ2VNFXSzZJapbJOwKyC3WansprKaz+PontnZpZjFSp+kTRE0qSCZcj67UlqBtwNnBkR/wGuB3YGepCN5H/VEOfh9IuZGfWbpx4RI4GRtbTVhCyg3x4R96R95hdsvxF4IK3OAToX7L5DKqOW8hp5pG5mRnahtNil9nYk4CZgekT8uqC8Q0G1o4AX0+sxwEBJW0nqCnQHngEmAt0ldZW0JdnF1DF1nYdH6mZmgCjZ9JeDgROBFyRNSWUXAF+X1AMI4E3gVICImCZpNNkF0DXAaRGxFkDSUGAsUAncHBHT6jq4g7qZGVmuvBQiYjxU+w7xYC37XAFcUU35g7XtVx0HdTMzfJsAM7NcKdU89XJzUDczIz/3fnFQNzPDt941M8uVnMR0B3UzM4DKnER1B3UzM5x+MTPLlZzMaHRQNzMDj9TNzHIlJzG97ht6KfMNSRel9R0lHVDXfmZmm5NSPc6u3Iq5S+N1wEHA19P6MrJHLJmZ5UZlhYpeGrNi0i89I2JfSc8BRMTidBtIM7PcaNyhunjFBPXVkirJbheJpLbABw3aKzOzTSwv934pJv0yArgXaCfpCmA88JMG7ZWZ2SZWqodklFudI/WIuF3Ss8CXyD6hHBkR0xu8Z2Zmm1BjvwBarDqDuqQdgZXA/YVlEfFWQ3bMzGxTyklMLyqn/leyfLqArYGuwCvAng3YLzOzTaqxz2opVp059Yj4TETsnX52Bw4Anmr4rpmZbTqlmqcuqbOkxyS9JGmapDNSeWtJ4yS9ln62SuWSNELSDElTJe1b0NagVP81SYOKOY96f6M0IiZL6lnf/epr8cRrGvoQthl6a+HKcnfBGqHWTbfd6DaKmTVSpDXA2SlWNgeelTQOOBl4JCKulHQecB5wLtAP6J6WnsD1QE9JrYHhwH5k2ZJnJY2JiMW1HbyYnPpZBasVwL7A3Pqdo5lZ41aqC6URMQ+Yl14vkzQd6AQMAHqlarcCj5MF9QHAbRERwARJLSV1SHXHRcSi1L9xQF/gztqOX8xIvXnB6zVkOfa7i9jPzGyz0RApdUldgH2Ap4H2KeADvA20T687AbMKdpudymoqr1WtQT196ah5RJxTRP/NzDZb9blQKmkIMKSgaGREjFyvTjOyAfCZEfGfwk8CERGSYuN6XL0ag7qkLSJijaSDG+LAZmaNSX1G6imAj6xpu6QmZAH99oi4JxXPl9QhIual9MqCVD4H6Fyw+w6pbA4fpmuqyh+vq2+1XRt4Jv2cImmMpBMlHV211NWwmdnmpFTfKFU2JL8JmB4Rvy7YNAaomsEyCLivoPykNAvmQGBpStOMBXpLapVmyvROZbUqJqe+NbAQOJQP56sHcE9tO5mZbU5KeO+Xg4ETgRckTUllFwBXAqMlnQLMBI5L2x4E+gMzyL7oORggIhZJugyYmOpdWnXRtDa1BfV2aebLi3wYzKs0SC7IzKxcSjWlMSLGU/NNH79UTf0ATquhrZuBm+tz/NqCeiXQrIbOOaibWa58Em4TMC8iLt1kPTEzK6O83CagtqCejzM0MytCTmJ6rUH9Y7kfM7O8ystDMmoM6sVcZTUzy4ucxPT639DLzCyPPgnpFzOzTwzl5DKig7qZGbBFCe+9W04O6mZmfIKeUWpm9kngnLqZWY7kZKDuoG5mBp+AeepmZp8klb5QamaWHxWe0mhmlh85yb44qJuZgWe/mJnlii+UmpnlSE5iesme4GRmtlmrrFDRS10k3SxpgaQXC8ouljRH0pS09C/Ydr6kGZJekdSnoLxvKpsh6bxizsNB3cyMLBgWuxThFqBvNeVXRUSPtDwIIGkPYCCwZ9rnOkmVkiqBa4F+wB7A11PdWjn9YmZGae/9EhFPSOpSZPUBwKiIeB94Q9IM4IC0bUZEvJ76NyrVfam2xjxSNzMje35nsctGGCppakrPtEplnYBZBXVmp7KaymvloG5mRjb7pdhF0hBJkwqWIUUc4npgZ6AHMA/4VUOch9MvZmbUbwQeESOBkfVpPyLmrzuWdCPwQFqdA3QuqLpDKqOW8hp5pG5mBlRUqOhlQ0jqULB6FFA1M2YMMFDSVpK6At2BZ4CJQHdJXSVtSXYxdUxdx/FI3cyM0o5wJd0J9ALaSJoNDAd6SeoBBPAmcCpAREyTNJrsAuga4LSIWJvaGQqMBSqBmyNiWp3HjogSnkrpvLeGxtkxK6u3Fq4sdxesEdq1/bYbPXVl9JS5Rcec43p0bLRfVfJI3cyMjZ7V0mg4qJuZ4WeUmpnlSqWDuplZfuQjpDuom5kB+blLo4O6mRl+nJ2ZWa54pG5mliPySN3MLD88+8XMLEdyEtMd1M3MwEHdzCxXnFM3M8uRDbyjbqPjoG5mRvbkozxwUDczw+kXayBvz5vHsPN/xKKFC0HimGOP44QTB/HKyy9z+aXDWblyJR07duKnP/8lzZo1K3d3rQEtX7aM//v5Jcx8498IccZ5w5k0YTxPj/8HqhAtWrbmzAsuYfs27YgIRo74Oc9O+CdbbbU1Z5x/Cbvstnu5T2Gzkpf0ix+S0ci8884C3n3nHXbfY09WrFjOwGO/ym9GXMuFF5zLWT88l/32P4B777mLObNnM/T0M8vd3U3uk/SQjKuuuJA9PrsPfY44mtWrV/P+e+9RUSG2bZq9mY+56w5mvfk6p53zYyY99ST33zOKi39+Da+89AI3jvgFv7rhD2U+g02nFA/JePLVxUXHnM/v2qrRvgX4GaWNTNu27dh9jz0BaNq0Gd26dWPBgvnMnPkm/2+//QE46KCDeWTcQ+XspjWwFcuX8eLzk+l9+FEANGnShGbNm68L6ADvv7dq3T3AJ4z/B4f2OQJJfHrPvVmxfBmL3n2nLH3fXEnFL42Zg3ojNmfObF6ePp3P7P1Zdt6lO489+ggAD439O2+/Pa/MvbOGNH/eXFq0bMVvfjqcM04ZyIifXcJ7q1YBcNuN1zD4q315fNzfOOGU7wKw8N0FtGn3qXX7b9+2PQvfXVCWvm+uVI+lzrakmyUtkPRiQVlrSeMkvZZ+tkrlkjRC0gxJUyXtW7DPoFT/NUmDijmPTR7UJQ2uZdsQSZMkTbrpxpGbsluNzsoVKzj7zNP54XkX0KxZMy657Ar+NOoOBh57NCtXrqBJky3L3UVrQGvXruHfr71M/yOP5eqbRrH11ttw1+03A3DSt4fy+7v/Tq/D+vHAPX8qc0/zo1IqeinCLUDf9crOAx6JiO7AI2kdoB/QPS1DgOshexMge2B1T+AAYHjVG0FtyjFSv6SmDRExMiL2i4j9Tvn2kE3Zp0Zl9erVnHXm6fQ//Ct8+bDeAHTttjM33Hgzo/58D337H84OnTuXuZfWkNq0bU+btu3YbY/PAHBwry/z71df/kidQw7rz7/+kX16275NO95d8Pa6bQvfmc/2bdptug7nQQmH6hHxBLBoveIBwK3p9a3AkQXlt0VmAtBSUgegDzAuIhZFxGJgHB9/o/iYBgnq6SNEdcsLQPuGOGZeRAQXXzSMbt26cdLJH36oWbhwIQAffPABN95wPcd+bWC5umibQKvt29Cm3aeY/dabADz/7DN07tKNubNmrqvz9PjH2WHHLgD0/NwhPDr2ASKCl6dNZdumzWjdpm0Zer75Un3+K8gqpKWYUWj7iKjKm77Nh7GwEzCroN7sVFZTea0aakpje7J3mcXrlQv4VwMdMxeem/wsD4y5j+677spxRw8A4PtnnsVbM99k1J13APClLx/GkUd9tZzdtE3g1DPO5VeXXcCa1Wto37ETZ55/CSN+dglzZs2kQhW0/VQHTjt7GAD7Hfg5Jj01niFf/980pfHi8nZ+M1SfC6ARMRLY4BxxRISkBpnh1yBTGiXdBPw+IsZXs+2OiDi+rjY+qVMarXafpCmNVrxSTGmc+PrSomPO/t1a1Hk8SV2AByJir7T+CtArIual9MrjEbGbpBvS6zsL61UtEXFqKv9IvZo0SPolIk6pLqCnbXUGdDOzTa6U01+qNwaomsEyCLivoPykNAvmQGBpStOMBXpLapUukPZOZbXyN0rNzCjtvV8k3Uk20m4jaTbZLJYrgdGSTgFmAsel6g8C/YEZwEpgMEBELJJ0GTAx1bs0Ita/+PrxY/sbpbY5cfrFqlOK9MvkN/9TdMzZt8t2jfYrSB6pm5nBxqRVGhUHdTMzfJdGM7Ncaez3dCmWg7qZGQ7qZma54vSLmVmOeKRuZpYjOYnpDupmZkBuorqDupkZzqmbmeVKXh487aBuZgZOv5iZ5YnTL2ZmOeIpjWZmOZKTmO6gbmYG5CaqO6ibmVHah2SUk4O6mRm5Gag7qJuZAbmJ6g3y4Gkzs82N6vFfnW1Jb0p6QdIUSZNSWWtJ4yS9ln62SuWSNELSDElTJe27MefhoG5mRjalsdilSF+MiB4RsV9aPw94JCK6A4+kdYB+QPe0DAGu35jzcFA3M6NBgvr6BgC3pte3AkcWlN8WmQlAS0kdNvQgDupmZtQv/SJpiKRJBcuQ9ZoL4CFJzxZsax8R89Lrt4H26XUnYFbBvrNT2QbxhVIzM+o3Ao+IkcDIWqp8LiLmSGoHjJP08nr7h6TYoI7WwSN1MzOyyS/FLnWJiDnp5wLgXuAAYH5VWiX9XJCqzwE6F+y+QyrbIA7qZmaULqcuqamk5lWvgd7Ai8AYYFCqNgi4L70eA5yUZsEcCCwtSNPUm9MvZmZACSeqtwfuVRb9twDuiIi/S5oIjJZ0CjATOC7VfxDoD8wAVgKDN+bgimiQtM5Ge28NjbNjVlZvLVxZ7i5YI7Rr+203OiLPXfLfomNOx5ZbNtqvKnmkbmaGb71rZpYrfkiGmVme5COmO6ibmUFuYrqDupkZOKduZpYryklUd1A3M8PpFzOzXMnJQN1B3cwMPKXRzCxXPFI3M8sRB3Uzsxxx+sXMLEc8Ujczy5GcxHQHdTMzIDdR3UHdzAzn1M3McqUiHzHdQd3MDHD6xcwsT5x+MTPLkbxMaWy0D562D0kaEhEjy90Pa1z878KqU1HuDlhRhpS7A9Yo+d+FfYyDuplZjjiom5nliIP65sF5U6uO/13Yx/hCqZlZjnikbmaWIw7qZmY54qDeyEnqK+kVSTMknVfu/lj5SbpZ0gJJL5a7L9b4OKg3YpIqgWuBfsAewNcl7VHeXlkjcAvQt9ydsMbJQb1xOwCYERGvR8R/gVHAgDL3ycosIp4AFpW7H9Y4Oag3bp2AWQXrs1OZmVm1HNTNzHLEQb1xmwN0LljfIZWZmVXLQb1xmwh0l9RV0pbAQGBMmftkZo2Yg3ojFhFrgKHAWGA6MDoippW3V1Zuku4EngJ2kzRb0inl7pM1Hr5NgJlZjnikbmaWIw7qZmY54qBuZpYjDupmZjnioG5mliMO6tYgJK2VNEXSi5L+LGnbjWjrFknHpNe/q+2mZpJ6SfqfDTjGm5LabGgfzRoLB3VrKKsiokdE7AX8F/hO4UZJW2xIoxHxrYh4qZYqvYB6B3WzvHBQt03hSWCXNIp+UtIY4CVJlZJ+IWmipKmSTgVQ5pp0H/mHgXZVDUl6XNJ+6XVfSZMlPS/pEUldyN48fpA+JXxeUltJd6djTJR0cNp3e0kPSZom6XeANvHvxKxBbNBoyaxYaUTeD/h7KtoX2Csi3pA0BFgaEftL2gr4p6SHgH2A3cjuId8eeAm4eb122wI3Al9IbbWOiEWSfgssj4hfpnp3AFdFxHhJO5J9O3d3YDgwPiIulXQ44G9lWi44qFtD2UbSlPT6SeAmsrTIMxHxRirvDexdlS8HWgDdgS8Ad0bEWmCupEeraf9A4ImqtiKipvuLfxnYQ1o3EN9OUrN0jKPTvn+VtHjDTtOscXFQt4ayKiJ6FBakwLqisAj4fkSMXa9e/xL2owI4MCLeq6YvZrnjnLqV01jgu5KaAEjaVVJT4Angaynn3gH4YjX7TgC+IKlr2rd1Kl8GNC+o9xDw/aoVST3SyyeA41NZP6BVqU7KrJwc1K2cfkeWL5+cHqJ8A9mnx3uB19K228juSPgREfEOMAS4R9LzwJ/SpvuBo6oulAKnA/ulC7Ev8eEsnEvI3hSmkaVh3mqgczTbpHyXRjOzHPFI3cwsRxzUzcxyxEHdzCxHHNTNzHLEQd3MLEcc1M3McsRB3cwsR/4/e1g75WQnmVEAAAAASUVORK5CYII=",
      "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": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_adaboost(x_train, y_train, x_test, y_test):\n",
    "    rf_clf = RandomForestClassifier(criterion='gini', max_depth=100, 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": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report: \n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.95      0.99      0.97      4113\n",
      "           1       0.96      0.75      0.84       848\n",
      "\n",
      "    accuracy                           0.95      4961\n",
      "   macro avg       0.96      0.87      0.91      4961\n",
      "weighted avg       0.95      0.95      0.95      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": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_evaluate_bagging(x_train, y_train, x_test, y_test):\n",
    "    rf_clf = RandomForestClassifier(criterion='gini', max_depth=100, 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": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report: \n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.94      0.99      0.97      4063\n",
      "           1       0.97      0.71      0.82       898\n",
      "\n",
      "    accuracy                           0.94      4961\n",
      "   macro avg       0.95      0.85      0.89      4961\n",
      "weighted avg       0.94      0.94      0.94      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_bagging(x_train, y_train, x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Undersampled 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.73   \t| 0.83 \t| 0.95     \t|\n",
    "| Adaboost Classifier \t| 0.75   \t| 0.84 \t| 0.95     \t|\n",
    "| Bagging Classifier  \t| 0.71   \t| 0.81 \t| 0.94     \t|"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "32097e69bc79c595731a7497feac30fb46b046080f88a2597586ab8db5f4f542"
  },
  "kernelspec": {
   "display_name": "Python 3.8.4 64-bit ('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
 },
 "nbformat": 4,
 "nbformat_minor": 2
}