mushroom_DL_model_selection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Mushroom Data Set</b> \n",
    "(reference to UCI Machine Learning Repository <a href=\"https://archive.ics.uci.edu/ml/datasets/mushroom\">description</a>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://andreasondata.wordpress.com/author/andreasondata/\n",
    "# http://josephwoolf.com/wp-content/uploads/2017/05/Edibility-of-a-Mushroom.pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# coding: utf-8\n",
    "import multiprocessing \n",
    "multiprocessing.set_start_method('spawn')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tb 2018-09-13 \n",
      "\n",
      "CPython 3.6.4\n",
      "IPython 6.2.1\n",
      "\n",
      "sys 3.6.4 |Anaconda custom (64-bit)| (default, Jan 16 2018, 12:04:33) \n",
      "[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)]\n",
      "numpy 1.14.2\n",
      "pandas 0.22.0\n",
      "sklearn 0.19.2\n",
      "torch 0.4.0a0+9692519\n",
      "IPython 6.2.1\n",
      "\n",
      "compiler   : GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)\n",
      "system     : Darwin\n",
      "release    : 17.5.0\n",
      "machine    : x86_64\n",
      "processor  : i386\n",
      "CPU cores  : 24\n",
      "interpreter: 64bit\n",
      "\n",
      "GPU Name: TITAN Xp\n",
      "GPU Memory: 12.0GB\n",
      "CUDA Version: (9, 1, 0)\n",
      "GPU Free/Total Memory: 93%\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pylab import rcParams\n",
    "rcParams['figure.figsize'] = 14, 8\n",
    "\n",
    "from IPython.display import display\n",
    "import pickle\n",
    "\n",
    "import numpy as np\n",
    "np.set_printoptions(precision=4, threshold=10000, linewidth=100, edgeitems=999, suppress=True)\n",
    "\n",
    "import pandas as pd\n",
    "pd.set_option('display.max_columns', 30)\n",
    "pd.set_option('display.width', 200)\n",
    "pd.set_option('display.max_rows', 500)\n",
    "pd.set_option('display.max_columns', 500)\n",
    "pd.set_option('display.width', 1000)\n",
    "pd.set_option('precision', 6)\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "import seaborn as sns\n",
    "sns.set()\n",
    "\n",
    "from tqdm import tqdm_notebook, tqdm\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler, RobustScaler, Normalizer\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from imblearn.over_sampling import RandomOverSampler, SMOTE\n",
    "from sklearn.model_selection import ShuffleSplit, KFold\n",
    "from sklearn.model_selection import GridSearchCV, cross_val_score, KFold, RandomizedSearchCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import (ExtraTreesClassifier, RandomForestClassifier, \n",
    "                              AdaBoostClassifier, GradientBoostingClassifier)\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "from sklearn import metrics\n",
    "from sklearn.model_selection import learning_curve\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import cross_validate\n",
    "from sklearn.model_selection import ShuffleSplit, KFold\n",
    "from sklearn.model_selection import GridSearchCV, cross_val_score, KFold, RandomizedSearchCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import validation_curve\n",
    "from imblearn.pipeline import Pipeline\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "\n",
    "from lib.utils import *\n",
    "\n",
    "from lib.classifier import Classifier, torch_weight_init, Stopping, OutlierSampler, exp_decay, to_var, PytorchLogger\n",
    "\n",
    "from lib.model import MLP, MLP_vanilla\n",
    "\n",
    "%load_ext watermark\n",
    "%watermark -a \"tb\" -d -v -m -p sys,numpy,pandas,sklearn,torch,IPython\n",
    "gpu_stat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters\n",
    "HP = HYPERPARAMETERS({\n",
    "    \"GPU\"                 : True ,\n",
    "    \"SEED\"                : 0\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if not HP.SEED:\n",
    "#     torch.cuda.is_available = lambda : False\n",
    "\n",
    "# Seed random generators for repro \n",
    "np.random.seed(HP.SEED)  \n",
    "# torch.manual_seed(HP.SEED);\n",
    "# if torch.cuda.is_available():\n",
    "#     torch.cuda.manual_seed(HP.SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Dataset statistics:\n",
      "===================\n",
      "number of features:       22\n",
      "number of classes:        2\n",
      "data type:                float32\n",
      "number of train samples:  5443 (pos=2641, neg=2802, size=0MB)\n",
      "number of test samples:   2681 (pos=1275, neg=1406, size=0MB)\n",
      "labels                    ['edible', 'poisonous']\n"
     ]
    }
   ],
   "source": [
    "dataframe = pd.read_csv(\"data/agaricus-lepiota.csv\", header=None)\n",
    "\n",
    "# Read Header file\n",
    "feature_names= []\n",
    "with open('data/agaricus-lepiota.txt', 'r') as f_names:\n",
    "    for line in f_names:\n",
    "        feature_names.append(line.strip())\n",
    "dataframe.columns = ['class'] + feature_names\n",
    "target_names = ['edible', 'poisonous']\n",
    "\n",
    "#Transform data form categorial to numeric\n",
    "cat_variables = [i for i in dataframe.columns if dataframe[i].dtype == 'object']\n",
    "encods = [LabelEncoder() for col in cat_variables]\n",
    "for i, col in enumerate(cat_variables):\n",
    "    dataframe[col] = encods[i].fit_transform(dataframe[col].astype(str))\n",
    "    \n",
    "    \n",
    "X = np.float32(dataframe.values[:,1:])\n",
    "y = np.int64(dataframe.values[:,0])\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, shuffle=True, random_state=None)\n",
    "\n",
    "dataset_statistics(X_train, y_train, X_test, y_test, target_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    'module'                       : MLP,\n",
    "    'module_H'                     : 12,\n",
    "    'module_D_in'                  : X_train.shape[1] ,\n",
    "    'module_D_out'                 : 2 ,\n",
    "\n",
    "    'module_initialize'            : torch_weight_init ,\n",
    "\n",
    "    'max_epochs'                   : 1000,\n",
    "    'batch_size'                   : 100 ,\n",
    "    'batch_shuffle'                : True,\n",
    "\n",
    "    'optimizer'                    : torch.optim.SGD ,\n",
    "    'optimizer_lr'                 : 0.5 ,\n",
    "    'optimizer_momentum'           : 0.9 ,\n",
    "    'optimizer_weight_decay'       : 5e-4 ,\n",
    "    'optimizer_nesterov'           : True ,\n",
    "\n",
    "    'criterion'                    : nn.CrossEntropyLoss ,\n",
    "    'criterion_size_average'       : True ,\n",
    "\n",
    "    'scheduler'                    : torch.optim.lr_scheduler.LambdaLR ,\n",
    "    'scheduler_lr_lambda'          : exp_decay ,\n",
    "\n",
    "    'stopping'                     : Stopping ,\n",
    "    'stopping_patience'            : 120 ,\n",
    "\n",
    "    'scoring'                      : metrics.f1_score ,\n",
    "\n",
    "    'random_state'                 : 10\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipeline = Pipeline(steps=[\n",
    "                ('scaler',     MinMaxScaler(copy=True)),\n",
    "#                 ('outlier',    OutlierSampler(8.5)),\n",
    "                ('sampler',    RandomOverSampler(random_state=HP.SEED)),\n",
    "                ('classifier', Classifier(**params))\n",
    "                ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_grid = {\n",
    "    'classifier__module'                       : [MLP, MLP_vanilla],\n",
    "    'classifier__module_H'                     : [ 15, 20, 25] , \n",
    "    'classifier__module_D_in'                  : [X_train.shape[1]] ,\n",
    "    'classifier__module_D_out'                 : [2] ,\n",
    "\n",
    "    'classifier__module_initialize'            : [torch_weight_init] ,\n",
    "\n",
    "    'classifier__max_epochs'                   : [1000],\n",
    "    'classifier__batch_size'                   : [80, 100, 120] ,\n",
    "    'classifier__batch_shuffle'                : [True],\n",
    "\n",
    "    'classifier__optimizer'                    : [torch.optim.SGD] ,\n",
    "    'classifier__optimizer_lr'                 : [0.5, 0.1, 0.05] ,\n",
    "    'classifier__optimizer_momentum'           : [0.9] ,\n",
    "    'classifier__optimizer_weight_decay'       : [5e-4] ,\n",
    "    'classifier__optimizer_nesterov'           : [True] ,\n",
    "\n",
    "    'classifier__criterion'                    : [nn.CrossEntropyLoss] ,\n",
    "    'classifier__criterion_size_average'       : [True] ,\n",
    "\n",
    "    'classifier__scheduler'                    : [torch.optim.lr_scheduler.LambdaLR] ,\n",
    "    'classifier__scheduler_lr_lambda'          : [exp_decay] ,\n",
    "\n",
    "    'classifier__stopping'                     : [Stopping] ,\n",
    "    'classifier__stopping_patience'            : [100, 120, 140] ,\n",
    "\n",
    "    'classifier__scoring'                      : [metrics.f1_score] ,\n",
    "\n",
    "    'classifier__random_state'                 : [10]\n",
    "}\n",
    "\n",
    "scoring = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3/3 [3:56:54<00:00, 4738.31s/it]  \n"
     ]
    }
   ],
   "source": [
    "NUM_TRIALS = 3\n",
    "\n",
    "trial_scores_columns = ['best_score', 'best_parameters', 'estimator',\n",
    "                        'trial', 'score_mean', 'score_std', 'score_min', 'score_max']\n",
    "trial_scores = pd.DataFrame(columns=trial_scores_columns)\n",
    "for trial in tqdm(range(NUM_TRIALS)):\n",
    "    \n",
    "    cv = KFold(n_splits=4, shuffle=True, random_state=trial)\n",
    "    gscv = GridSearchCV(estimator=pipeline, param_grid=param_grid, cv=cv, scoring=scoring, \n",
    "                        verbose=0, n_jobs=4)\n",
    "    gscv.fit(X_train, y_train)\n",
    "\n",
    "    best_estimator = pickle.dumps(gscv.best_estimator_)\n",
    "    best_score = gscv.best_score_\n",
    "    best_parameters = gscv.best_params_\n",
    "\n",
    "    cv = KFold(n_splits=10, shuffle=True, random_state=trial).split(X_train)\n",
    "    scores = cross_validate(gscv.best_estimator_, X_train, y_train, \n",
    "                            cv=cv, return_train_score=True,  scoring=scoring, \n",
    "                            verbose=0, n_jobs=6)['test_score']\n",
    "    \n",
    "    trial_scores = trial_scores.append(pd.DataFrame([[\n",
    "        best_score, best_parameters, best_estimator, \n",
    "        trial, np.mean(scores), np.std(scores), np.min(scores), np.max(scores)\n",
    "    ]], columns=trial_scores_columns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>best_score</th>\n",
       "      <th>best_parameters</th>\n",
       "      <th>estimator</th>\n",
       "      <th>trial</th>\n",
       "      <th>score_mean</th>\n",
       "      <th>score_std</th>\n",
       "      <th>score_min</th>\n",
       "      <th>score_max</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>{'classifier__batch_shuffle': True, 'classifie...</td>\n",
       "      <td>b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>{'classifier__batch_shuffle': True, 'classifie...</td>\n",
       "      <td>b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...</td>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.999463</td>\n",
       "      <td>{'classifier__batch_shuffle': True, 'classifie...</td>\n",
       "      <td>b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...</td>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   best_score                                    best_parameters                                          estimator trial  score_mean  score_std  score_min  score_max\n",
       "0    1.000000  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     1         1.0        0.0        1.0        1.0\n",
       "0    1.000000  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     2         1.0        0.0        1.0        1.0\n",
       "0    0.999463  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     0         1.0        0.0        1.0        1.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trial_scores.sort_values('best_score', ascending=False).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(best_score                                                              1\n",
       " best_parameters         {'classifier__batch_shuffle': True, 'classifie...\n",
       " estimator               b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...\n",
       " trial                                                                   1\n",
       " score_mean                                                              1\n",
       " score_std                                                               0\n",
       " score_min                                                               1\n",
       " score_max                                                               1\n",
       " best_parameters_hash                                 -8563661599625559721\n",
       " Name: 0, dtype: object,\n",
       " {'classifier__batch_shuffle': True,\n",
       "  'classifier__batch_size': 100,\n",
       "  'classifier__criterion': torch.nn.modules.loss.CrossEntropyLoss,\n",
       "  'classifier__criterion_size_average': True,\n",
       "  'classifier__max_epochs': 1000,\n",
       "  'classifier__module': lib.model.MLP,\n",
       "  'classifier__module_D_in': 22,\n",
       "  'classifier__module_D_out': 2,\n",
       "  'classifier__module_H': 20,\n",
       "  'classifier__module_initialize': <function lib.classifier.utilities.torch_weight_init>,\n",
       "  'classifier__optimizer': torch.optim.sgd.SGD,\n",
       "  'classifier__optimizer_lr': 0.5,\n",
       "  'classifier__optimizer_momentum': 0.9,\n",
       "  'classifier__optimizer_nesterov': True,\n",
       "  'classifier__optimizer_weight_decay': 0.0005,\n",
       "  'classifier__random_state': 10,\n",
       "  'classifier__scheduler': torch.optim.lr_scheduler.LambdaLR,\n",
       "  'classifier__scheduler_lr_lambda': <function lib.classifier.utilities.exp_decay>,\n",
       "  'classifier__scoring': <function sklearn.metrics.classification.f1_score>,\n",
       "  'classifier__stopping': lib.classifier.stopping.Stopping,\n",
       "  'classifier__stopping_patience': 140})"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trial_scores['best_parameters_hash'] = trial_scores['best_parameters'].apply(lambda x : hash(str(x)))\n",
    "trial_selected = trial_scores.groupby(['best_parameters_hash'])['score_mean'].agg(['count']).sort_values('count', ascending=False).iloc[0]\n",
    "df_tmp = trial_scores[(trial_scores['best_parameters_hash'] == trial_selected.name)]\n",
    "trial_clf = df_tmp[(df_tmp['best_parameters_hash'] == trial_selected.name)].iloc[0]\n",
    "trial_clf, trial_clf['best_parameters']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>best_parameters_hash</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>-8563661599625559721</th>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8151195821507829093</th>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9131242952668997707</th>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      count  mean  std  min  max\n",
       "best_parameters_hash                            \n",
       "-8563661599625559721      1   1.0  NaN  1.0  1.0\n",
       " 8151195821507829093      1   1.0  NaN  1.0  1.0\n",
       " 9131242952668997707      1   1.0  NaN  1.0  1.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trial_scores.groupby(['best_parameters_hash'])['score_mean'].agg(['count', 'mean', 'std', 'min', 'max']).sort_values('mean', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MinMaxScaler(copy=True, feature_range=(0, 1))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "RandomOverSampler(random_state=0, ratio='auto')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Classifier(batch_shuffle=True, batch_size=100,\n",
       "      criterion=<class 'torch.nn.modules.loss.CrossEntropyLoss'>,\n",
       "      criterion_size_average=True, max_epochs=1000,\n",
       "      module=<class 'lib.model.MLP'>, module_D_in=22, module_D_out=2,\n",
       "      module_H=20, module_dropout=0.5,\n",
       "      module_initialize=<function torch_weight_init at 0x1a9ea8a158>,\n",
       "      optimizer=<class 'torch.optim.sgd.SGD'>, optimizer_lr=0.5,\n",
       "      optimizer_momentum=0.9, optimizer_nesterov=True,\n",
       "      optimizer_weight_decay=0.0005, progress_bar=None, random_state=10,\n",
       "      scheduler=<class 'torch.optim.lr_scheduler.LambdaLR'>,\n",
       "      scheduler_lr_lambda=<function exp_decay at 0x1a9ea81e18>,\n",
       "      scoring=<function f1_score at 0x1a0b1c4840>,\n",
       "      stopping=<class 'lib.classifier.stopping.Stopping'>,\n",
       "      stopping_patience=140, validation_ratio=0.2, validation_shuffle=True,\n",
       "      verbose=0)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pipeline = pickle.loads(trial_clf['estimator'])\n",
    "\n",
    "for pip_name in pipeline.named_steps:\n",
    "    display(pipeline.named_steps[pip_name])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion Matrix\n",
      " [[1406    0]\n",
      " [   0 1275]]\n",
      "Accuracy  1.0\n",
      "Recall    1.0\n",
      "Precision 1.0\n",
      "F1        1.0\n",
      "ROC AUC   1.0\n"
     ]
    }
   ],
   "source": [
    "y_pred = pipeline.predict(X_test)\n",
    "y_prob = pipeline.predict_proba(X_test)\n",
    "\n",
    "print('Confusion Matrix\\n', metrics.confusion_matrix(y_test, y_pred))  # Confusion Matrix\n",
    "print('Accuracy ', metrics.accuracy_score(y_test, y_pred))            # Accuracy (TP + TN) / float(TP + TN + FP + FN)\n",
    "print('Recall   ', metrics.recall_score(y_test, y_pred))                # Recall (Sensitivity)   TP / float(FN + TP)\n",
    "print('Precision', metrics.precision_score(y_test, y_pred))     \n",
    "print('F1       ', metrics.f1_score(y_test, y_pred))     \n",
    "print('ROC AUC  ', metrics.roc_auc_score(y_test, y_pred))     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy score: 0.9992537313432835 0.001492537313432818\n"
     ]
    }
   ],
   "source": [
    "#  Cross-validate score on test set\n",
    "cv = KFold(n_splits=10, shuffle=True, random_state=HP.SEED).split(X_test)\n",
    "scores = cross_val_score(pipeline, X_test, y_test, cv=cv, scoring='accuracy', \n",
    "                         verbose=0, n_jobs=4)\n",
    "\n",
    "print(\"Test accuracy score:\", np.mean(scores), np.std(scores))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1abe875898>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "clf = pipeline.named_steps['classifier']\n",
    "plot_loss_curve(clf.loss_train_, clf.score_train_,  clf.loss_valid_, clf.score_valid_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1acd68ab70>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    cv = KFold(n_splits=10, shuffle=True, random_state=HP.SEED).split(X_train)\n",
    "    plot_learning_curve(pipeline, 'Learning Curves', X_train, y_train, cv=cv, shuffle=True, \n",
    "                        n_jobs=4, random_state=HP.SEED)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}