credit_risk_resampling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Credit Risk Resampling Techniques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pathlib import Path\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read the CSV into DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>loan_size</th>\n",
       "      <th>interest_rate</th>\n",
       "      <th>homeowner</th>\n",
       "      <th>borrower_income</th>\n",
       "      <th>debt_to_income</th>\n",
       "      <th>num_of_accounts</th>\n",
       "      <th>derogatory_marks</th>\n",
       "      <th>total_debt</th>\n",
       "      <th>loan_status</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10700.0</td>\n",
       "      <td>7.672</td>\n",
       "      <td>own</td>\n",
       "      <td>52800</td>\n",
       "      <td>0.431818</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>22800</td>\n",
       "      <td>low_risk</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>8400.0</td>\n",
       "      <td>6.692</td>\n",
       "      <td>own</td>\n",
       "      <td>43600</td>\n",
       "      <td>0.311927</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>13600</td>\n",
       "      <td>low_risk</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>9000.0</td>\n",
       "      <td>6.963</td>\n",
       "      <td>rent</td>\n",
       "      <td>46100</td>\n",
       "      <td>0.349241</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>16100</td>\n",
       "      <td>low_risk</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>10700.0</td>\n",
       "      <td>7.664</td>\n",
       "      <td>own</td>\n",
       "      <td>52700</td>\n",
       "      <td>0.430740</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>22700</td>\n",
       "      <td>low_risk</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10800.0</td>\n",
       "      <td>7.698</td>\n",
       "      <td>mortgage</td>\n",
       "      <td>53000</td>\n",
       "      <td>0.433962</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>23000</td>\n",
       "      <td>low_risk</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   loan_size  interest_rate homeowner  borrower_income  debt_to_income  \\\n",
       "0    10700.0          7.672       own            52800        0.431818   \n",
       "1     8400.0          6.692       own            43600        0.311927   \n",
       "2     9000.0          6.963      rent            46100        0.349241   \n",
       "3    10700.0          7.664       own            52700        0.430740   \n",
       "4    10800.0          7.698  mortgage            53000        0.433962   \n",
       "\n",
       "   num_of_accounts  derogatory_marks  total_debt loan_status  \n",
       "0                5                 1       22800    low_risk  \n",
       "1                3                 0       13600    low_risk  \n",
       "2                3                 0       16100    low_risk  \n",
       "3                5                 1       22700    low_risk  \n",
       "4                5                 1       23000    low_risk  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Loading the data\n",
    "file_path = Path('Resources/lending_data.csv')\n",
    "df = pd.read_csv(file_path)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Encoding \"homeowner\" with LabelEncoder\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "le = LabelEncoder()\n",
    "\n",
    "le.fit(df[\"homeowner\"])\n",
    "df[\"homeowner\"] = le.transform(df[\"homeowner\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Split the Data into Training and Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating our features\n",
    "X = df.copy()\n",
    "X.drop(\"loan_status\", axis=1, inplace=True)\n",
    "\n",
    "# Creating our target\n",
    "y = df['loan_status']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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>loan_size</th>\n",
       "      <th>interest_rate</th>\n",
       "      <th>homeowner</th>\n",
       "      <th>borrower_income</th>\n",
       "      <th>debt_to_income</th>\n",
       "      <th>num_of_accounts</th>\n",
       "      <th>derogatory_marks</th>\n",
       "      <th>total_debt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>77536.000000</td>\n",
       "      <td>77536.000000</td>\n",
       "      <td>77536.000000</td>\n",
       "      <td>77536.000000</td>\n",
       "      <td>77536.000000</td>\n",
       "      <td>77536.000000</td>\n",
       "      <td>77536.000000</td>\n",
       "      <td>77536.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>9805.562577</td>\n",
       "      <td>7.292333</td>\n",
       "      <td>0.606144</td>\n",
       "      <td>49221.949804</td>\n",
       "      <td>0.377318</td>\n",
       "      <td>3.826610</td>\n",
       "      <td>0.392308</td>\n",
       "      <td>19221.949804</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>2093.223153</td>\n",
       "      <td>0.889495</td>\n",
       "      <td>0.667811</td>\n",
       "      <td>8371.635077</td>\n",
       "      <td>0.081519</td>\n",
       "      <td>1.904426</td>\n",
       "      <td>0.582086</td>\n",
       "      <td>8371.635077</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>5000.000000</td>\n",
       "      <td>5.250000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>30000.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>8700.000000</td>\n",
       "      <td>6.825000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>44800.000000</td>\n",
       "      <td>0.330357</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>14800.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>9500.000000</td>\n",
       "      <td>7.172000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>48100.000000</td>\n",
       "      <td>0.376299</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>18100.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>10400.000000</td>\n",
       "      <td>7.528000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>51400.000000</td>\n",
       "      <td>0.416342</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>21400.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>23800.000000</td>\n",
       "      <td>13.235000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>105200.000000</td>\n",
       "      <td>0.714829</td>\n",
       "      <td>16.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>75200.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          loan_size  interest_rate     homeowner  borrower_income  \\\n",
       "count  77536.000000   77536.000000  77536.000000     77536.000000   \n",
       "mean    9805.562577       7.292333      0.606144     49221.949804   \n",
       "std     2093.223153       0.889495      0.667811      8371.635077   \n",
       "min     5000.000000       5.250000      0.000000     30000.000000   \n",
       "25%     8700.000000       6.825000      0.000000     44800.000000   \n",
       "50%     9500.000000       7.172000      1.000000     48100.000000   \n",
       "75%    10400.000000       7.528000      1.000000     51400.000000   \n",
       "max    23800.000000      13.235000      2.000000    105200.000000   \n",
       "\n",
       "       debt_to_income  num_of_accounts  derogatory_marks    total_debt  \n",
       "count    77536.000000     77536.000000      77536.000000  77536.000000  \n",
       "mean         0.377318         3.826610          0.392308  19221.949804  \n",
       "std          0.081519         1.904426          0.582086   8371.635077  \n",
       "min          0.000000         0.000000          0.000000      0.000000  \n",
       "25%          0.330357         3.000000          0.000000  14800.000000  \n",
       "50%          0.376299         4.000000          0.000000  18100.000000  \n",
       "75%          0.416342         4.000000          1.000000  21400.000000  \n",
       "max          0.714829        16.000000          3.000000  75200.000000  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "low_risk     75036\n",
       "high_risk     2500\n",
       "Name: loan_status, dtype: int64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking the balance of our target values\n",
    "df['loan_status'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating X_train, X_test, y_train, y_test\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Pre-Processing\n",
    "\n",
    "Scale the training and testing data using the `StandardScaler` from `sklearn`. Remember that when scaling the data, you only scale the features data (`X_train` and `X_testing`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the StandardScaler instance\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fitting the Standard Scaler with the training data\n",
    "# When fitting scaling functions, only train on the training dataset\n",
    "X_scaler = scaler.fit(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scale the training and testing data\n",
    "X_train_scaled = X_scaler.transform(X_train)\n",
    "X_test_scaled = X_scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(random_state=1)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "model = LogisticRegression(solver='lbfgs', random_state=1)\n",
    "model.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9520479254722232"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating the balanced accuracy score\n",
    "from sklearn.metrics import balanced_accuracy_score\n",
    "y_pred = model.predict(X_test)\n",
    "balanced_accuracy_score(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  563,    56],\n",
       "       [  102, 18663]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying the confusion matrix\n",
    "from sklearn.metrics import confusion_matrix\n",
    "confusion_matrix(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   pre       rec       spe        f1       geo       iba       sup\n",
      "\n",
      "  high_risk       0.85      0.91      0.99      0.88      0.95      0.90       619\n",
      "   low_risk       1.00      0.99      0.91      1.00      0.95      0.91     18765\n",
      "\n",
      "avg / total       0.99      0.99      0.91      0.99      0.95      0.91     19384\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Printing the imbalanced classification report\n",
    "from imblearn.metrics import classification_report_imbalanced\n",
    "print(classification_report_imbalanced(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Oversampling\n",
    "\n",
    "In this section, I will compare two oversampling algorithms to determine which algorithm results in the best performance. I will oversample the data using the naive random oversampling algorithm and the SMOTE algorithm. For each algorithm, I am completing the folliowing steps:\n",
    "\n",
    "1. Viewing the count of the target classes using `Counter` from the collections library. \n",
    "3. Using the resampled data to train a logistic regression model.\n",
    "3. Calculating the balanced accuracy score from sklearn.metrics.\n",
    "4. Printing the confusion matrix from sklearn.metrics.\n",
    "5. Generating a classication report using the `imbalanced_classification_report` from imbalanced-learn.\n",
    "\n",
    "Note: I used a random state of 1 for each sampling algorithm to ensure consistency between tests."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Naive Random Oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'low_risk': 56271, 'high_risk': 56271})"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Resampling the training data with the RandomOversampler\n",
    "from imblearn.over_sampling import RandomOverSampler\n",
    "\n",
    "ros = RandomOverSampler(random_state=1)\n",
    "X_resampled_1, y_resampled_1 = ros.fit_resample(X_train, y_train)\n",
    "\n",
    "# Viewing the count of target classes with Counter\n",
    "Counter(y_resampled_1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(random_state=1)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training the Logistic Regression model using the resampled data\n",
    "model_1 = LogisticRegression(solver='lbfgs', random_state=1)\n",
    "model_1.fit(X_resampled_1, y_resampled_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9936781215845847"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating the balanced accuracy score\n",
    "y_predicted_1 = model_1.predict(X_test)\n",
    "balanced_accuracy_score(y_test, y_predicted_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  615,     4],\n",
       "       [  116, 18649]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying the confusion matrix\n",
    "confusion_matrix(y_test, y_predicted_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   pre       rec       spe        f1       geo       iba       sup\n",
      "\n",
      "  high_risk     0.8413    0.9935    0.9938    0.9111    0.9937    0.9874       619\n",
      "   low_risk     0.9998    0.9938    0.9935    0.9968    0.9937    0.9874     18765\n",
      "\n",
      "avg / total     0.9947    0.9938    0.9935    0.9941    0.9937    0.9874     19384\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Printing the imbalanced classification report\n",
    "print(classification_report_imbalanced(y_test, y_predicted_1, digits = 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SMOTE Oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'low_risk': 56271, 'high_risk': 56271})"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Resampling the training data with SMOTE\n",
    "from imblearn.over_sampling import SMOTE\n",
    "\n",
    "X_resampled_2, y_resampled_2 = SMOTE(random_state=1, sampling_strategy=1.0).fit_resample(X_train, y_train)\n",
    "\n",
    "# Viewing the count of target classes with Counter\n",
    "Counter(y_resampled_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(random_state=1)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training the Logistic Regression model using the resampled data\n",
    "model_2 = LogisticRegression(solver='lbfgs', random_state=1)\n",
    "model_2.fit(X_resampled_2, y_resampled_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9936781215845847"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating the balanced accuracy score\n",
    "y_predicted_2 = model_2.predict(X_test)\n",
    "balanced_accuracy_score(y_test, y_predicted_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  615,     4],\n",
       "       [  116, 18649]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying the confusion matrix\n",
    "confusion_matrix(y_test, y_predicted_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   pre       rec       spe        f1       geo       iba       sup\n",
      "\n",
      "  high_risk     0.8413    0.9935    0.9938    0.9111    0.9937    0.9874       619\n",
      "   low_risk     0.9998    0.9938    0.9935    0.9968    0.9937    0.9874     18765\n",
      "\n",
      "avg / total     0.9947    0.9938    0.9935    0.9941    0.9937    0.9874     19384\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Printing the imbalanced classification report\n",
    "print(classification_report_imbalanced(y_test, y_predicted_2, digits = 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Undersampling\n",
    "\n",
    "In this section, I will test an undersampling algorithm to determine which algorithm results in the best performance compared to the oversampling algorithms above. I will undersample the data using the Cluster Centroids algorithm and complete the folliowing steps:\n",
    "\n",
    "1. Viewing the count of the target classes using `Counter` from the collections library. \n",
    "3. Using the resampled data to train a logistic regression model.\n",
    "3. Calculating the balanced accuracy score from sklearn.metrics.\n",
    "4. Displaying the confusion matrix from sklearn.metrics.\n",
    "5. Generating a classication report using the `imbalanced_classification_report` from imbalanced-learn.\n",
    "\n",
    "Note: I used a random state of 1 for each sampling algorithm to ensure consistency between tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'high_risk': 1881, 'low_risk': 1881})"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Resampling the data using the ClusterCentroids resampler\n",
    "from imblearn.under_sampling import ClusterCentroids\n",
    "\n",
    "cc = ClusterCentroids(random_state=1)\n",
    "X_resampled_3, y_resampled_3 = cc.fit_resample(X_train, y_train)\n",
    "\n",
    "# Viewing the count of target classes with Counter\n",
    "Counter(y_resampled_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(random_state=1)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training the Logistic Regression model using the resampled data\n",
    "model_3 = LogisticRegression(solver='lbfgs', random_state=1)\n",
    "model_3.fit(X_resampled_3, y_resampled_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9865149130022852"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating the balanced accuracy score\n",
    "y_predicted_3 = model_3.predict(X_test)\n",
    "balanced_accuracy_score(y_test, y_predicted_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  606,    13],\n",
       "       [  112, 18653]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying the confusion matrix\n",
    "confusion_matrix(y_test, y_predicted_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   pre       rec       spe        f1       geo       iba       sup\n",
      "\n",
      "  high_risk     0.8440    0.9790    0.9940    0.9065    0.9865    0.9717       619\n",
      "   low_risk     0.9993    0.9940    0.9790    0.9967    0.9865    0.9746     18765\n",
      "\n",
      "avg / total     0.9943    0.9936    0.9795    0.9938    0.9865    0.9745     19384\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Printing the imbalanced classification report\n",
    "print(classification_report_imbalanced(y_test, y_predicted_3, digits = 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combination (Over and Under) Sampling\n",
    "\n",
    "In this section, I will test a combination over- and under-sampling algorithm to determine if the algorithm results in the best performance compared to the other sampling algorithms above. I will resample the data using the SMOTEENN algorithm and complete the folliowing steps:\n",
    "\n",
    "1. Viewing the count of the target classes using `Counter` from the collections library. \n",
    "3. Using the resampled data to train a logistic regression model.\n",
    "3. Calculating the balanced accuracy score from sklearn.metrics.\n",
    "4. Displaying the confusion matrix from sklearn.metrics.\n",
    "5. Generating a classication report using the `imbalanced_classification_report` from imbalanced-learn.\n",
    "\n",
    "Note: I used a random state of 1 for each sampling algorithm to ensure consistency between tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'high_risk': 55609, 'low_risk': 55948})"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Resampling the training data with SMOTEENN\n",
    "from imblearn.combine import SMOTEENN\n",
    "\n",
    "sm = SMOTEENN(random_state=1)\n",
    "X_resampled_4, y_resampled_4 = sm.fit_resample(X_train, y_train)\n",
    "\n",
    "# View the count of target classes with Counter\n",
    "Counter(y_resampled_4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(random_state=1)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training the Logistic Regression model using the resampled data\n",
    "model_4 = LogisticRegression(solver='lbfgs', random_state=1)\n",
    "model_4.fit(X_resampled_4, y_resampled_4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9935182494822666"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating the balanced accuracy score\n",
    "y_predicted_4 = model_4.predict(X_test)\n",
    "balanced_accuracy_score(y_test, y_predicted_4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  615,     4],\n",
       "       [  122, 18643]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying the confusion matrix\n",
    "confusion_matrix(y_test, y_predicted_4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   pre       rec       spe        f1       geo       iba       sup\n",
      "\n",
      "  high_risk     0.8345    0.9935    0.9935    0.9071    0.9935    0.9871       619\n",
      "   low_risk     0.9998    0.9935    0.9935    0.9966    0.9935    0.9871     18765\n",
      "\n",
      "avg / total     0.9945    0.9935    0.9935    0.9938    0.9935    0.9871     19384\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Printing the imbalanced classification report\n",
    "print(classification_report_imbalanced(y_test, y_predicted_4, digits = 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final Questions\n",
    "\n",
    "1. Which model had the best balanced accuracy score?\n",
    "\n",
    "   The Naive Random Oversampling and SMOTE Oversampling have the best balanced accuracy scores. \n",
    "\n",
    "2. Which model had the best recall score?\n",
    "\n",
    "    The Naive Random Oversampling and SMOTE Oversampling also have the best recall scores (0.9938).\n",
    "\n",
    "3. Which model had the best geometric mean score?\n",
    "\n",
    "    The Naive Random Oversampling and SMOTE Oversampling have the best geometric mean scores (0.9937). \n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}