diabetic_DL_model_selection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Diabetes Data Set</b> (reference to UCI Machine Learning Repository <a href=\"https://archive.ics.uci.edu/ml/datasets/diabetes\">description</a>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# coding: utf-8\n",
    "import multiprocessing \n",
    "multiprocessing.set_start_method('spawn')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tb 2018-09-14 \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: 95%\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": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters\n",
    "HP = HYPERPARAMETERS({\n",
    "    \"GPU\"                 : True ,\n",
    "    \"SEED\"                : 0\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://archive.ics.uci.edu/ml/datasets/diabetes\n",
    "dataframe = pd.read_csv(\"data/diabetic_data.csv\")\n",
    "dataframe.drop('encounter_id', axis=1, inplace=True)\n",
    "dataframe.drop('patient_nbr', axis=1, inplace=True)\n",
    "dataframe.drop('payer_code', axis=1, inplace=True)\n",
    "dataframe.drop('weight', axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe['readmitted'] = dataframe['readmitted'].apply(lambda x: 1 if x == '<30' else 0)\n",
    "\n",
    "cols = list(dataframe)\n",
    "cols.insert(0, cols.pop(cols.index('readmitted')))\n",
    "dataframe = dataframe.loc[:, cols]\n",
    "\n",
    "feature_names = dataframe.columns[1:]\n",
    "target_names = ['no', 'readmitted']\n",
    "\n",
    "# Transform data form categorial to numeric\n",
    "cat_variables = [i for i in dataframe.columns[1:] 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",
    "data = dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Dataset statistics:\n",
      "===================\n",
      "number of features:       45\n",
      "number of classes:        2\n",
      "data type:                float32\n",
      "number of train samples:  81412 (pos=9116, neg=72296, size=14MB)\n",
      "number of test samples:   20354 (pos=2241, neg=18113, size=3MB)\n",
      "labels                    ['no', 'readmitted']\n"
     ]
    }
   ],
   "source": [
    "X = np.float32(data.values[:,1:])\n",
    "y = np.int64(data.values[:,0])\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=True, random_state=HP.SEED)\n",
    "\n",
    "dataset_statistics(X_train, y_train, X_test, y_test, target_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 9,
   "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": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_grid = {\n",
    "    'classifier__module'                       : [MLP],\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] ,\n",
    "    'classifier__batch_shuffle'                : [True],\n",
    "\n",
    "    'classifier__optimizer'                    : [torch.optim.SGD] ,\n",
    "    'classifier__optimizer_lr'                 : [0.1, 0.5, 0.9] ,\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'            : [80] ,\n",
    "\n",
    "    'classifier__scoring'                      : [metrics.f1_score] ,\n",
    "\n",
    "    'classifier__random_state'                 : [10]\n",
    "}\n",
    "\n",
    "scoring = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3/3 [3:05:09<00:00, 3703.26s/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=6)\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": 12,
   "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>0.243858</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>0.242555</td>\n",
       "      <td>0.009844</td>\n",
       "      <td>0.230711</td>\n",
       "      <td>0.262815</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.243513</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>0.244239</td>\n",
       "      <td>0.010405</td>\n",
       "      <td>0.231137</td>\n",
       "      <td>0.260629</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.242158</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>0.240798</td>\n",
       "      <td>0.008498</td>\n",
       "      <td>0.224108</td>\n",
       "      <td>0.252025</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    0.243858  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     0    0.242555   0.009844   0.230711   0.262815\n",
       "0    0.243513  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     2    0.244239   0.010405   0.231137   0.260629\n",
       "0    0.242158  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     1    0.240798   0.008498   0.224108   0.252025"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trial_scores.sort_values('best_score', ascending=False).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(best_score                                                       0.243858\n",
       " best_parameters         {'classifier__batch_shuffle': True, 'classifie...\n",
       " estimator               b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...\n",
       " trial                                                                   0\n",
       " score_mean                                                       0.242555\n",
       " score_std                                                      0.00984422\n",
       " score_min                                                        0.230711\n",
       " score_max                                                        0.262815\n",
       " best_parameters_hash                                  2967321065481003606\n",
       " Name: 0, dtype: object,\n",
       " {'classifier__batch_shuffle': True,\n",
       "  'classifier__batch_size': 80,\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': 45,\n",
       "  'classifier__module_D_out': 2,\n",
       "  'classifier__module_H': 25,\n",
       "  'classifier__module_initialize': <function lib.classifier.utilities.torch_weight_init>,\n",
       "  'classifier__optimizer': torch.optim.sgd.SGD,\n",
       "  'classifier__optimizer_lr': 0.1,\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': 80})"
      ]
     },
     "execution_count": 13,
     "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": 14,
   "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>476730922296938104</th>\n",
       "      <td>1</td>\n",
       "      <td>0.244239</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.244239</td>\n",
       "      <td>0.244239</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2967321065481003606</th>\n",
       "      <td>2</td>\n",
       "      <td>0.241676</td>\n",
       "      <td>0.001242</td>\n",
       "      <td>0.240798</td>\n",
       "      <td>0.242555</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      count      mean       std       min       max\n",
       "best_parameters_hash                                               \n",
       "476730922296938104        1  0.244239       NaN  0.244239  0.244239\n",
       "2967321065481003606       2  0.241676  0.001242  0.240798  0.242555"
      ]
     },
     "execution_count": 14,
     "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": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MinMaxScaler(copy=True, feature_range=(0, 1))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "OutlierSampler(memory=None, threshold=8.5, verbose=0)"
      ]
     },
     "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=80,\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=45, module_D_out=2,\n",
       "      module_H=25, module_dropout=0.5,\n",
       "      module_initialize=<function torch_weight_init at 0x1aa8acc0d0>,\n",
       "      optimizer=<class 'torch.optim.sgd.SGD'>, optimizer_lr=0.1,\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 0x1aa8ac3d90>,\n",
       "      scoring=<function f1_score at 0x1148167b8>,\n",
       "      stopping=<class 'lib.classifier.stopping.Stopping'>,\n",
       "      stopping_patience=80, 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": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion Matrix\n",
      " [[11797  6316]\n",
      " [ 1072  1169]]\n",
      "Accuracy  0.6370246634568144\n",
      "Recall    0.5216421240517626\n",
      "Precision 0.15617902471609887\n",
      "F1        0.24038659263828913\n",
      "ROC AUC   0.5864711475997785\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": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy score: 0.6689594184289666 0.01493122031291325\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": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1ab3f3ab00>"
      ]
     },
     "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": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1ab325ff28>"
      ]
     },
     "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
}