ionosphere_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-12 \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": [
    {
     "data": {
      "text/plain": [
       "([0,\n",
       "  1,\n",
       "  2,\n",
       "  3,\n",
       "  4,\n",
       "  5,\n",
       "  6,\n",
       "  7,\n",
       "  8,\n",
       "  9,\n",
       "  10,\n",
       "  11,\n",
       "  12,\n",
       "  13,\n",
       "  14,\n",
       "  15,\n",
       "  16,\n",
       "  17,\n",
       "  18,\n",
       "  19,\n",
       "  20,\n",
       "  21,\n",
       "  22,\n",
       "  23,\n",
       "  24,\n",
       "  25,\n",
       "  26,\n",
       "  27,\n",
       "  28,\n",
       "  29,\n",
       "  30,\n",
       "  31,\n",
       "  32,\n",
       "  33],\n",
       " ['bad', 'good'])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load dataset https://archive.ics.uci.edu/ml/datasets/ionosphere\n",
    "data = pd.read_csv(\"data/ionosphere.csv\", header=None)\n",
    "col_names = list(data.columns)\n",
    "feature_names = list(col_names[:-1])\n",
    "target_names = ['bad', 'good']\n",
    "\n",
    "cols = list(data)\n",
    "cols.insert(0, cols.pop(cols.index(34)))\n",
    "data = data.loc[:, cols]\n",
    "data.columns = col_names\n",
    "\n",
    "feature_names, target_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Dataset statistics:\n",
      "===================\n",
      "number of features:       34\n",
      "number of classes:        2\n",
      "data type:                float32\n",
      "number of train samples:  280 (pos=184, neg=96, size=0MB)\n",
      "number of test samples:   71 (pos=41, neg=30, size=0MB)\n",
      "labels                    ['g', 'b']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/sklearn/preprocessing/label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "X = np.float32(data.drop(0, axis=1).values)\n",
    "y = data[0].values   # conversion to int64 for pytorch\n",
    "\n",
    "# Encode target class\n",
    "encoder = LabelEncoder()\n",
    "y = np.int64(encoder.fit_transform(y))\n",
    "target_names = list(set(encoder.inverse_transform(y)))\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=True, \n",
    "                                                    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(3.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, 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": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/3 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 4 folds for each of 162 candidates, totalling 648 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=8)]: Done  34 tasks      | elapsed:  1.1min\n",
      "[Parallel(n_jobs=8)]: Done 184 tasks      | elapsed:  2.4min\n",
      "[Parallel(n_jobs=8)]: Done 434 tasks      | elapsed:  4.0min\n",
      "[Parallel(n_jobs=8)]: Done 648 out of 648 | elapsed:  5.0min finished\n",
      "[Parallel(n_jobs=8)]: Done   6 out of  10 | elapsed:   37.7s remaining:   25.1s\n",
      "[Parallel(n_jobs=8)]: Done  10 out of  10 | elapsed:   49.0s finished\n",
      " 33%|███▎      | 1/3 [05:56<11:52, 356.39s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 4 folds for each of 162 candidates, totalling 648 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=8)]: Done  34 tasks      | elapsed:   59.1s\n",
      "[Parallel(n_jobs=8)]: Done 184 tasks      | elapsed:  1.9min\n",
      "[Parallel(n_jobs=8)]: Done 434 tasks      | elapsed:  3.7min\n",
      "[Parallel(n_jobs=8)]: Done 648 out of 648 | elapsed:  4.7min finished\n",
      "[Parallel(n_jobs=8)]: Done   6 out of  10 | elapsed:   37.0s remaining:   24.7s\n",
      "[Parallel(n_jobs=8)]: Done  10 out of  10 | elapsed:   48.6s finished\n",
      " 67%|██████▋   | 2/3 [11:33<05:46, 346.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 4 folds for each of 162 candidates, totalling 648 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=8)]: Done  34 tasks      | elapsed:  1.2min\n",
      "[Parallel(n_jobs=8)]: Done 184 tasks      | elapsed:  2.4min\n",
      "[Parallel(n_jobs=8)]: Done 434 tasks      | elapsed:  4.1min\n",
      "[Parallel(n_jobs=8)]: Done 648 out of 648 | elapsed:  5.0min finished\n",
      "[Parallel(n_jobs=8)]: Done   6 out of  10 | elapsed:   37.8s remaining:   25.2s\n",
      "[Parallel(n_jobs=8)]: Done  10 out of  10 | elapsed:   49.4s finished\n",
      "100%|██████████| 3/3 [17:28<00:00, 349.61s/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=8)\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=8)['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.939081</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.930636</td>\n",
       "      <td>0.049744</td>\n",
       "      <td>0.848485</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.934899</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.941240</td>\n",
       "      <td>0.044371</td>\n",
       "      <td>0.833333</td>\n",
       "      <td>0.975610</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.928005</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.926975</td>\n",
       "      <td>0.052094</td>\n",
       "      <td>0.785714</td>\n",
       "      <td>0.976744</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.939081  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     2    0.930636   0.049744   0.848485   1.000000\n",
       "0    0.934899  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     0    0.941240   0.044371   0.833333   0.975610\n",
       "0    0.928005  {'classifier__batch_shuffle': True, 'classifie...  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     1    0.926975   0.052094   0.785714   0.976744"
      ]
     },
     "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.928005\n",
       " best_parameters         {'classifier__batch_shuffle': True, 'classifie...\n",
       " estimator               b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...\n",
       " trial                                                                   1\n",
       " score_mean                                                       0.926975\n",
       " score_std                                                       0.0520937\n",
       " score_min                                                        0.785714\n",
       " score_max                                                        0.976744\n",
       " best_parameters_hash                                 -7998839408373685133\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': src.model.MLP,\n",
       "  'classifier__module_D_in': 34,\n",
       "  'classifier__module_D_out': 2,\n",
       "  'classifier__module_H': 20,\n",
       "  'classifier__module_initialize': <function src.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 src.classifier.utilities.exp_decay>,\n",
       "  'classifier__scoring': <function sklearn.metrics.classification.f1_score>,\n",
       "  'classifier__stopping': src.classifier.stopping.Stopping,\n",
       "  'classifier__stopping_patience': 140})"
      ]
     },
     "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>-3162071643375528485</th>\n",
       "      <td>1</td>\n",
       "      <td>0.941240</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.941240</td>\n",
       "      <td>0.941240</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5490519590098870542</th>\n",
       "      <td>1</td>\n",
       "      <td>0.930636</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.930636</td>\n",
       "      <td>0.930636</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>-7998839408373685133</th>\n",
       "      <td>1</td>\n",
       "      <td>0.926975</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.926975</td>\n",
       "      <td>0.926975</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      count      mean  std       min       max\n",
       "best_parameters_hash                                          \n",
       "-3162071643375528485      1  0.941240  NaN  0.941240  0.941240\n",
       " 5490519590098870542      1  0.930636  NaN  0.930636  0.930636\n",
       "-7998839408373685133      1  0.926975  NaN  0.926975  0.926975"
      ]
     },
     "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=3.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=100,\n",
       "      criterion=<class 'torch.nn.modules.loss.CrossEntropyLoss'>,\n",
       "      criterion_size_average=True, max_epochs=1000,\n",
       "      module=<class 'src.model.MLP'>, module_D_in=34, module_D_out=2,\n",
       "      module_H=20, module_dropout=0.5,\n",
       "      module_initialize=<function torch_weight_init at 0x1aa96c00d0>,\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 0x1aa96b7d90>,\n",
       "      scoring=<function f1_score at 0x11540b7b8>,\n",
       "      stopping=<class 'src.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": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion Matrix\n",
      " [[30  0]\n",
      " [ 0 41]]\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": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy score: 0.9 0.1285714285714286\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 0x1ac8394eb8>"
      ]
     },
     "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 0x1ad7585320>"
      ]
     },
     "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
}