mushroom_ML_model_search.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": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from collections import Counter\n",
    "import os, pickle    \n",
    "\n",
    "from tqdm import tqdm\n",
    "\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.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 imblearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import validation_curve\n",
    "from imblearn.pipeline import Pipeline\n",
    "\n",
    "from lib.utils import *\n",
    "\n",
    "import warnings\n",
    "warnings.simplefilter(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters\n",
    "HP = HYPERPARAMETERS({\n",
    "    \"GPU\"                 : True ,\n",
    "    \"SEED\"                : 0\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Seed random generators for repro \n",
    "np.random.seed(HP.SEED)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipelines =  [\n",
    "     {'ExtraTreesClassifier1': Pipeline(steps=[\n",
    "                ('scaler',     StandardScaler(copy=True, with_mean=True, with_std=True)),\n",
    "#                 ('outlier',    OutlierSampler(8.5)),\n",
    "                ('sampler',    SMOTE(ratio='auto', random_state=HP.SEED)),\n",
    "                ('classifier', ExtraTreesClassifier())\n",
    "                ])},\n",
    "     {'ExtraTreesClassifier2': Pipeline(steps=[\n",
    "#                 ('outlier',    OutlierSampler(8.5)),\n",
    "                ('sampler',    RandomOverSampler(ratio='auto', random_state=HP.SEED)),\n",
    "                ('classifier', ExtraTreesClassifier())\n",
    "                ])},\n",
    "     {'RandomForestClassifier1': Pipeline(steps=[\n",
    "                ('scaler',     StandardScaler(copy=True, with_mean=True, with_std=True)),\n",
    "#                 ('outlier',    OutlierSampler(8.5)),\n",
    "                ('sampler',    SMOTE(ratio='auto', random_state=HP.SEED)),\n",
    "                ('classifier', RandomForestClassifier())\n",
    "                ])},\n",
    "     {'RandomForestClassifier2': Pipeline(steps=[\n",
    "                ('scaler',     MinMaxScaler(copy=True)),\n",
    "#                 ('outlier',    OutlierSampler(8.5)),\n",
    "                ('sampler',    RandomOverSampler(ratio='auto', random_state=HP.SEED)),\n",
    "                ('classifier', RandomForestClassifier())\n",
    "                ])},\n",
    "     {'GradientBoostingClassifier1': Pipeline(steps=[\n",
    "                ('scaler',     MinMaxScaler(copy=True)),\n",
    "#                 ('outlier',    OutlierSampler(8.5)),\n",
    "                ('sampler',    RandomOverSampler(ratio='auto', random_state=HP.SEED)),\n",
    "                ('classifier', GradientBoostingClassifier())\n",
    "                ])},\n",
    "     {'GradientBoostingClassifier2': Pipeline(steps=[\n",
    "                ('scaler',     StandardScaler(copy=True, with_mean=True, with_std=True)),\n",
    "#                 ('outlier',    OutlierSampler(8.5)),\n",
    "                ('sampler',    SMOTE(ratio='auto', random_state=HP.SEED)),\n",
    "                ('classifier', GradientBoostingClassifier())\n",
    "                ])},\n",
    "     {'SVC1': Pipeline(steps=[\n",
    "                ('scaler',     StandardScaler(copy=True, with_mean=True, with_std=True)),\n",
    "#                 ('outlier',    OutlierSampler(8.5)),\n",
    "                ('sampler',    SMOTE(ratio='auto', random_state=HP.SEED)),\n",
    "                ('classifier', SVC())\n",
    "                ])},\n",
    "     {'SVC2': Pipeline(steps=[\n",
    "#                 ('outlier',    OutlierSampler(8.5)),\n",
    "                ('sampler',    RandomOverSampler(ratio='auto', random_state=HP.SEED)),\n",
    "                ('classifier', SVC())\n",
    "                ])},\n",
    "#      {'LogisticRegression1': Pipeline(steps=[\n",
    "#                 ('scaler',     StandardScaler(copy=True, with_mean=True, with_std=True)),\n",
    "# #                 ('outlier',    OutlierSampler(8.5)),\n",
    "#                 ('sampler',    SMOTE(ratio='auto', random_state=HP.SEED)),\n",
    "#                 ('classifier', LogisticRegression())\n",
    "#                 ])},\n",
    "#     {'LogisticRegression2': Pipeline(steps=[\n",
    "# #                 ('outlier',    OutlierSampler(8.5)),\n",
    "#                 ('sampler',    RandomOverSampler(ratio='auto', random_state=HP.SEED)),\n",
    "#                 ('classifier', LogisticRegression())\n",
    "#                 ])},\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters = [\n",
    "     {'ExtraTreesClassifier1': \n",
    "      { 'classifier__n_estimators'      : [8, 16, 32] ,\n",
    "        'classifier__max_features'      : ['auto', 'sqrt', 'log2', None],\n",
    "        \"classifier__max_depth\"         : [1, 10, 20],\n",
    "        \"classifier__min_samples_split\" : [2, 4] ,\n",
    "        \"classifier__bootstrap\"         : [True, False]\n",
    "      }},\n",
    "     {'ExtraTreesClassifier2': \n",
    "      { 'classifier__n_estimators'      : [8, 16, 32] ,\n",
    "        'classifier__max_features'      : ['auto', 'sqrt', 'log2', None],\n",
    "        \"classifier__max_depth\"         : [1, 10, 20],\n",
    "        \"classifier__min_samples_split\" : [2, 4] ,\n",
    "        \"classifier__bootstrap\"         : [True, False]\n",
    "      }},\n",
    "     {'RandomForestClassifier1': \n",
    "      { 'classifier__n_estimators'      : [8, 32, 64] ,\n",
    "        \"classifier__criterion\"         : [\"gini\", \"entropy\"],\n",
    "        'classifier__max_features'      : ['auto', 'sqrt', 'log2', None],\n",
    "        \"classifier__max_depth\"         : [1, 10, 20],\n",
    "        \"classifier__min_samples_split\" : [2, 4] ,\n",
    "        \"classifier__bootstrap\"         : [True, False]\n",
    "      }},\n",
    "      {'RandomForestClassifier2': \n",
    "       { 'classifier__n_estimators'      : [8, 32, 64] ,\n",
    "        \"classifier__criterion\"         : [\"gini\", \"entropy\"],\n",
    "        'classifier__max_features'      : ['auto', 'sqrt', 'log2', None],\n",
    "        \"classifier__max_depth\"         : [1, 10, 20],\n",
    "        \"classifier__min_samples_split\" : [2, 4] ,\n",
    "        \"classifier__bootstrap\"         : [True, False]\n",
    "      }},\n",
    "     {'GradientBoostingClassifier1': \n",
    "      { 'classifier__n_estimators': [16, 32], \n",
    "        'classifier__learning_rate': [0.1, 0.05, 0.02, 0.01],\n",
    "        'classifier__max_depth': [4, 6, 8],\n",
    "        'classifier__min_samples_leaf': [20, 50,100,150],\n",
    "        'classifier__max_features': [1.0, 0.3, 0.1]        \n",
    "      }},\n",
    "     {'GradientBoostingClassifier2': \n",
    "      { 'classifier__n_estimators': [16, 32], \n",
    "        'classifier__learning_rate': [0.1, 0.05, 0.02, 0.01],\n",
    "        'classifier__max_depth': [4, 6, 8],\n",
    "        'classifier__min_samples_leaf': [20, 50,100,150],\n",
    "        'classifier__max_features': [1.0, 0.3, 0.1]        \n",
    "      }},\n",
    "    {'SVC1': [\n",
    "        {'classifier__kernel': ['rbf'], \n",
    "         'classifier__gamma': [1e-3, 1e-4],\n",
    "         'classifier__C': [0.1, 1, 10, 100, 1000]},\n",
    "        {'classifier__kernel': ['linear'], \n",
    "         'classifier__C': [0.1, 1, 10, 100, 1000]}\n",
    "    ]},\n",
    "    {'SVC2': [\n",
    "        {'classifier__kernel': ['rbf'], \n",
    "         'classifier__gamma': [1e-3, 1e-4],\n",
    "         'classifier__C': [0.1, 1, 10, 100, 1000]},\n",
    "        {'classifier__kernel': ['linear'], \n",
    "         'classifier__C': [0.1, 1, 10, 100, 1000]}\n",
    "    ]},\n",
    "#     {'LogisticRegression1': [\n",
    "#         {'classifier__solver': ['newton-cg',  'lbfgs' , 'sag' ],\n",
    "#          'classifier__C': np.logspace(-10, 10, 5),            \n",
    "#          'classifier__fit_intercept': [True, False],\n",
    "#          'classifier__max_iter' : [50, 100, 200],\n",
    "#          'classifier__intercept_scaling' : [0.5, 1.0, 1.5]\n",
    "#         },\n",
    "#         {'classifier__solver': ['liblinear'],\n",
    "#          'classifier__penalty': ['l1', 'l2'],\n",
    "#          'classifier__C': np.logspace(-10, 10, 5),            \n",
    "#          'classifier__fit_intercept': [True, False],\n",
    "#          'classifier__max_iter' : [50, 100, 200],\n",
    "#          'classifier__intercept_scaling' : [0.5, 1.0, 1.5]\n",
    "#         }   \n",
    "#     ]},\n",
    "#     {'LogisticRegression2': [\n",
    "#         {'classifier__solver': ['newton-cg',  'lbfgs' , 'sag' ],\n",
    "#          'classifier__C': np.logspace(-10, 10, 5),            \n",
    "#          'classifier__fit_intercept': [True, False],\n",
    "#          'classifier__max_iter' : [50, 100, 200],\n",
    "#          'classifier__intercept_scaling' : [0.5, 1.0, 1.5]\n",
    "#         },\n",
    "#         {'classifier__solver': ['liblinear'],\n",
    "#          'classifier__penalty': ['l1', 'l2'],\n",
    "#          'classifier__C': np.logspace(-10, 10, 5),            \n",
    "#          'classifier__fit_intercept': [True, False],\n",
    "#          'classifier__max_iter' : [50, 100, 200],\n",
    "#          'classifier__intercept_scaling' : [0.5, 1.0, 1.5]\n",
    "#         }      \n",
    "#    ]}\n",
    "]\n",
    "\n",
    "scoring = 'f1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3/3 [32:35<00:00, 651.72s/it]\n"
     ]
    }
   ],
   "source": [
    "NUM_TRIALS = 3\n",
    "\n",
    "trial_scores_columns = ['name', 'best_score', 'best_parameters', 'pipeline',\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",
    "    model_select_columns = ['trail', 'idx', 'name', 'best_score', 'best_parameters', 'pipeline']\n",
    "    model_select = pd.DataFrame(columns=model_select_columns)\n",
    "    for idx, (pip, params) in enumerate(zip(pipelines, parameters)):\n",
    "        pipeline_name, pipeline = list(pip.items())[0]\n",
    "        _, pipeline_parameters = list(params.items())[0]\n",
    "            \n",
    "        cv = KFold(n_splits=4, shuffle=True, random_state=trial)\n",
    "        gscv = GridSearchCV(estimator=pipeline, param_grid=pipeline_parameters, scoring=scoring, cv=cv, \n",
    "                            verbose=0, n_jobs=-1)\n",
    "        gscv.fit(X_train, y_train)\n",
    "        \n",
    "        model_select = model_select.append(pd.DataFrame([[\n",
    "            trial, idx, pipeline_name, gscv.best_score_, gscv.best_params_ , pickle.dumps(gscv.best_estimator_)\n",
    "        ]], columns=model_select_columns))\n",
    "            \n",
    "    best_trail = model_select.groupby(['name'])['best_score'].agg(['mean', 'std', 'min', 'max']).sort_values('mean', ascending=False).iloc[0]\n",
    "    best_pipeline = model_select[model_select['name'] == best_trail.name].sort_values('best_score', ascending=False).iloc[0]\n",
    "      \n",
    "    pipeline = pickle.loads(best_pipeline['pipeline'])\n",
    "    parameter = best_pipeline['best_parameters']\n",
    "                    \n",
    "    cv = KFold(n_splits=10, shuffle=True, random_state=trial).split(X_train)\n",
    "    scores = cross_validate(pipeline, X_train, y_train, cv=cv, return_train_score=True, \n",
    "                            verbose=0, n_jobs=4)['test_score']\n",
    "    \n",
    "    trial_scores = trial_scores.append(pd.DataFrame([[\n",
    "        best_pipeline['name'], best_pipeline['best_score'], parameter, pickle.dumps(pipeline),\n",
    "        trial, np.mean(scores), np.std(scores), np.min(scores), np.max(scores)\n",
    "    ]], columns=trial_scores_columns))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>name</th>\n",
       "      <th>best_score</th>\n",
       "      <th>best_parameters</th>\n",
       "      <th>pipeline</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>ExtraTreesClassifier1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>{'classifier__bootstrap': True, 'classifier__m...</td>\n",
       "      <td>b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...</td>\n",
       "      <td>1</td>\n",
       "      <td>0.999633</td>\n",
       "      <td>0.000734</td>\n",
       "      <td>0.998165</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ExtraTreesClassifier1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>{'classifier__bootstrap': True, 'classifier__m...</td>\n",
       "      <td>b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...</td>\n",
       "      <td>0</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ExtraTreesClassifier1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>{'classifier__bootstrap': True, 'classifier__m...</td>\n",
       "      <td>b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...</td>\n",
       "      <td>2</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    name  best_score  \\\n",
       "0  ExtraTreesClassifier1         1.0   \n",
       "0  ExtraTreesClassifier1         1.0   \n",
       "0  ExtraTreesClassifier1         1.0   \n",
       "\n",
       "                                     best_parameters  \\\n",
       "0  {'classifier__bootstrap': True, 'classifier__m...   \n",
       "0  {'classifier__bootstrap': True, 'classifier__m...   \n",
       "0  {'classifier__bootstrap': True, 'classifier__m...   \n",
       "\n",
       "                                            pipeline trial  score_mean  \\\n",
       "0  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     1    0.999633   \n",
       "0  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     0    1.000000   \n",
       "0  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     2    1.000000   \n",
       "\n",
       "   score_std  score_min  score_max  \n",
       "0   0.000734   0.998165        1.0  \n",
       "0   0.000000   1.000000        1.0  \n",
       "0   0.000000   1.000000        1.0  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trial_scores.sort_values(\"score_mean\", ascending=True).head(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name                                                ExtraTreesClassifier1\n",
       "best_score                                                              1\n",
       "best_parameters         {'classifier__bootstrap': True, 'classifier__m...\n",
       "pipeline                b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...\n",
       "trial                                                                   0\n",
       "score_mean                                                              1\n",
       "score_std                                                               0\n",
       "score_min                                                               1\n",
       "score_max                                                               1\n",
       "best_parameters_hash                                 -7413783029806246948\n",
       "Name: 0, dtype: object"
      ]
     },
     "execution_count": 9,
     "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(['name', 'best_parameters_hash'])['score_mean'].agg(['count']).sort_values('count', ascending=False).iloc[0]\n",
    "df_tmp = trial_scores[(trial_scores['name'].str.contains(trial_selected.name[0]))]\n",
    "trial_clf = df_tmp[(df_tmp['best_parameters_hash'] == trial_selected.name[1])].iloc[0]\n",
    "trial_clf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "StandardScaler(copy=True, with_mean=True, with_std=True)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "SMOTE(k=None, k_neighbors=5, kind='regular', m=None, m_neighbors=10, n_jobs=1,\n",
       "   out_step=0.5, random_state=0, ratio='auto', svm_estimator=None)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "ExtraTreesClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "           max_depth=10, max_features='auto', max_leaf_nodes=None,\n",
       "           min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "           min_samples_leaf=1, min_samples_split=2,\n",
       "           min_weight_fraction_leaf=0.0, n_estimators=8, n_jobs=1,\n",
       "           oob_score=False, random_state=None, verbose=0, warm_start=False)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "{'classifier__bootstrap': True,\n",
       " 'classifier__max_depth': 10,\n",
       " 'classifier__max_features': 'auto',\n",
       " 'classifier__min_samples_split': 2,\n",
       " 'classifier__n_estimators': 8}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipeline = pickle.loads(trial_clf['pipeline'])\n",
    "params = trial_clf['best_parameters']\n",
    "\n",
    "for pip_name in pipeline.named_steps:\n",
    "    display(pipeline.named_steps[pip_name])\n",
    "    \n",
    "params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1aa29a6748>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "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, \n",
    "                    cv=cv, scoring=scoring, shuffle=True, random_state=HP.SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1aa3852e48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.learning_curve import validation_curve\n",
    "# param_name = 'classifier__C'\n",
    "# param_range = [ 0.5, 1.0, 1.5]\n",
    "param_name = 'classifier__max_depth'\n",
    "param_range = [ 5, 10, 15]\n",
    "train_scores, test_scores = validation_curve(\n",
    "                estimator=pipeline,\n",
    "                 X=X_train,\n",
    "                 y=y_train,\n",
    "                 param_name=param_name,\n",
    "                 scoring='accuracy',\n",
    "                 param_range=param_range,\n",
    "                 cv=10)\n",
    "\n",
    "train_mean = np.mean(train_scores, axis=1)\n",
    "train_std = np.std(train_scores, axis=1)\n",
    "test_mean = np.mean(test_scores, axis=1)\n",
    "test_std = np.std(test_scores, axis=1)\n",
    "\n",
    "\n",
    "plt.plot(param_range, train_mean,\n",
    "          color='blue', marker='o',\n",
    "          markersize=5,\n",
    "          label='training accuracy')\n",
    "plt.fill_between(param_range, train_mean + train_std,\n",
    "                  train_mean - train_std, alpha=0.15,\n",
    "                  color='blue')\n",
    "plt.plot(param_range, test_mean,\n",
    "          color='green', linestyle='--',\n",
    "          marker='s', markersize=5,\n",
    "          label='validation accuracy')\n",
    "plt.fill_between(param_range,\n",
    "                  test_mean + test_std,\n",
    "                  test_mean - test_std,\n",
    "                  alpha=0.15, color='green')\n",
    "plt.grid()\n",
    "#plt.xscale('log')\n",
    "plt.legend(loc='lower right')\n",
    "plt.xlabel('Parameter C')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.ylim([0.8, 1.0])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trainings score: 0.9997888454406205 0.0003777788190471257\n",
      "Validation score: 0.9998087954110899 0.0005736137667303965\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x109c4f940>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Cross-validate to train best model \n",
    "cv = KFold(n_splits=10, shuffle=True, random_state=HP.SEED).split(X_train)\n",
    "scores = cross_validate(pipeline, X_train, y_train, cv=cv, scoring=scoring, return_train_score=True, \n",
    "                        verbose=0, n_jobs=-1)\n",
    "\n",
    "print(\"Trainings score:\", np.mean(scores['train_score']), np.std(scores['train_score']))\n",
    "print(\"Validation score:\", np.mean(scores['test_score']), np.std(scores['test_score']))\n",
    "plot_cross_validation_scores(scores, figsize=(12, 8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion Matrix\n",
      " [[1404    2]\n",
      " [   0 1275]]\n",
      "Accuracy  0.9992540096978739\n",
      "Recall    1.0\n",
      "Precision 0.9984338292873923\n",
      "F1        0.9992163009404388\n",
      "ROC AUC   0.9992887624466572\n"
     ]
    }
   ],
   "source": [
    "# http://www.ritchieng.com/machine-learning-evaluate-classification-model/\n",
    "# https://github.com/justmarkham/DAT8/blob/master/other/model_evaluation_comparison.md\\\n",
    "# Accuracy of a model that simply counts, i.e. looks at the prior distribution\n",
    "\n",
    "y_pred = pipeline.predict(X_test)\n",
    "try:\n",
    "    y_prob = pipeline.predict_proba(X_test)\n",
    "except:\n",
    "    pass\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": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy score: 0.9985074626865673 0.0024750931271308924\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', verbose=0, n_jobs=-1)\n",
    "\n",
    "print(\"Test accuracy score:\", np.mean(scores), np.std(scores))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZMAAAEWCAYAAACjYXoKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzsnXl8W8XV979H8h6viRNnT4CyNDshhFA2Q0uAQIEEnjdAKEsLeWgJbWlZwvKypA2kvDzslKUlQGkKtGEpD4Sym6UsIbShkASaEApkcXbvlmRJ8/4x99qyLO+WJcvn+/lcS5p7dTV3LM3vnnNmzogxBkVRFEXpDp5EV0BRFEXp+6iYKIqiKN1GxURRFEXpNiomiqIoSrdRMVEURVG6jYqJoiiK0m1UTBSlBxCRF0Xk3ETXQ1EShYqJ0qcRkf+IyPcSXQ9jzAnGmEfjcW4RyReRO0TkaxGpEZENzuvieHyeonQFFRNFaQcRSUvgZ2cArwHjgeOBfOA7wC5gehfOl7BrUVIbFRMlZRGRk0RktYhUiMi7IjIpYt9CEflCRKpFZK2IzI7Yd56I/F1EbheR3cANTtk7InKriOwRkS9F5ISI95SJyAUR72/r2L1E5C3ns18VkXtF5I+tXMY5wGhgtjFmrTEmbIzZboz5lTFmhXM+IyLfijj/IyLya+d5qYhsEpErRaQceFhE1onISRHHp4nIThGZ6rye4bRXhYh8LCKlUW2z0an7lyIyr2v/HSXVUDFRUhKnY1wK/DcwCHgAeE5EMp1DvgCOAAqAG4E/isiwiFMcAmwEhgCLI8o+B4qBW4CHRERaqUJbx/4JWOnU6wbgB21cyveAvxljatq/6lYZCgwExgDzgceBMyP2HwfsNMb8Q0RGAC8Av3becxnwlIgMFpEBwF3ACcaYPKyFtLob9VJSCBUTJVW5EHjAGPOBMSbkxDP8wAwAY8xfjDFbnDv9J4H1NHcbbTHG3G2MCRpj6p2yr4wxvzPGhIBHgWFASSufH/NYERkNHAxcZ4wJGGPeAZ5r4zoGAVu71AJNhIHrjTF+51r+BJwsIjnO/rOcMoCzgRXGmBVO27wCrAJmRZxrgohkG2O2GmPWdLNuSoqgYqKkKmOAXzqumgoRqQBGAcMBROScCBdYBTABa0W4fBPjnOXuE2NMnfM0t5XPb+3Y4cDuiLLWPstlF1aIusMOY4wvoj4bgHXA9x1BOZkmMRkD/FdUux0ODDPG1AJzgYuArSLygogc0M26KSmCiomSqnwDLDbGFEZsOcaYx0VkDPA7YAEwyBhTCHwKRLqs4pVOeyswMMIqACtyrfEqcJzjYmqNOiDyfEOj9se6FtfVdQqw1hEYsO32WFS7DTDGLAEwxrxkjDkWK3CfYdtRUVRMlJQgXUSyIrY0bCd3kYgcIpYBInKiiOQBA7Ad7A4AETkfa5nEHWPMV1i30Q0ikiEihwLfb+Mtj2E7+KdE5AAR8YjIIBG5WkRc19Nq4CwR8YrI8cBRHajKE8BM4Mc0WSUAf8RaLMc558tygvgjRaRERE52hM0P1AChzly/krqomCipwAqgPmK7wRizChs3uQfYA2wAzgMwxqwF/gd4D9gGTAT+3ov1nQccinVh/Rp4Ets5t8AY48cG4T8DXgGqsMH7YuAD57CfYQWpwjn3s+1VwBizFXv933E+3y3/BmutXI0V22+Ay7F9hQf4JbAF2I0VrZ909KKV1EZ0cSxFSSwi8iTwmTHm+kTXRVG6ilomitLLiMjBIrKP47I6HmsJtGtNKEoyo7NhFaX3GQo8jR32uwn4sTHmn4mtkqJ0D3VzKYqiKN1G3VyKoihKt+kXbq7i4mIzduzYRFej29TW1jJgQFvTDfof2iYt0TZpibZJSzrSJh999NFOY8zgjpyvX4jJ2LFjWbVqVaKr0W3KysooLS1NdDWSCm2TlmibtETbpCUdaRMR+aqj51M3l6IoitJtVEwURVGUbqNioiiKonSbfhEzUZRUpaGhgU2bNuHzNSYFpqCggHXr1iWwVsmHtklLItskKyuLkSNHkp6e3uXzxU1MRGQpcBKw3RjTIomes1DQndh1EuqA84wx/3D2nQtc6xz6a3dtbRFZjF15rsgY01rqb0XpN2zatIm8vDzGjh2Lu/ZWdXU1eXl5Ca5ZcqFt0hK3TYwx7Nq1i02bNrHXXnt1+XzxdHM9gl2zujVOAPZ1tvnAfQAiMhC4HrtS3XTgehEpct7zv3Rh3WtFSVV8Ph+DBg1qFBJF6SwiwqBBg5pZt10hbmJijHkLm1m0NU4B/mAs7wOFzrKpxwGvGGN2G2P2YDOlHu+c830n26miKA4qJEp36YnvUCJjJiNovsLcJqestfJOISLzsRYPJSUllJWVdbmiyUJNTU1KXEdP0t/bpKCggOrq6mZloVCoRVl/R9ukJdFt4vP5uvVbSqSYxJJC00Z5pzDGPAg8CDBt2jSTChOWkn7iVSgEe/ZARgZkZdnHOJP0bRJn1q1b1yIW0JvxgV27dvHd734XgPLycrxeL4MH2wnTK1euJKMD34Hzzz+fhQsXsv/++7d6zL333kthYSHz5s3rUj01ZtKS6DbJysriwAMP7PL5Eikmm2i+XOlI7KI7m4DSqPKyXquV0jV8PtiyxQqKMXZLT4eCAhgwADIzQd0xCWfZMrjmGvj6axg9GhYvhi72zwAMGjSI1atXA3DDDTeQm5vLZZdd1uwYYwzGGDye2F71hx9+uN3Pufjii7teyTjS3rX1JxLZAs8B5zhLqs4AKp14yEvATBEpcgLvM50yJRkxBior4auvwOOxwpGbC3l5Vkz27LH7NmyA8nKorbWCo/Q6y5bB/Pn232GMfZw/35b3NBs2bGDChAlcdNFFTJ06la1btzJ//nymTZvG+PHjWbRoUeOxhx9+OKtXryYYDFJYWMjChQuZPHkyhx56KNu3bwfg2muv5Y477mg8fuHChUyfPp3999+fd999F7C5pk477TQmT57MmWeeybRp0xqFLpLLL7+ccePGMWnSJK688krAWlWnnHIKkyZNYvLkyXzwgV3E8pZbbmHChAlMmDCBu+++u9Vre/HFFzn00EOZOnUqc+fOpba2tucbNcmJ59Dgx7EWRrGIbMKO0EoHMMbcj11qdRZ2OdU64Hxn324R+RXwoXOqRcaY3c45bwHOAnKcc/7eGHNDvK5BaYdQCLZvh6oqKyLRd2deL+Tk2OfGQF2dPdYYyM62Vkt2dq+4w/oDP/85rF4NoVA2Xm/L/e+/D/6oxYHr6uBHP4Lf/S72OadMAacP7zRr167l4Ycf5v777wdgyZIlDBw4kGAwyNFHH83pp5/OuHHjmr2nsrKSo446iiVLlvCLX/yCpUuXsnDhwhbnNsawcuVKnnvuORYtWsTf/vY37r77boYOHcpTTz3Fxx9/zNSpU1u8b9u2baxYsYI1a9YgIlRUVADW8jn22GNZsGABwWCQuro6Vq5cybJly1i5ciWhUIjp06dz1FFHkZOT0+zatm/fzpIlS3jttdfIyclh8eLF3HnnnVx99dVda7g+StzExBhzZjv7DRDTdjXGLAWWxii/AriiRyqodA/XrRUOWyukPURsHMUlELBCFA5bCyY/v8kdpi6DuBAtJO2Vd5d99tmHgw8+uPH1448/zkMPPUQwGGTLli2sXbu2hZhkZ2dzwgknAHDQQQfx9ttvxzz3nDlzGo/5z3/+A8A777zTaGlMnjyZ8ePHt3jfwIED8Xg8XHjhhZx44omcdNJJgI29PfHEEwCkpaWRn5/P22+/zWmnnUaOc0N06qmn8s477zBz5sxm1/buu++ydu1avvOd7wAQCAQ4/PDDO99gfRydAa90DmOsdVFebjv+SIHoDBkZTRZJKAQVFbDbGUmel2e3rCxI069oR3EtiOrq+pjB5rFjrWsrmjFjIB4D4iLTm69fv54777yTlStXUlhYyNlnnx1zXkNkwN7r9RIMBmOeOzMzs8UxHVnoLz09nVWrVvHKK6/wxBNPcN999/Hyyy8DLYfHtnW+yGszxnD88cfz2GOPtfv5qYzeAiodJxSyIrJ1q7Uieso95brDcnPteevrYfNm2LjR9n6Vlfb2WVcF7RaLFzd5HV1ycmx5vKmqqiIvL4/8/Hy2bt3KSy/1fBj08MMP589//jMAn3zyCWvXrm1xTHV1NVVVVZx00kncfvvt/POfdrXko48+utEdFwqFqKqq4sgjj+SZZ56hvr6empoa/vrXv3LEEUe0OOd3vvMd3nzzTTZu3AjY2M369et7/PqSHb3tUzqG3287+HDYuqTihesOcy2ehgZ1h/UQ7qitnhzN1VGmTp3KuHHjmDBhAnvvvTeHHXZYj3/GJZdcwjnnnMOkSZOYOnUqEyZMoKCgoNkxlZWVzJkzB7/fTzgc5rbbbgPgnnvu4cILL+SBBx4gLS2NBx54gOnTp3PmmWc2urN+/OMfM3HiRDZs2NDsnCUlJTz00EPMnTuXQCAAwE033cS+++7b49eYzPSLNeCnTZtmdHGsblBZ2eTWSmSwPBy2ohYMWtHJzaXss88oPfLIfusOW7duHd/+9reblfXXORXBYJBgMEhWVhbr169n5syZrF+/nrS0tH7bJm0R3Saxvksi8pExZlpHztc/f4FKx3BHa1VWWhdUoi0Bj8eO/gLr8vL7reXyxRdW6AoKrN8mI0PntPRDampq+O53v0swGMQY02hlKL2DtrQSG9etFQrF163VVUSaXF15eVZUdu601ktami3LzbXuskSLoNIrFBYW8tFHHyW6Gv0WFROlJVVVNsjendFavU16ut3ACkp1tR0hBjbGkpdnrZpurNegKErrqJgoTYRCsGOH7YSTwa3VVaLdYYGAjfmAdYG5kyU1xYui9BgqJool2d1aXcV1hznzEggGm9xhXq+91txcuz/WtHFFUTqEionS5NbKyLAuoVQmLa1p5JfrDtuzx4pOTo4VF3WHKUqn6aN+DKVHCIVg2zabFsWdu9GfcN1hbrA+GLTusI0b4csv7Yx8n08nS7ZDeXk5Z5xxBvvssw/jxo1j1qxZ/Pvf/050tWIyduxYdu7cCdCY/iSa8847j+XLl7d5nkceeYQtW7Y0vr7gggtiTpLsT6iY9Ff8fjtzrarK3o331fhIT5KR0ZTx2Ou1YvL116mV8XjZMptXxeOxj91MGWyMYfbs2ZSWlvLFF1+wdu1abrrpJrZt29bsuFAStpubbbgrRIvJ73//+xZ5xpKB1tLRxAPtQfojVVVNSZpS3a3VVdLSmlK8ZGdbIdm82c5p+eYbO/fGme3cZ4hDDvo33niD9PR0LrroosayKVOmcMQRR1BWVsbRRx/NWWedxcSJEwG47bbbGlO6uynla2trOfHEE5k8eTITJkzgySefBGDhwoWNqeKj10gBuO+++7jiiqa8r4888giXXHIJYJMyHnTQQYwfP54HH3wwZt1zc3MBK4gLFixg3LhxnHjiiY1p7wEWLVrEwQcfzIQJE5g/fz7GGJYvX86qVauYN28eU6ZMob6+ntLSUtyJ0Y8//jgTJ05kwoQJjYkn3c+75pprmDx5MjNmzGghuABvvvkmU6ZMYcqUKRx44IGNKyHecsstTJw4kcmTJzdmUV69ejUzZsxg0qRJzJ49mz179gBQWlrK1VdfzVFHHcWdd97Jjh07OO200zj44IM5+OCD+fvf/976P7QbaMykPxEO29Fae/ZYEdGAc8eIHB0GVkTcjiAtLXkWAHNy0GeHQrH/t3HIQf/pp59y0EEHtbp/5cqVfPrpp+y111589NFHPPzww3zwwQcYYzjkkEM46qij2LhxI8OHD+eFF14AbMqT3bt388wzz/DZZ581SxUfyemnn86hhx7KLbfcAsCTTz7JNddcA8DSpUsZOHAg9fX1HHzwwcycObPVGfDPPPMMn3/+OZ988gnbtm1j3Lhx/PCHPwRgwYIFXHfddQD84Ac/4Pnnn+f000/nnnvu4dZbb2XatOaTw7ds2cKVV17JRx99RFFRETNnzuTZZ5/l1FNPpba2lhkzZrB48WKuuOIKfve733Httdc2e/+tt97Kvffey2GHHUZNTQ1ZWVm8+OKLPPvss3zwwQfk5OSw20mIes4553D33Xdz1FFHcd1113HjjTc2CnRFRQVvvvkmAGeddRaXXnophx9+OF9//TXHHXcc69ata/V/1lXUMukvRLu1VEi6jusOy83tWwuA9XYOemD69OnstddegE0RP3v2bAYMGEBubi5z5szh7bffZuLEibz66qtceeWVvP322xQUFJCfn09WVhYXXHABTz/9dGMa+EgGDx7M3nvvzfvvv8+uXbv4/PPPG3N+3XXXXY0WwDfffMMXX3zRah3feustzjzzTLxeL8OHD+eYY45p3PfGG29wyCGHMHHiRF5//XXWrFnT5vV++OGHlJaWMnjwYNLS0pg3bx5vvfUWYDMiuynvI1PnR3LYYYfxi1/8grvuuouKigrS0tJ49dVXOf/88xvbYODAgVRWVlJRUcFRRx0FwLnnntv4OQBz585tfP7qq6+yYMECpkyZwsknn0xVVVWztd97CrVM+gP9abRWbxNrAbDKSvu6txcAc+5K61vLQxWHHPTjx49vM1gdnao9Fvvttx8fffQRK1as4KqrrmLmzJlcd911rFy5ktdee40nnniCe+65h1deeaXRCjr55JNZtGgRc+fO5c9//jMHHHAAs2fPRkQoKyvj1Vdf5b333iMnJ4fS0lL87QhmdPp5AJ/Px09+8hNWrVrFqFGjuOGGG2KmzY+krVyH6enpjZ/TWnr9hQsXcuKJJ7JixQpmzJjBq6++ijEmZv3aIrLdw+Ew7733HtmR1jX0uKCoZdIOlZW2L66rs96NcDjRNeoE4bB1x2zebDu8/jZaq7dxMx6767EYY3ObffmlHSG2c6dNr5+oL1EcctAfc8wx+P1+fhfhJvvwww8bXSyRHHnkkTz77LPU1dVRW1vLM888wxFHHMGWLVvIycnh7LPP5rLLLuMf//gHNTU1VFZWMmvWLO644w5Wr16N1+tl9erVrF69unHZ3zlz5vDss8/y+OOPN96NV1ZWUlRURE5ODp999hnvv/9+m9dw5JFH8sQTTxAKhdi6dStvvPEGQKNwFBcXU1NT00w08/LyYnbGhxxyCG+++SY7d+4kFArx+OOPN1oPHeGLL75g4sSJXHnllUybNo3PPvuMmTNnsnTpUurq6gDYvXs3BQUFFBUVNS4e9thjj7X6OTNnzuSee+5pfB1rKeOeQC2Tdtixo8lj4d4ceDxNmUYyMqynIy3N3qQmjffI77fWSEODvTtWep/IFC+hkL0zibUAWHdG0hkTe+hyrLKzzrKPV19tBxGMGgU33WTLuzj8WYBnnn6an196KUuWLCErK4uxY8dyx+23s3nz5mZ1mXrggZx37rlMnz4dgAt+9CMOnDKFl156icuvuAKPx0N6ejr3/fa3VFdVccqpp+Lz+TDGcPtttzXVMeIuvaioiHHjxrF27drG8x5//PHcf//9TJo0if33358ZM2a0eQ2zZ8/m9ddfZ+LEiey3336NnXJhYSEXXnghEydOZOzYsc1WjTzvvPO46KKLyM7O5r333mssHzZsGDfffDNHH300xhhmzZrFKaec0uH2vOOOO3jjjTfwer2MGzeOE044gczMTFavXs20adPIyMhg1qxZ3HTTTTz66KNcdNFF1NXVsffee/Pwww/HPOddd93FxRdfzKRJkwgGgxx55JGNa7f0JJqCvh02bLBeikgrMxy2fUMw2NI17gqNu6WnW4FxxaY7dDgFfaRbK8WtkbI1ayiNsTxrUuNmPA4G7fNuBO3X+Xx8e7/9mpVV+/3kpfj/HY/HbiLNt1bQFPQt0RT0SYD7PY41SdoVmupqeyPqarUxVkzc/t1dkdbdesSi0dFafQPXHdYTBAItLRuR1J83ZIwV40jc644WGaVXUDHpYdoSGvf7X1NjjQfXQ+H+BtLTmxYZ7LTQBAJ2JnsgkFq5tRQlFrGEwhh7JxfpLnCPc/epyMQNFZNeRKS5Gz0SV2hqa63QhMNN33cRa9EEgzahb2SMJi0NawZt2dI0ZFXpV3RltE9fxXXKx7za1kTCvWtraGh+rFoxjfREuEPFJEloT2hCoSYvVqPrLBQmrWIHWXV7SC8cQEa2l4yQ/X24YtOPfx/9giyvl1179jCoqCglBMU4fwxNGhC9QctQiYgjMNGPkQdHuv7asmJckYksS2GMMezatYusbrpeVUz6ACJWHEQipokEAni2bYGGAKG8POoDQk198xiN6zpz4zQZGSo0qcbI3Fw27dnDDid5IYAvECCrN+a1dJHGm2ATWzwikcY/zZ83vjf6nJHvjbDsG0IBMtIyWj9f5ElaVCJGkD8Ffjw+n69RQLKyshg5cmS3zqdi0geRmmo827Zi0tIgNxcv4I3xnzTGWjM+n50nEw43xWhcgWpt1FkK/Fb6BeleL3tFDf0uW7OGAxM4ws0dhOJuDQ128FpDg93caTbud9EdUu/xtBIf7KIHJhxqqsvnu9ewT/74FqOL3bhk9BB/ty5ej0GCDc2tGGPsG3JyWs4P6EOUlZVx4IEH9tj5+tbVK8jO7XgqdmOy2x+tFflDjcYVGr+/SWgi3+cKTUaG3dzzuBaS0n+J9BCFw00i4fPZuF7kICt3FKNrEWdl9d73x/VWpaWBR2InfwiH7eb+BtwbLnDrKaSlZbQUnIYQnj21eMOVVnAEe6FZWU0ThN2DU31knYOKSV8hEEACATyVFZgBed3+RbYlNGA7ilhCA02uM9d9pkKTeoTDTfOoQiE7SNC1MNzpMZG434H09L41tSlScFojtuB4AW9zC8dryPA0kM5u0jwhPF6x7ZKdgXdANpLjpNWJXKAthUi9K0pBXLcWgBnQO6O12hOaQKB5ZhDXZeH+TiJjM+5zN7YZHefsD9Mikg3XuggGm6yLQKBpi76BaHT7OILRn24aOi44Ql1DBuFwRnMLJxREQjWkSRVpacYOtMnwkJaXjSc3x4pNVjrerHTE03cbVsUkmQmHkT278OzZZd1a1cnxRWtPaNxhzoFAU1C1I+moIjusjooR2HOrGLUkMm7h3gBExi4iibRUMzO1PTtL24KTBqQ1WTghCNeHCVc1QMMuxFjlEY/gyckkLTeb9Pxs0nPSSctOx5vhbfzfJHM8M65iIiJLgZOA7caYCTH2C3AnMAuoA84zxvzD2Xcu4Cb7/7Ux5lGn/CDgESAbWAH8zKRiTphAAM/2rUgg0CNurd6iO5Pu3bu51sQoMvOI+9zvt3kU3c92BSmWGEVPKUikZbTs6WyuWZLH11u8jB4eYvHCaubNqe/UOWIFul131JdfNs3Riw50u5kYlN6lmeBkeoAMZ2siHAgSrq7Gt7uCupDBGCHsScNkZmGysiEzE29WOunZaWRkSqPXLPJ/6/WC/GkZXHONXXZi9GibzHPevLheX7wtk0eAe4A/tLL/BGBfZzsEuA84REQGAtcD07BjOT4SkeeMMXucY+YD72PF5HjgxTheQ68TOVrL5PSflPFd6dC91U2B1UgxcjvWSCFqjUgXndvpuuIT+QONtoqiBamjLHs6m/lXFFBXby/4q81pzL/CjsiKFBS37pGuqMiRUZGpvSID3dC7gW6l5/BkpOHJiOqWw2EI+pFALfjDhCuEkBF8aZnUpmcTysjGpKVjvFZV8p9fRvFV80lvsFmG+eorgj+cbzv7OApKXMXEGPOWiIxt45BTgD84lsX7IlIoIsOAUuAVY8xuABF5BTheRMqAfGPMe075H4BTSRUxiXZr9aHcWk+/mM3N9+SxeZuXESUhrlpQzZwTOnen3V26a124ohMMQnWN4PODzy/U+wSfXwgEnMcG8DvP/QFn80MwZI8JNAiBoPscAg3uMfbx76syCASa9/R19R7mX1HAm++lkzfAkDsgTG5OmLwBhoK8MAV5YfLzwgwsNOQOMG0GugUVkpTC44GMTEyG/YcLkGYMaTXVeLduxLtzG549u/Ds3oGnYg8Zj/2+SUgc0gJ11PzsGnL7qph0gBHANxGvNzllbZVvilHeAhGZj7VgKCkpoayLi//4/b3kAjHOePawM9uwpuUh9UEfn5a3vdJbInjtjaHcfvc4/H4rfpvK0/jFr/L5pmIT3z26vNPnC4chEPAQaPAQCHhpaHzuaVYeCHio9Q3ib6E9EeXOeyKO90eXNTuXc/6I8lCoe/9wj8eQkREiIyNMRnqY9IwwGekh53mIQCC2j6muXvjTXzOprY2RBiGCtLQwubkN5A4IkpvbQF6ufczNDZKX20BmznCK8vY0vs7NbSAvzx6Tkx3ql0KTrL+daDyBALKjgnB5FbK9Eu/OStJ27SF9TwXZlbvIqd5Nbu0u8up3kROM0UnQ+rScnF1fN+sHa2pqutwvxiLRYhLra226UN6y0JgHgQfBpqDvUOr2GMRKQd/TSG0NnvItdhJiZuspDT4tX8OEoYlPtx4OQ1WNUFHpoaLKw+8fGtgoJC5+v5e7fzueTRv3brwj9wdoupuPuKt3LQC3vCHY3WHPhqxMQ1YmZGYYu2Xax6xMKMwxZBZGloXIzAhFHWfIzKCxLKtxH02vMwzp6YbMdNM0NNR5Hj26zR1GnZYGBxyVxzdbWv70Rg4L8c5TO/D7oaZOqK3zUFvvoapGqKzyUFHtobLKQ2W1UOk8r6jKorLaw5fbPLasWgiHW28/j8dQkOdYO/nW4inMN82e5+eFKXT355vG5/m5ps8G5nvjtxNogOoaD9U1QnWtUF3roaZWqKkIYrbvRHbuwLNnBxkVO8iq2sGA2m3k1u2gwLeNoobtFIfKKTCVMc+9h0LKGco3lFDOvuyQIezJHEp19mBqckqoyxuMP28w4YIibnltKmP5usU5vmZ0syUsOrykRQdJtJhsAkZFvB4JbHHKS6PKy5zykTGO75sk2K0VCkFltVBR5aGi0sMe57GiysOeSg8VlWLLmpXbjqytDsultk54+c2sZh2028EXFYZtWYaxs/AjO/JWy6I680zD11XrmTD8W07nb8vSe3C+izsCxw1yR8ZejLHi4M67cR+jR6VFc/NV1c1iJgA52WGWXF3NmDEtbpxOAAAgAElEQVRuvMdQWxuitjbUGEh3c7e1dW3GwMovP2N49ngqq5pEqKo6SpCqpPH55vImcWpLyEWMdbt1RITyDIX5Tc8L8sLdmloRTzeqKwI1tUJVTZMINAmDh+paoabWCntNrVBXHSa9cgfZNVYU8ut3MCi0jRK2MZRyStjGAc7jIHbH/NxqTz6700uozBxCef54NuaW4ssfQqBgMMGBQzDFxXiGDCFtyEByijLIGxBmUK5hzIAwWZnO9yAcRvw+O90/3UO4MI3Fh97EbyrmM4AmV1ctOdw2aDF39UiLxSbRYvIcsEBEnsAG4CuNMVtF5CXgJhEpco6bCVxljNktItUiMgP4ADgHuDshNe8uDQ14tm1B/P5uj9YKBqGi2un8KyOEIUIEIoVhT4V9rKxu+zbTdhJhCgvs45gRQQoLTLOyovwwv/x1ITt2tRTCkUNDfPjC9i5fV0cIl9cxcmio/QNbe3+EWLiPkSPGXLHIyWnqzKOD8p3FDbK3NprL/ZwBA5oGE/j9NqN0XV2ToLkCFokIDMgJMWpoiFHDOlcvY6DeJ1Q4IlRZ42kmSJEiVFXtoaJKWP9lmmMtefD52/4OD8iJLUJuPKgwhggV5od5/d1MrlpSQL3PNvam8jQu+3UBwSB893C/7fhrhaqaJhGocV67IvDNzvF4Q0VWIJyyaudYvxO/8hCimJ0MZXMzURhKOeNkGyM85QyVcoaYbRSGduGJ4RTxp+dSnzcYf/4QGgr3pmbQDGoHF+MpGUz6sGK8QwdjBg0mNLAYsrLJBIY4W9tEjOU2BgJ+6xYXD+GCIkxuHmRmYgx86/p5/ORyuDF4DaP5mq8ZzY3pi/nenX14NJeIPI61MIpFZBN2hFY6gDHmfuxorFnABuzQ4POdfbtF5FfAh86pFrnBeODHNA0NfpE+GHyX2ho7WsvrbTYJMdBAlIUgzYRh49YDkIaiRgvBFYvq2tZ7NBFDYb6hyOn8BxaG2Xt0kKL8cDNhKMoP22MKmn7UHTWUbri0ist+3fRjB8jOCnPVgpZrZPc20ak/IsUCnNhmRs+KRUeYxzLmsQRrWA8HFgJzWhznLj+QkdG0rLzfb0eqVVdbgYlceK07xq0I5GQbcrINw0s6v069z48VmerYImTFyX6vK6s9fLUpjX85rrnaurYb+kyWcRNNnePVvsX87Ib2O8c0T4ixA3YyImMLY7L+xYi0coZLOUO82xiSu42BWdso9G8nr347OfU78ZiW1x3OzCJcPITwwGLCg0YRHnQgdYOGEBpYTHjQEMKD3MfBmOycps+meQdrgGD0yTtDg82CAXbycnjIUBq8WTSEPIQagAb7P/yv/4Lc3HkcuWgemzb12shgXba3NZZFDNMePhwWLoQ5LX/rMfH57Loj0due3WEqyn1UbvezpzaTimpvM2Fo6wfl9RrychsYVCgUxbAOigrtXV6hKwrO/t7ycydqNNcn5Wv4dvH4RrGIno/iioV7F99bYtEmTz8NV1xhUwi4ZGfDLbd0/Evm4OZX8/nsomuBAGyoXMP+A8c3XmtfoKGBFpaQ65r7eMkL/I7mbps6srme65k8dxzFQRtzKPCVk1u/gwE128iq3kH6nh14K3Yi0WtrAyYjk/CgwYQGDiZcPJjwwMFWLIpbioTJGZC44XGhkOPGChPOysafVUhDxgCMx/5j09PtEkbZ2U3f8Y5WtSMxk84s26tiEoNly2D+fOtScMnIgB/8APbfP4ZI7Gn+6PO1fu40r3E6fkcICiIEwLEQrEiYptf5YfJyDWu2JUcAvjeJnmsRLRZfVK1h3ODxjXn10tNbTlhMOqZPh82bW5Z7vTBqVMvyTmAM1AcCZKZltMg60GdHcW3aRFoH7ulNWnqjAEQLwn+8PkbsM9WxLoZYt1CyNogx4PMRDgRpIJ2G3CLC2QOQzAxycqx4RCZg7So9LSaJjpkkJddc01xIwN7xPfRQ0+uMDCgqgsJCu40ZA5MnN72O3Iqy6hkULKewwJBTlJW03+FEEEssInHXZIm884oUi2/WQTeXYegdjIE1a+Avf4ktJGB9cFOndutjBKiuqCCnsBAvTW3qZvN17x0j139KdrI2/SdmuQH23P9nQo4LyuQXtioQ28vXMCSJb8SMgYZaP+H6AEY8hHILSBuWz4CBmWTnSKetjkSgYhKDr1uOqgPsP3LlSisiHZphHA4je3bj2bMTk5WTkplC26M1sXCtC1cssrKasna7o6FSInt3eTk88wwsXw6ffdZ0sbHM1xEj4O7ujydZt2YNJc56Jh5nS6N5ML+qxnrZ2grmJwvp//yAtPKWAhwaOoLAwYcloEbdx01/E/I3IAE/HoHMohxyvjWEjIJsMrI8fcZF6dL/ercOMHo0fPVVy/Lhw+3WIRoa8Gzbivh9fSq3VldxO6ro9OQpLxaxqK+Hv/3NWiFvv20VdOpUuOkm+P73oawsdsxk4cK4Vqu1YL7fb+MtPRnM70lqFiwk/9dX4PE1tVc4K5uaBfFtr54i+rdhQmEyw/XkZYfJGpJJ+pAS0gsHIOl9uzvu27WPE4sXt4yZdOa3LnW1dhKix9NrKeMTgXt3FQxaUcjKslZbdOK5fkE4DO+/by2Q55+3PfPIkXDJJXDaabDPPk3HukH2JUtgy5bOj/DoIUTs/ywrCwoKWgbzfb7mw6MT9b/0nWDbJfeeJXi3bSFUMpyaBQsby5ONRqvDifuLQHaWoTDLR7oEychOwztooA1+9KXFX9pBxSQG7hC6To/mMgbZvStl3VruHVZDg32eng75+VZo+23a8g0b4Kmn7LZ5s+0gvv99OP10OOSQ1htlzpxeF4/28Hjs/zI7294UBIP2f11XZ8Wlvr5pVr9rYfYWvhPmJKV4tLA6TJPll5UF6SZAethv1ynJz7eqnaJZOFOrt+tB5s2zW4fTqTQ04NlejvjqU8qt5a6D4cY6cnKaYkbJ6mOPO7t3w3PPWSvkn/+0veqRR8LVV8Nxx9kvTArgpoLJzoZBg5oyMdfW2q0zM/NThZhWR7bViMYRViZoTbxw2O4cOMI+priZrmLSA6SSWyvS+gDbmRQU9HPrA2wv+vrrVkBefdU20AEHwP/9v3DqqTB0aKJrGHdam5lfExHMjxSXvk67VkekiIbD1i9YF7KFxcXWSk2FhuggKibdIUXcWq71EQpZscjJsXeiyTzCp1cwBlavtgLy17/aiUTFxXDeedaNNX58/7gdj0FrwXyfr8lyScZgfltEWh3GNLn9mlkdkdfhXnRDgz24qKgpDtIPvxd9s/dLBhrdWnV9zq1ljBUP944rI8POh3HncvRb68Nl82YbA1m+HL74wnYOxx1nBeSoo/rsTUM8iQzmFxY2BfPr662wJEsw36VTVkc0rklmjH3D0KH2Tf38h6O/ii4g9XV4tm523Fp5ia5OhwiFmr7/ItZV4d5Ead+I9dWsWGGH8773nm2oQw6Biy6CE0+0t6dKh4kM5g8c2LQMc319YoL5BitoHbY6ogmF7AnCYfujGTrUmvD642lEW6IzOG4t7+4dhLMHJPUXKXKZV9clMXBg03yPPmRIxY9QCP7+dysgL75oe7ixY+GXv7QjrcaMSXQNUwY3mO+6UOMZzI9ldbhGRLtWR/SJfD57ovR0W3E3l4nSguTtDZONCLdWODc/KXtj9+4vHLZ3Xrm5MHiw/e4nse71Pp9/bl1YTz9tZ6gXFNi5IKefDtOmJeX/NtVoK5jvzu/qaDC/I7GOTZ9ZLegQblpmj8eexFUh/V60iXYxHUDq6/Bu24JBksqtZZe3bfoRZWVZ68ONfeh3P4KdO+HZZ62IfPKJ9WkccwzceCN873u28ZSE0Nlgvmt1R8Y63My5XbZsgsGmwM6AATBkiD1hP4+DdAYVk3bwVOzGW7vdrlOQBLf3rvXh3oHl5trvvlofMfD54JVXrIC88YZV3UmTYNEiOOUUOzJLSTraC+anpdn5f93OnOsO5w2F7IlKSuyPSX9IXUJbrR08FbsJF+Qi3sTcobjWRzAIobD9oRUX27iHWh8xMAZWrbJxkP/9X6iqssHS//5v68baf/9E11DpJNHB/G4RGQdJS7NqlZeXUmlNEoWKSUfo5R7bDZyHw/b77lofm/w2sawSg6++sjGQ5cvhP/+xPc8JJ9hl5w47LPFjUZXEYoxdmlKctCZuHiC9G+sxVEySgOgUDVlZ1vpwR57o970VqqoY9uKLdhb6Bx/YhvrOd+BnP4NZs6wKK/2XyOG8YJPs5eTojUWcUDFJAMY0xT7AWh95efZ73ldmCyeMYBDefNNaIC+9xP5+P3zrW02ZONV069+4ARZ3OK+b1mTrVvsjU+KGikkvEStd+5AhTbEPpQ3cVQqXL7cLTe3caVNXnHUWH02dykGzZ6v51p+JTmtSUGDdWDqhqldRMYkTmq69BygvbxrOu26dbcRjj7WB9KOPhowMqtes0Q6jvxKd1qSkRIfzJhAVkx6ktXTtan10AneVwuXL4a23Wq5S2O3hPElGrIXvu4vrR01F3MRymtYk6dD/QDeIZX1ouvYuELlK4Qsv2GnQI0bEXqUwlQgE7BaPYamRayenGprWJClRMekkkena3YSJmq69i8RapfCkk9pfpTAVcJNTjR7d87Pvv/xS84opvY6KSQfw++2EQU3X3gP0k1UK28RN3TFmjKZxUVIGFZN2yMoCyYbcPE3X3mUCAZvOZPlym96kH65S2IgrJPGwSBQlgWjX2A5DhwLZgA4Yapunn4YlS2DLFjs5bOFC2HtvKyDPPqurFIIVkvp6GDWqf1hgSr9CxUTpPk8/DVdcYTtKsPGPn/7U+gV1lUJLKGRzq48aZUcfKUqK0U9/2UqPsmRJk5C4GGODS+++q6sUhkI23e3IkXbEhqKkIHENH4vI8SLyuYhsEJGFMfaPEZHXRORfIlImIiMj9v1GRD51trkR5ceIyD+c8kdFRAUx0WzZEru8slKFJBy2QjJihOYKU1KauImJiHiBe4ETgHHAmSIyLuqwW4E/GGMmAYuAm533nghMBaYAhwCXi0i+iHiAR4EzjDETgK+Ac+N1DUo7hMPwwAOtz2kYPrx365NshMM2U+3w4ZoXSkl54mmZTAc2GGM2GmMCwBPAKVHHjANec56/EbF/HPCmMSZojKkFPgaOBwYBfmPMv53jXgFOi+M1KK2xaxece65daGrixJYjk7KzbRC+vxIO28mXw4fbPDqKkuLE00U0Avgm4vUmrJURycdYMbgTmA3kicggp/x6EbkNyAGOBtYCO4F0EZlmjFkFnA6MivXhIjIfmA9QUlJCWVlZ167C70+aySQ1Ph9la9YkuhoUrl7Nt5csIb26mg0LFrDl+99nyOuvs/fDD5O5Ywf+wYPZeP75bN9/f5ugMY4kS5u0IBSys1jLy3v9o2tqarr+fU9RtE1a0tNtEk8xiTXuM9ofchlwj4icB7wFbAaCxpiXReRg4F1gB/CeU25E5AzgdhHJBF4GYiYhMsY8CDwIMG3aNFNaWtq1q9iwIWkW0Slbs4bS8eMTV4FgEG6/He68E/baCx5/nP0mTGA/gAkT7AguIAtrWkb7NONBwtskGncRppISm5gtAZSVldHl73uKom3Skp5uk3iKySaaWw0jgWaRWmPMFmAOgIjkAqcZYyqdfYuBxc6+PwHrnfL3gCOc8plg+zIlzmzeDAsWwMqVdvXCxYt1ZFI0rpAMGZIwIVGURBFP/82HwL4ispeIZABnAM9FHiAixU5QHeAqYKlT7nXcXYjIJGAS1gpBRIY4j5nAlcD9cbwGBeCll2DmTOuyuusuuOMOFZJoXCEpLk69zMaK0gHiZpkYY4IisgB4CfACS40xa0RkEbDKGPMcUArcLCIG6+a62Hl7OvC2WNdSFXC2McZ1Z10uIidhhfA+Y8zr8bqGfo/PZy2QpUttkP23v7Wz2pXmuEIyaJAVE0Xph8R1joYxZgWwIqrsuojny4HlMd7noxWXuzHmcuDynq2p0oING+AnP7HWyAUX2ESM8UiVngrU1KiQKP0enfCntOQvf2kSj4cfti4uJTZVVTY+UlycFIM0FCVRqJgoTdTUWBF56imYMQPuvlsnHrZFdbUVkiFDVEiUfo+KiWL55BP48Y/hq6/gl7+En/0MvN5E1yp5qamxkxFVSBQFUDFRjLEB9l//2o5C+vOf4dBDE12r5KamxubZKilRIVEUBxWT/szu3fCLX9gFq773PTshUYe1tk1trR0WPXRo0mRGUJRkQMWkv/L++3DxxTbH1o03wo9+pHfZ7VFba7MhDBumQqIoUaiY9DdCITvx8Lbb7NKxzz0HkyYlulbJT12dTWY5fLgKiaLEoMO/ChE5XETOd54PFpG94lctJS5s3Qpz58Ktt9q11196SYWkI9TX26SNKiSK0iodskxE5HpgGrA/8DB2hvofgcPiVzWlR3n1Vfj5z+2s9ttvt/m11K3VPvX1dqnhkSN1dJuitEFHb7NmAycDtdCYoFFX++kL+P1www127ZFhw+Bvf4P/839USDpCfb0VkBEjVEgUpR06GjMJOOnfDYCIaJa/vsCXX9qUKP/6F5x/Plx7bctFrJTY1Ndbl9bIkdYyURSlTTr6K/mziDwAFIrIhcAPgd/Fr1pKt3nmGbjySuvrf+ghOP74RNeo7+DzWctNhURROkyHfinGmFtF5FhsBt/9geuMMa/EtWZK16irsxbIk0/C9Olwzz3WTaN0DJ/PPo4aZYVYUZQO0a6YiIgXeMkY8z3smutKsrJmjU2JsnGjDbZfeqneWXcGv99mBFAhUZRO024A3hgTAupEpKAX6qN0BWPgkUfg+9+3qT6efBIuv1yFpDMEAnYOzqhRkJGR6NooSp+jo72ND/hERF7BGdEFYIz5aVxqpXScPXuscLz4IhxzjF0FcdCgRNeqbxEIQEODncSpQqIoXaKjYvKCsynJxIcf2tFaO3bAddfBhRfqpLrO0tBgxWTMGF38S1G6QUcD8I8667jv5xR9boxpiF+1lDYJhWxg/X/+x444evZZmDIl0bXqezQ02DjJ6NEqJIrSTTo6A74UeBT4DyDAKBE51xjzVvyqpsRk2za45BL4+9/hlFPgN7+BPJ0/2mmCQSsko0bp3BtF6QE66ub6H2CmMeZzABHZD3gcOCheFVNaMnDlSpsKpbbWWiVz5+pM9q4QDNpJiaNH2yzAiqJ0m46KSborJADGmH+LiI6d7C0CAfjNb5h0//3w7W/DfffBvvsmulZ9k1DICsmoUSokitKDdFRMVonIQ8Bjzut5wEfxqZLSjK++skH21avZfNJJjLjjDu0Eu0ooZK26kSMhJyfRtVGUlKKjYvJj4GLgp9iYyVvAb+NVKcXhr3+1KVE8HnjwQdaPHcsIFZKu4QrJiBF2yV1FUXqUjopJGnCnMeY2aJwVr8Nf4kV9vR3q+6c/wUEHwb33WrfMmjWJrlnfJBy2QjJ8uA5WUJQ40dFJCa8BkbfE2cCrPV8dhXXrYNYsePxxWLAAnnrKConSNcJhmxVg+HDIz090bRQlZemoZZJljKlxXxhjakREnc49iTHwxz/atUfy8qxVcuSRia5V3yYchupqFRJF6QU6apnUishU94WITAPq41OlfkhlJfz3f8PChXDIIfDKKyok3cUYa5EMHQoFmlZOUeJNRy2TnwN/EZEtgAGGA3PjVqv+xEcf2dFa5eVwzTVw0UWaEqW7GANVVVBSAkVFia6NovQL2uy1RORgERlqjPkQOAB4EggCfwO+7IX6pS7hsA2sz55tJx4+84wVFRWS7mGMdW0NGQIDBya6NorSb2iv53oACDjPDwWuBu4F9gAPtndyETleRD4XkQ0isjDG/jEi8pqI/EtEykRkZMS+34jIp842N6L8uyLyDxFZLSLviMi3OnCdycWOHTBvHtx0E5xwArz0Ekyd2v77lLZxhaS4WDMnK0ov056YeI0xu53nc4EHjTFPGWP+L9BmJ+4MH74XOAEYB5wpIuOiDrsV+IMxZhKwCLjZee+JwFRgCnAIcLmIuBHU+4B5xpgpwJ+Aa9u/zCTirbfg2GNh5UqbV+v++9Wn31NUV1sRUSFRlF6nXTERETeu8l3g9Yh97cVbpgMbjDEbjTEB4AnglKhjxmGHHQO8EbF/HPCmMSZojKkFPgbcRcwN4ApLAbClnXokBw0NcPPNcOaZ1v3ywgtw9tmaW6unqK628ZHiYm1TRUkA7QnC48CbIrITO3rrbQDHtVTZzntHAN9EvN6EtTIi+Rg4DbgTmA3kicggp/x6EbkNyAGOBtY677kAWCEi9dg16WfE+nARmQ/MBygpKaGsrKyd6raC39/tOEZWeTnfvvlmCtatY8usWWy46CLCoVCnJyHW+HyU6cTFZtT4fJR98gl4vbB1q52n08+pqanp+vc9RdE2aUlPt0mbYmKMWSwirwHDgJeNMcbZ5QEuaefcsW4PTdTry4B7ROQ8bIqWzUDQGPOyiBwMvAvsAN7DBv4BLgVmGWM+EJHLgduwAhNd9wdx4jrTpk0zpaWl7VS3FTZssLmwunq3+/zzdiVEY+C++xh+8skM79qZKFuzhtLx47v47tSk7JNPKJ00yQ4BVosEgLKyMrr8fU9RtE1a0tNt0u7QYGPM+zHK/t2Bc28CIqdujyTKJWWM2QLMARCRXOA0Y0yls28xsNjZ9ydgvYgMBiYbYz5wTvEkdmRZ8lFfDzfeCI89BgceCL/9rU15rvQcNTXWalQhUZSEE89xqB8C+4rIXs4qjWcAz0UeICLFIuLW4SpgqVPuddxdiMgkYBLwMnYUWYGzngrAsUDy+TX+/W846SQrJD/5iR32q0LSs9TUwIABkJ6uQqIoSUBHJy12GmNMUEQWAC8BXmCpMWaNiCwCVhljngNKgZtFxGDdXBc7b08H3hbbSVQBZxtjggAiciHwlIiEseLyw3hdQ6cxBp54Aq691nZ0y5aBmtY9T22tbd9hw2D9+kTXRlEU4igmAMaYFcCKqLLrIp4vB5bHeJ8PO6Ir1jmfAZ7p2Zr2AFVVNh3KX/8Khx8Od91lZ2ArPUtdnV1md9gwneCpKElEXMWk37B6tXVnbdpkBeXii7Wjiwf19ZCZaRM3avsqSlKhv8juEA7bSYennGLXFX/qKbjkEu3o4kFdHaSlWSHxehNdG0VRolDLpKvs3AmXXgqvv27XH/l//w8KCxNdq9Skvt4KyYgRKiSKkqSomHSFd96Bn/4UKipsfq1zztERRfGivt4KyMiRVlAURUlK1B/TGYJBm0/rjDPsAlbPPw/nnqtCEi98Ptu2KiSKkvToL7SjbN5sA+sffmjF5Fe/ghxdbDJu+Hz2cdQoFRJF6QPor7Q1li2zi1V9/bVNIOi6W+69F049NdG1S238fjtnZ/RoOylRUZSkR8UkFsuWwfz5dgQRwO7d1t1y3XUqJPHG74dQSIVEUfoYGjOJxTXXNAmJizHw+98npj79hUDACsmoUZCRkejaKIrSCVRMYvH117HLt/SNpVP6JA0Ndhs1yk5MVBSlT6FiEovWkjIO72ryeKVNGhqse0uFRFH6LComsVi8uOVIrexsmypF6VmCQTtya/Rom3NLUZQ+iYpJLObNgwcfhDFjbOB9xAi45RaYMyfRNUstgkE7Sk6FRFH6PDqaqzXmzbNbd1daVGITClkhGTXKtq+iKH0atUyU3icUsmuSjBypEz8VJUVQMVF6F1dIRoywC1wpipISqJgovUc43CQkeXmJro2iKD2IionSO4TDdt324cNVSBQlBVExUeKPKyTDhkF+fqJroyhKHFAxUeKLMVZISkqgoCDRtVEUJU6omCjxwxiorrZCUlSU6NooihJHVEyU+OAKyZAhKiSK0g9QMVF6Hte1VVwMAwcmujaKovQCKiZKz+JaJAMHwqBBia6Noii9hIqJ0nO4QjJokLVKNAWNovQbNDeX0jM0NNhcW26MRIVEUfoVKiZK96mrA4/HZlnWpI2K0i9RMVG6jptnq6DAWiReb6JrpChKglAxUbqGz2fXIxk+XGe1K4oS3wC8iBwvIp+LyAYRabFMoYiMEZHXRORfIlImIiMj9v1GRD51trkR5W+LyGpn2yIiz8bzGpQo3CC71wtjx6qQKIoCxNEyEREvcC9wLLAJ+FBEnjPGrI047FbgD8aYR0XkGOBm4AciciIwFZgCZAJvisiLxpgqY8wREZ/xFPDXeF2DEoUbZC8utiO2NMiuKIpDPC2T6cAGY8xGY0wAeAI4JeqYccBrzvM3IvaPA940xgSNMbXAx8DxkW8UkTzgGEAtk96grs66tcaM0WG/iqK0IJ4xkxHANxGvNwGHRB3zMXAacCcwG8gTkUFO+fUichuQAxwNrI1672zgNWNMVawPF5H5wHyAkpISysrKunYVfr8dqZQE1Ph8lK1Z0/sfHApZt1Z6OnzzTfvH9yI1NTVd/9+mKNomLdE2aUlPt0k8xSTWrauJen0ZcI+InAe8BWwGgsaYl0XkYOBdYAfwHhCMeu+ZwO9b+3BjzIPAgwDTpk0zpaWlXbgEkmoN+LI1aygdP773PtDns66tJE4dX1ZWRpf/tymKtklLtE1a0tNtEk8x2QSMing9EtgSeYAxZgswB0BEcoHTjDGVzr7FwGJn35+A9e77HOtlOtY6UXoaY+yQ38xMu057Rkaia6QoSpITT//Nh8C+IrKXiGQAZwDPRR4gIsUi4tbhKmCpU+51BAMRmQRMAl6OeOt/Ac8bY3xxrH//pKGhKbfWqFEqJIqidIi4WSbGmKCILABeArzAUmPMGhFZBKwyxjwHlAI3i4jBurkudt6eDrwt1rVUBZxtjIl0c50BLIlX3fst9fX2cfRoyMlJbF0URelTxHXSojFmBbAiquy6iOfLgeUx3ufDjuhq7bylPVdLpXFZ3YICGDwY0nQuq6IonUN7jf5O5Ez2vLykGGigKErfQ8Wkv+IG2TMy7Ex2jY0oisI+Ya4AAA04SURBVNINVEz6I8GgnYToroSYJPNoFEXpu6iY9Dfq6uyjBtkVRelBVEz6C+GwdWvl5kJJiQbZFUXpUbRH6Q/4/Xb+yNChdia7BtkVRelhVExSGWOsWys93SZozMxMdI0URUlRVExSFTfIPmiQ3TTIrihKHFExSUU0yK4oSi+jYpJKuDPZ8/I0yK4oSq+ivU2q4PdDINCULl6D7Iqi9CIqJn2d6JnsGmRXFCUBqJj0ZTTIrihKkqBi0lepr7dWyahRMGBAomujKEo/R8Wkr6FBdkVRkhDtifoSbnykpAQKCzXIrihK0qBi0hdwRQQ0yK4oSlKiEdtkJxiEqipriWRkqJAoipKUqJgkM/X1dv7I6NEwZEiia6MoitIq6uZKRtx08QMG2PhIenqia6QoitImKibJRiBg12XXILuiKH0IFZNkwU0X7/XaIHtWVqJrpCiK0mFUTJIBdyZ7UREMHqwz2RVF6XOomCSa+nobIxk50i6pqyiK0gdRMUkUbpA9J8cup6tBdkVR+jAqJolAg+yKoqQYKia9TW2tBtkVRUk5VEx6i1DICklRERQXW0FRFEVJEVRMegM3yD5ihM32qyiKkmLEdQyqiBwvIp+LyAYRWRhj/xgReU1E/iUiZSIyMmLfb0TkU2ebG1EuIrJYRP4tIutE5KfxvIZuYYzNq+WugqhCoihKihI3y0REvMC9wLHAJuBDEXnOGLM24rBbgT8YYx4VkWOAm4EfiMiJwFRgCpAJvCkiLxpjqoDzgFHAAcaYsIgkZ9IqN8g+ZIh1bWmQXVGUFCaelsl0YIMxZqMxJgA8AZwSdcw44DXn+RsR+8cBbxpjgsaYWuBj4Hhn34+BRcaYMIAxZnscr6Fr1NZat9bYsTBwoAqJoigpTzxjJiOAbyJebwIOiTrmY+A04E5gNpAnIoOc8utF5DYgBzgacC2afYC5IjIb2AH81BizPvrDRWQ+MB+gpKSEsrKyrl2F39+5GemhkF39MC0Nvv66a5/ZCjU1NV2/jhRF26Ql2iYt0TZpSU+3STzFJNbtuIl6fRlwj4icB7wFbAaCxpiXReRg4F2sYLwHBJ33ZAI+Y8w0EZkDLAWOaPFBxjwIPAgwbdo0U1pa2rWr2LABsrPbty7q662QDBsWt9hIWVkZXb6OFEXbpCXaJi3RNmlJT7dJPN1cm7CxDZeRwJbIA4wxW4wxc4wxBwLXOGWVzuNiY8wUY8yxWGFyrY9NwFPO82eASfG7hA5gDFRX2yD7XntpkF1RlH5JPMXkQ2BfEdlLRDKAM4DnIg8QkWIRcetwFdbKQES8jrsLEZmEFYyXneOeBY5xnh8F/DuO19A2gYAVksGDbW4tTYmiKEo/JW5uLmNMUEQWAC8BXmCpMWaNiCwCVhljngNKgZtFxGDdXBc7b08H3hbrWqoCzjbGuG6uJcAyEbkUqAEuiNc1tEldnY2ljBlj3WCKoij9mLhOWjTGrABWRJVdF/F8ObA8xvt82BFdsc5ZAZzYszXtBO5M9oICO+xXZ7IriqLoDPhO4fPZtUeGD4f8/ETXRlEUJWlQMekIxkBNjU3MOHKkDbYriqIojaiYdITqapsuXmeyK4qixETFpD3y8+1wXw2yK4qitIqKSXsMSc7UX4qiKMlEXLMGK4qiKP0DFRNFURSl26iYKIqiKN1GxURRFEXpNiomiqIoSrdRMVEURVG6jYqJoiiK0m1UTBRFUZRuI8ZEL36YeojIDuCrRNejBygGdia6EkmGtklLtE1aom3Sko60yRhjzOCOnKxfiEmqICKrjDHTEl2PZELbpCXaJi3RNmlJT7eJurkURVGUbqNioiiKonQbFZO+xYOJrkASom3SEm2TlmibtKRH20RjJoqiKEq3UctEURRF6TYqJoqiKEq3UTFJMCKyVES2i8inEWUDReQVEVnvPBY55SIid4nIBhH5l4hMjXjPuc7x60Xk3ERcS08hIqNE5A0RWScia0TkZ055v20XEckSkZUi8rHTJjc65XuJyAfO9T0pIhlOeabzeoOzf2zEua5yyj8XkeMSc0U9g4h4ReSfIvK887pftweAiPxHRD4RkdUissopi/9vxxijWwI34EhgKvBpRNktwELn+ULgN87zWcCLgAAzgA+c8oHARuexyHlelOhr60abDAOmOs/zgH8D4/pzuzjXlus8Twc+cK71z8AZTvn9wI+d5z8B7neenwE86TwfB3z8/9s7/1iv6jKOv94FkkFIUTIHbcJkDQnFgrumNFkkpTmrySrHqhlLa9W0tlrl5myxRatMK7aiWMMsrRCTuVmSlkXaNG4EF9QF05aAUCP80YBI3v3xec7l+PV7sfp+773ce57X9t05n+d8Puf7fJ57z3nO53M+3+cBxgHTgZ3AS4e7fx3Y5VPAj4A7o9xoe0SfHgde3SIb9GsnRybDjO3fAPtbxO8E1sT+GuBdNflNLvwemCTpNOBtwAbb+23/A9gAvH3wtR8cbO+x3Rv7zwAPA1NpsF2ib89GcWx8DLwFWBvyVptUtloLLJKkkN9q+7Dtx4AdQM8QdKHrSJoGvAP4XpRFg+3xIgz6tZPO5MRkiu09UG6sQJWIfirw11q9J0I2kHzEE9MR51CexBttl5jS2Qzso1zcO4EDtv8dVer96+97HH8KmMzosskNwGeAo1GeTLPtUWHgbkmbJF0RskG/dsZ0QfFk6FAbmY8jH9FImgDcBlxt++nyINm+ahvZqLOL7eeAuZImAbcDs9pVi+2otomki4F9tjdJWliJ21RthD1aOM/2bkmnAhskPXKcul2zS45MTkz2xlCT2O4L+RPAa2v1pgG7jyMfsUgaS3EkP7S9LsSNtwuA7QPArylz3JMkVQ+F9f719z2On0KZTh0tNjkPuETS48CtlOmtG2iuPfqxvTu2+ygPHT0MwbWTzuTEZD1QrZ74IHBHTf6BWIHxJuCpGLL+Algs6ZWxSmNxyEYkMZe9GnjY9vW1Q421i6TXxIgESScDb6W8S/oVsCSqtdqkstUS4F6XN6vrgffF6qbpwEzgwaHpRfew/Tnb02yfTnmhfq/tpTTUHhWSxkt6RbVP+Z/vYyiuneFeedD0D3ALsAc4QnkaWEaZy70H+HNsXxV1BaykzJVvBebVzvMhysvDHcDlw92vDm2ygDKk3gJsjs9FTbYLcBbwx7BJH3BtyGdQbn47gJ8C40L+sijviOMzaue6Jmz1KHDhcPetC7ZZyLHVXI22R/T/T/HZBlwT8kG/djKcSpIkSdIxOc2VJEmSdEw6kyRJkqRj0pkkSZIkHZPOJEmSJOmYdCZJkiRJx6QzSUYFkiZHlNTNkp6UtKtWPum/PMf3Jb3uRep8TNLS7mh9YiBpo6S5w61HMrLJpcHJqEPSdcCztr/aIhflf/5o24YNRdJG4OO2Nw+3LsnIJUcmyahG0hmS+iR9G+gFTpO0StIfVPKCXFuru1HSXEljJB2QtEIlf8gDEecIScslXV2rv0Ilz8ijks4N+XhJt0XbW+K7XvDkL2m+pPsiIN9dkqZIGhvlBVHnKzqWu+QLkh6q+hPOsdLjekm/lbRd0jxJt6vkobiuZodtkn6gkuviJ/FL+ladLoz+9qrk/xhf02O7Ss6LL3f1j5SMCtKZJE3gTGC17XNs76LkdZgHnA1cIOnMNm1OAe6zfTbwAOXXwO2Q7R7g00DlmD4BPBltV1CiHj+/kTQOuBG41PYbgZuBL9o+AlwOrJK0mBJzank0u9H2fGBO6FcPCX7Q9pspYWh+Bnwk6l1RhWEJO6y0PQc4BFzZotOplFwXi2y/gfJr+6skTaFEIJht+yzgSwPYImkw6UySJrDT9kO18mWSeikjlVmUm2wrB23fFfubgNMHOPe6NnUWUIIPYrsKa9HKLGA28EuVsPKfJQLr2d4S7e+ghLE4Em0WSXqQEirj/GhfsT62W4GttvfaPkRJlDQtjj3mkrMCivNa0KLTuRRb3B86LY0+7aeEef+upHcD/xzAFkmDyRD0SRPov/lJmglcBfTYPiDpZkrcplb+Vdt/joGvlcNt6gwYK7+GgC0xmmjH6yk5N6rptZcD36JkoNwlaXmL3pUeR2v7VbnSq/UFaWtZwM9tv/8FykrzgAsoQRU/Sgn8lyT95MgkaRoTgWeAp3Uso1y32Qi8B0DSHNqPfLYDUyX1RL2TJM2O/fcCEygBDFdKmgicTHEMf4+osJf+H3pNlzQ/9i8LPevcD5wvaUboMV7SzPi+ibbvBD5Jm2m7JMmRSdI0eik38j5KXuvfDcJ3fBO4SdKW+L4+yiijH9uHJS0BvhE36zHA1yT9jfKOZGGMQL4DfN32Mklr4lx/oWSe/F/ZBnxY0mrgEWBVi057JS0DflxbTv154CCwLt7zvISSdz1JnkcuDU6SLqOSfGmM7UMxrXY3MNPH0skOh05nAGtt5+9JkkEhRyZJ0n0mAPeEUxFw5XA6kiQZCnJkkiRJknRMvoBPkiRJOiadSZIkSdIx6UySJEmSjklnkiRJknRMOpMkSZKkY/4DjGbJkFZWKvgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1aa29a66d8>"
      ]
     },
     "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
}