breast_cancer_DL_model_selection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Breast Cancer Wisconsin (Diagnostic) Data Set</b> \n",
    "(reference to UCI Machine Learning Repository <a href=\"http://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+%28Diagnostic%29\">description</a>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# References\n",
    "# Compare results https://plot.ly/~s143717/87.embed\n",
    "# https://github.com/kzky/python-online-machine-learning-library/tree/master/evaluation/uci_small_dataset\n",
    "# https://github.com/tmadl/sklearn-random-rotation-ensembles\n",
    "# https://books.google.com/books?id=dltICgAAQBAJ&pg=PA29&lpg=PA29&dq=ionosphere+sklearn&source=bl&ots=MqQk59GzAh&sig=77iP6Lo3YaGBqPO1pAdTiZH7cLY&hl=en&sa=X&ved=0ahUKEwjF7MymmpfXAhWBOCYKHak7DtoQ6AEIRDAE#v=onepage&q=ionosphere%20sklearn&f=false"
   ]
  },
  {
   "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: 85%\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:       30\n",
      "number of classes:        2\n",
      "data type:                float32\n",
      "number of train samples:  381 (pos=236, neg=145, size=0MB)\n",
      "number of test samples:   188 (pos=121, neg=67, size=0MB)\n",
      "labels                    ['malignant' 'benign']\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_breast_cancer\n",
    "\n",
    "dataset = load_breast_cancer()\n",
    "feature_names = dataset.feature_names\n",
    "target_names = dataset.target_names\n",
    "data = pd.DataFrame(np.c_[dataset['target'], dataset['data']], columns= np.append(['diagnosis'], feature_names ))\n",
    "\n",
    "X = np.float32(data.drop('diagnosis', axis=1).values)\n",
    "y = np.int64(data['diagnosis'].values)   # conversion to int64 for pytorch\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, 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": 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 [20:55<00:00, 418.64s/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>0.990241</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.981016</td>\n",
       "      <td>0.014391</td>\n",
       "      <td>0.956522</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.987639</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.973632</td>\n",
       "      <td>0.015298</td>\n",
       "      <td>0.941176</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.982664</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.974673</td>\n",
       "      <td>0.012828</td>\n",
       "      <td>0.954545</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    0.990241  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     1    0.981016   0.014391   0.956522        1.0\n",
       "0    0.987639  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     0    0.973632   0.015298   0.941176        1.0\n",
       "0    0.982664  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     2    0.974673   0.012828   0.954545        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                                                       0.990241\n",
       " best_parameters         {'classifier__batch_shuffle': True, 'classifie...\n",
       " estimator               b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...\n",
       " trial                                                                   1\n",
       " score_mean                                                       0.981016\n",
       " score_std                                                       0.0143907\n",
       " score_min                                                        0.956522\n",
       " score_max                                                               1\n",
       " best_parameters_hash                                 -5928813628130602964\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': 30,\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.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': 100})"
      ]
     },
     "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>-5928813628130602964</th>\n",
       "      <td>1</td>\n",
       "      <td>0.981016</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.981016</td>\n",
       "      <td>0.981016</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>-994665197800371410</th>\n",
       "      <td>1</td>\n",
       "      <td>0.974673</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.974673</td>\n",
       "      <td>0.974673</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>-1561482673399617406</th>\n",
       "      <td>1</td>\n",
       "      <td>0.973632</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.973632</td>\n",
       "      <td>0.973632</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      count      mean  std       min       max\n",
       "best_parameters_hash                                          \n",
       "-5928813628130602964      1  0.981016  NaN  0.981016  0.981016\n",
       "-994665197800371410       1  0.974673  NaN  0.974673  0.974673\n",
       "-1561482673399617406      1  0.973632  NaN  0.973632  0.973632"
      ]
     },
     "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": [
       "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=30, module_D_out=2,\n",
       "      module_H=25, module_dropout=0.5,\n",
       "      module_initialize=<function torch_weight_init at 0x1a9e4140d0>,\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 0x1a9e40bd90>,\n",
       "      scoring=<function f1_score at 0x1a0aba27b8>,\n",
       "      stopping=<class 'lib.classifier.stopping.Stopping'>,\n",
       "      stopping_patience=100, 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",
      " [[ 63   4]\n",
      " [  6 115]]\n",
      "Accuracy  0.9468085106382979\n",
      "Recall    0.9504132231404959\n",
      "Precision 0.9663865546218487\n",
      "F1        0.9583333333333334\n",
      "ROC AUC   0.9453558653015913\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.9576023391812866 0.03947368421052632\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 0x1abd516cc0>"
      ]
     },
     "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 0x1ac88fbda0>"
      ]
     },
     "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
}