Module-5/week-3/Class_imbalance_model_eval.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class Imbalance and Model Evaluation/Comparison\n",
    "\n",
    "Agenda:\n",
    "- Review class imbalance\n",
    "- Review code for different ways to handle class imbalance\n",
    "- Review model evalutation metrics\n",
    "- Review how to compare models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn import metrics"
   ]
  },
  {
   "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>Survived</th>\n",
       "      <th>Pclass</th>\n",
       "      <th>Age</th>\n",
       "      <th>SibSp</th>\n",
       "      <th>Parch</th>\n",
       "      <th>Fare</th>\n",
       "      <th>youngin</th>\n",
       "      <th>male</th>\n",
       "      <th>Q</th>\n",
       "      <th>S</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PassengerId</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>22.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>7.2500</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>38.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>71.2833</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>26.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>7.9250</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>35.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>53.1000</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>35.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>8.0500</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Survived  Pclass   Age  SibSp  Parch     Fare  youngin  male  Q  \\\n",
       "PassengerId                                                                    \n",
       "1                   0       3  22.0      1      0   7.2500        0     1  0   \n",
       "2                   1       1  38.0      1      0  71.2833        0     0  0   \n",
       "3                   1       3  26.0      0      0   7.9250        0     0  0   \n",
       "4                   1       1  35.0      1      0  53.1000        0     0  0   \n",
       "5                   0       3  35.0      0      0   8.0500        0     1  0   \n",
       "\n",
       "             S  \n",
       "PassengerId     \n",
       "1            1  \n",
       "2            0  \n",
       "3            1  \n",
       "4            1  \n",
       "5            1  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read in data and split data to be used in the models\n",
    "titanic = pd.read_csv('cleaned_titanic.csv', index_col='PassengerId')\n",
    "\n",
    "titanic.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create matrix of features\n",
    "X = titanic.drop('Survived', axis = 1) # grabs everything else but 'Survived'\n",
    "\n",
    "# Create target variable\n",
    "y = titanic['Survived'] # y is the column we're trying to predict\n",
    "\n",
    "# Create a list of the features being used in the \n",
    "feature_cols = X.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Handling Class Imbalance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How do we know we have a class imbance problem???  We need to look at the target variable to see  if we have \"even\" groups."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Class Imbalance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "sns.set_style('darkgrid')\n",
    "plt.figure(figsize=(10, 5))\n",
    "sns.countplot(y, alpha=.80, color='blue')\n",
    "plt.title('Survivors vs Non-Survivors')\n",
    "plt.ylabel('# Passengers')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the above bar chart do we have the the same number of survivors vs. non-survivors?  What will happen if we run a model with this data?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run a Dummy Classifier for Baseline Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is a baseline model?  Why do we use it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy score:  0.6547085201793722\n",
      "Test F1 score:  0.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "//anaconda3/lib/python3.7/site-packages/sklearn/metrics/classification.py:1437: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 due to no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1c220959b0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.metrics import accuracy_score, f1_score, confusion_matrix\n",
    "\n",
    "# setting up testing and training sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=23)\n",
    "\n",
    "# DummyClassifier to predict only target 0\n",
    "dummy = DummyClassifier(strategy='most_frequent', random_state=13).fit(X_train, y_train)\n",
    "dummy_pred = dummy.predict(X_test)\n",
    "\n",
    "\n",
    "# checking accuracy\n",
    "print('Test Accuracy score: ', accuracy_score(y_test, dummy_pred))\n",
    "\n",
    "\n",
    "# checking accuracy\n",
    "print('Test F1 score: ', f1_score(y_test, dummy_pred))\n",
    "\n",
    "#checking confusion matrix\n",
    "from yellowbrick.classifier import ConfusionMatrix\n",
    "# The ConfusionMatrix visualizer taxes a model\n",
    "cm = ConfusionMatrix(dummy, classes=[0,1])\n",
    "\n",
    "# Fit fits the passed model. This is unnecessary if you pass the visualizer a pre-fitted model\n",
    "cm.fit(X_train, y_train)\n",
    "\n",
    "# To create the ConfusionMatrix, we need some test data. Score runs predict() on the data\n",
    "# and then creates the confusion_matrix from scikit-learn.\n",
    "cm.score(X_test, y_test)\n",
    "\n",
    "# How did we do?\n",
    "cm.poof()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run a classification model with class imbalance\n",
    "\n",
    "For the purpose of this example we are using a Logistic Regression classification mode but this will apply to other classification models. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy score:  0.7847533632286996\n",
      "Test F1 score:  0.6619718309859155\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1a21648a58>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "# dt_clf = DecisionTreeClassifier(max_depth=5)\n",
    "lr_clf = LogisticRegression(solver='liblinear', random_state=13)\n",
    "\n",
    "# dt_clf.fit(X_train, y_train)\n",
    "lr_clf.fit(X_train, y_train)\n",
    "\n",
    "# y_pred_test = dt_clf.predict(X_test)\n",
    "y_pred_test = lr_clf.predict(X_test)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# checking accuracy\n",
    "print('Test Accuracy score: ', accuracy_score(y_test, y_pred_test))\n",
    "\n",
    "\n",
    "# checking accuracy\n",
    "print('Test F1 score: ', f1_score(y_test, y_pred_test))\n",
    "\n",
    "#checking confusion matrix\n",
    "from yellowbrick.classifier import ConfusionMatrix\n",
    "# The ConfusionMatrix visualizer taxes a model\n",
    "cm = ConfusionMatrix(lr_clf, classes=[0,1])\n",
    "\n",
    "# Fit fits the passed model. This is unnecessary if you pass the visualizer a pre-fitted model\n",
    "cm.fit(X_train, y_train)\n",
    "\n",
    "# To create the ConfusionMatrix, we need some test data. Score runs predict() on the data\n",
    "# and then creates the confusion_matrix from scikit-learn.\n",
    "cm.score(X_test, y_test)\n",
    "\n",
    "# How did we do?\n",
    "cm.poof()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepping data for handling class imbalances\n",
    "\n",
    "We are goign to change the training dataset to which we fit our model, so we want to bring our training data back together before we make those changes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# concatenate our training data back together\n",
    "training  = pd.concat([X_train, y_train], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# separate minority and majority classes\n",
    "deceased = training[training.Survived==0]\n",
    "survived = training[training.Survived==1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deceased count: 403\n",
      "survived count: 263\n"
     ]
    }
   ],
   "source": [
    "print('deceased count: '+ str(len(deceased)))\n",
    "print('survived count: '+ str(len(survived)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.utils import resample\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](class_imb_images/resampling.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Upsampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# upsample minority\n",
    "survived_upsampled = resample(survived,\n",
    "                          replace=True, # sample with replacement\n",
    "                          n_samples=len(deceased), # match number in majority class\n",
    "                          random_state=23) # reproducible results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    403\n",
       "0    403\n",
       "Name: Survived, dtype: int64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# combine majority and upsampled minority\n",
    "upsampled = pd.concat([deceased, survived_upsampled])\n",
    "\n",
    "# check new class counts\n",
    "upsampled.Survived.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy score:  0.7713004484304933\n",
      "Test F1 score:  0.6577181208053691\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1c223b94e0>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# trying logistic regression again with the balanced dataset\n",
    "y_train = upsampled.Survived\n",
    "X_train = upsampled.drop('Survived', axis=1)\n",
    "\n",
    "\n",
    "# upsampled_dt = DecisionTreeClassifier(max_depth=5)\n",
    "upsampled_lr = LogisticRegression(solver='liblinear')\n",
    "\n",
    "\n",
    "# upsampled_dt.fit(X_train, y_train)\n",
    "upsampled_lr.fit(X_train, y_train)\n",
    "\n",
    "\n",
    "# upsampled_pred = upsampled_dt.predict(X_test)\n",
    "upsampled_pred = upsampled_lr.predict(X_test)\n",
    "\n",
    "\n",
    "\n",
    "# checking accuracy\n",
    "print('Test Accuracy score: ', accuracy_score(y_test, upsampled_pred))\n",
    "\n",
    "\n",
    "# checking accuracy\n",
    "print('Test F1 score: ', f1_score(y_test, upsampled_pred))\n",
    "\n",
    "#checking confusion matrix\n",
    "from yellowbrick.classifier import ConfusionMatrix\n",
    "# The ConfusionMatrix visualizer taxes a model\n",
    "cm = ConfusionMatrix(upsampled_lr, classes=[0,1])\n",
    "\n",
    "# Fit fits the passed model. This is unnecessary if you pass the visualizer a pre-fitted model\n",
    "cm.fit(X_train, y_train)\n",
    "\n",
    "# To create the ConfusionMatrix, we need some test data. Score runs predict() on the data\n",
    "# and then creates the confusion_matrix from scikit-learn.\n",
    "cm.score(X_test, y_test)\n",
    "\n",
    "# How did we do?\n",
    "cm.poof()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Downsampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# downsample majority\n",
    "survived_downsampled = resample(deceased,\n",
    "                                replace = False, # sample without replacement\n",
    "                                n_samples = len(survived), # match minority n\n",
    "                                random_state = 23) # reproducible results\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    263\n",
       "0    263\n",
       "Name: Survived, dtype: int64"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# combine minority and downsampled majority\n",
    "downsampled = pd.concat([survived_downsampled, survived])\n",
    "\n",
    "# checking counts\n",
    "downsampled.Survived.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy score:  0.7802690582959642\n",
      "Test F1 score:  0.6711409395973155\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1c22498da0>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# trying logistic regression again with the balanced dataset\n",
    "y_train = downsampled.Survived\n",
    "X_train = downsampled.drop('Survived', axis=1)\n",
    "\n",
    "\n",
    "# downsampled_dt = DecisionTreeClassifier(max_depth=5)\n",
    "downsampled_lr = LogisticRegression(solver='liblinear')\n",
    "\n",
    "\n",
    "# downsampled_dt.fit(X_train, y_train)\n",
    "downsampled_lr.fit(X_train, y_train)\n",
    "\n",
    "\n",
    "# downsampled_pred = upsampled_dt.predict(X_test)\n",
    "downsampled_pred = downsampled_lr.predict(X_test)\n",
    "\n",
    "\n",
    "\n",
    "# checking accuracy\n",
    "print('Test Accuracy score: ', accuracy_score(y_test, downsampled_pred))\n",
    "\n",
    "\n",
    "# checking accuracy\n",
    "print('Test F1 score: ', f1_score(y_test, downsampled_pred))\n",
    "\n",
    "#checking confusion matrix\n",
    "\n",
    "# The ConfusionMatrix visualizer taxes a model\n",
    "cm = ConfusionMatrix(downsampled_lr, classes=[0,1])\n",
    "\n",
    "# Fit fits the passed model. This is unnecessary if you pass the visualizer a pre-fitted model\n",
    "cm.fit(X_train, y_train)\n",
    "\n",
    "# To create the ConfusionMatrix, we need some test data. Score runs predict() on the data\n",
    "# and then creates the confusion_matrix from scikit-learn.\n",
    "cm.score(X_test, y_test)\n",
    "\n",
    "# How did we do?\n",
    "cm.poof()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Over-sampling: SMOTE\n",
    "\n",
    "SMOTE (Synthetic Minority Oversampling Technique) consists of synthesizing elements for the minority class, based on those that already exist. It works randomly picking a point from the minority class and computing the k-nearest neighbors for this point. The synthetic points are added between the chosen point and its neighbors.\n",
    "\n",
    "![alt text](class_imb_images/smote.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from imblearn.over_sampling import SMOTE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# setting up testing and training sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=23)\n",
    "\n",
    "sm = SMOTE(random_state=23, ratio=1.0)\n",
    "X_train, y_train = sm.fit_sample(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy score:  0.7847533632286996\n",
      "Test F1 score:  0.68\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1c229a67f0>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# smote_dt = DecisionTreeClassifier(max_depth=5)\n",
    "smote_lr = LogisticRegression(solver='liblinear')\n",
    "\n",
    "\n",
    "# smote_dt.fit(X_train, y_train)\n",
    "smote_lr.fit(X_train, y_train)\n",
    "\n",
    "\n",
    "# smote_pred = smote_dt.predict(X_test)\n",
    "smote_pred = smote_lr.predict(X_test)\n",
    "\n",
    "\n",
    "\n",
    "# checking accuracy\n",
    "print('Test Accuracy score: ', accuracy_score(y_test, smote_pred))\n",
    "\n",
    "\n",
    "# checking accuracy\n",
    "print('Test F1 score: ', f1_score(y_test, smote_pred))\n",
    "\n",
    "# The ConfusionMatrix visualizer taxes a model\n",
    "cm = ConfusionMatrix(smote_lr, classes=[0,1])\n",
    "\n",
    "# Fit fits the passed model. This is unnecessary if you pass the visualizer a pre-fitted model\n",
    "cm.fit(X_train, y_train)\n",
    "\n",
    "# To create the ConfusionMatrix, we need some test data. Score runs predict() on the data\n",
    "# and then creates the confusion_matrix from scikit-learn.\n",
    "cm.score(X_test, y_test)\n",
    "\n",
    "# How did we do?\n",
    "cm.poof()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reading in the data... again\n",
    "\n",
    "titanic = pd.read_csv('cleaned_titanic.csv', index_col='PassengerId')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create matrix of features... again\n",
    "X = titanic.drop('Survived', axis = 1) # grabs everything else but 'Survived'\n",
    "\n",
    "# Create target variable\n",
    "y = titanic['Survived'] # y is the column we're trying to predict\n",
    "\n",
    "# Create a list of the features being used in the \n",
    "feature_cols = X.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setting up testing and training sets... again\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "feature_scaler = StandardScaler()\n",
    "X_train = feature_scaler.fit_transform(X_train)\n",
    "X_test = feature_scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "rf_classifier = RandomForestClassifier(n_estimators = 300, random_state = 0)\n",
    "lr_clf = LogisticRegression(solver = 'liblinear', random_state = 0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "all_accuracies = cross_val_score(estimator = rf_classifier, X = X_train, y = y_train, cv = 10, n_jobs = -1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.85294118 0.85294118 0.80882353 0.77272727 0.78787879 0.81818182\n",
      " 0.87878788 0.81818182 0.83333333 0.84848485]\n"
     ]
    }
   ],
   "source": [
    "print(all_accuracies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bringing it all together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import cross_validate\n",
    "\n",
    "all_scores = cross_validate(estimator = rf_classifier, X = X_train, y = y_train, \n",
    "                            cv = 10, n_jobs = -1, scoring = ['accuracy', 'f1', 'recall', 'precision'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'fit_time': array([0.32545114, 0.32095504, 0.32833385, 0.32107925, 0.34290791,\n",
       "        0.32908106, 0.33301091, 0.34138584, 0.21440792, 0.20806599]),\n",
       " 'score_time': array([0.11139774, 0.10996604, 0.11098909, 0.11124372, 0.10110712,\n",
       "        0.10580826, 0.09859324, 0.08287382, 0.05710506, 0.05774117]),\n",
       " 'test_accuracy': array([0.85294118, 0.85294118, 0.80882353, 0.77272727, 0.78787879,\n",
       "        0.81818182, 0.87878788, 0.81818182, 0.83333333, 0.84848485]),\n",
       " 'test_f1': array([0.80769231, 0.80769231, 0.76363636, 0.70588235, 0.74074074,\n",
       "        0.76923077, 0.84      , 0.77777778, 0.7755102 , 0.81481481]),\n",
       " 'test_recall': array([0.77777778, 0.77777778, 0.77777778, 0.69230769, 0.76923077,\n",
       "        0.76923077, 0.80769231, 0.80769231, 0.73076923, 0.84615385]),\n",
       " 'test_precision': array([0.84      , 0.84      , 0.75      , 0.72      , 0.71428571,\n",
       "        0.76923077, 0.875     , 0.75      , 0.82608696, 0.78571429])}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grid Search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "grid_param = {\n",
    "    'n_estimators': [100, 300, 500, 800, 1000],\n",
    "    'criterion': ['gini', 'entropy'],\n",
    "    'bootstrap': [True, False]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid_search = GridSearchCV(estimator = rf_classifier,\n",
    "                     param_grid = grid_param,\n",
    "                     scoring = 'accuracy',\n",
    "                     cv = 10,\n",
    "                     n_jobs = -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=10, error_score='raise-deprecating',\n",
       "             estimator=RandomForestClassifier(bootstrap=True, class_weight=None,\n",
       "                                              criterion='gini', max_depth=None,\n",
       "                                              max_features='auto',\n",
       "                                              max_leaf_nodes=None,\n",
       "                                              min_impurity_decrease=0.0,\n",
       "                                              min_impurity_split=None,\n",
       "                                              min_samples_leaf=1,\n",
       "                                              min_samples_split=2,\n",
       "                                              min_weight_fraction_leaf=0.0,\n",
       "                                              n_estimators=300, n_jobs=None,\n",
       "                                              oob_score=False, random_state=0,\n",
       "                                              verbose=0, warm_start=False),\n",
       "             iid='warn', n_jobs=-1,\n",
       "             param_grid={'bootstrap': [True, False],\n",
       "                         'criterion': ['gini', 'entropy'],\n",
       "                         'n_estimators': [100, 300, 500, 800, 1000]},\n",
       "             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,\n",
       "             scoring='accuracy', verbose=0)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid_search.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'bootstrap': True, 'criterion': 'gini', 'n_estimators': 100}\n"
     ]
    }
   ],
   "source": [
    "best_parameters = grid_search.best_params_\n",
    "print(best_parameters)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf_classifier_2 = RandomForestClassifier(n_estimators = 100, random_state = 0, \n",
    "                                         bootstrap = True, criterion = 'gini', n_jobs = -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_new_scores = cross_validate(estimator = rf_classifier_2, X = X_train, y = y_train, \n",
    "                            cv = 10, n_jobs = -1, scoring = ['accuracy', 'f1', 'recall', 'precision'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fit_time': array([0.15089417, 0.1473701 , 0.15543318, 0.15622497, 0.15899801,\n",
      "       0.15849376, 0.15693808, 0.16946101, 0.13340521, 0.13104415]), 'score_time': array([0.44790506, 0.44677472, 0.43614078, 0.42853689, 0.42459416,\n",
      "       0.42130208, 0.41829896, 0.42997599, 0.42834592, 0.42811704]), 'test_accuracy': array([0.85294118, 0.85294118, 0.82352941, 0.81818182, 0.78787879,\n",
      "       0.83333333, 0.84848485, 0.83333333, 0.84848485, 0.89393939]), 'test_f1': array([0.80769231, 0.80769231, 0.77777778, 0.76      , 0.74074074,\n",
      "       0.79245283, 0.8       , 0.8       , 0.79166667, 0.86792453]), 'test_recall': array([0.77777778, 0.77777778, 0.77777778, 0.73076923, 0.76923077,\n",
      "       0.80769231, 0.76923077, 0.84615385, 0.73076923, 0.88461538]), 'test_precision': array([0.84      , 0.84      , 0.77777778, 0.79166667, 0.71428571,\n",
      "       0.77777778, 0.83333333, 0.75862069, 0.86363636, 0.85185185])}\n"
     ]
    }
   ],
   "source": [
    "print(all_new_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}