breast_cancer_ML_model_search.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": [
    "%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 *"
   ]
  },
  {
   "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:       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": 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' : [10000],\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' : [10000],\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' : [10000],\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' : [10000],\n",
    "#          'classifier__intercept_scaling' : [0.5, 1.0, 1.5]\n",
    "#         }      \n",
    "#    ]}\n",
    "]\n",
    "\n",
    "scoring = 'f1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3/3 [04:38<00:00, 92.85s/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=-1)['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>SVC1</td>\n",
       "      <td>0.981165</td>\n",
       "      <td>{'classifier__C': 100, 'classifier__gamma': 0....</td>\n",
       "      <td>b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...</td>\n",
       "      <td>2</td>\n",
       "      <td>0.971120</td>\n",
       "      <td>0.014185</td>\n",
       "      <td>0.947368</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>SVC1</td>\n",
       "      <td>0.979056</td>\n",
       "      <td>{'classifier__C': 0.1, 'classifier__kernel': '...</td>\n",
       "      <td>b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...</td>\n",
       "      <td>1</td>\n",
       "      <td>0.978947</td>\n",
       "      <td>0.025784</td>\n",
       "      <td>0.921053</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>SVC1</td>\n",
       "      <td>0.978538</td>\n",
       "      <td>{'classifier__C': 1, 'classifier__kernel': 'li...</td>\n",
       "      <td>b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...</td>\n",
       "      <td>0</td>\n",
       "      <td>0.979082</td>\n",
       "      <td>0.019480</td>\n",
       "      <td>0.947368</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   name  best_score                                    best_parameters  \\\n",
       "0  SVC1    0.981165  {'classifier__C': 100, 'classifier__gamma': 0....   \n",
       "0  SVC1    0.979056  {'classifier__C': 0.1, 'classifier__kernel': '...   \n",
       "0  SVC1    0.978538  {'classifier__C': 1, 'classifier__kernel': 'li...   \n",
       "\n",
       "                                            pipeline trial  score_mean  \\\n",
       "0  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     2    0.971120   \n",
       "0  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     1    0.978947   \n",
       "0  b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...     0    0.979082   \n",
       "\n",
       "   score_std  score_min  score_max  \n",
       "0   0.014185   0.947368        1.0  \n",
       "0   0.025784   0.921053        1.0  \n",
       "0   0.019480   0.947368        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                                                                 SVC1\n",
       "best_score                                                       0.981165\n",
       "best_parameters         {'classifier__C': 100, 'classifier__gamma': 0....\n",
       "pipeline                b'\\x80\\x03cimblearn.pipeline\\nPipeline\\nq\\x00)...\n",
       "trial                                                                   2\n",
       "score_mean                                                        0.97112\n",
       "score_std                                                       0.0141855\n",
       "score_min                                                        0.947368\n",
       "score_max                                                               1\n",
       "best_parameters_hash                                  3510003529597648470\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": [
       "OutlierSampler(memory=None, threshold=8.5, verbose=0)"
      ]
     },
     "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": [
       "SVC(C=100, cache_size=200, class_weight=None, coef0=0.0,\n",
       "  decision_function_shape='ovr', degree=3, gamma=0.001, kernel='rbf',\n",
       "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "  tol=0.001, verbose=False)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "{'classifier__C': 100, 'classifier__gamma': 0.001, 'classifier__kernel': 'rbf'}"
      ]
     },
     "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 0x10c1e4e48>"
      ]
     },
     "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 0x1aa5837cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection 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 = [ 2, 5, 10, 15, 20]\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.988522495030937 0.0016552398724581769\n",
      "Validation score: 0.9825243535805299 0.01340784638096497\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAucAAAIGCAYAAAD3HyHvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3Xd4VNXWx/HvokjvYAVFAUFABAyIoiJiQ+zgK9grgh0Lgl67WJELdrFjARHrtSFWLChFAQGloyCoFKVIh/3+sSZkGJKQhEnOJPl9nmeeZM6cmbNmJmXNPmuvbSEEREREREQkeiWiDkBERERERJyScxERERGRFKHkXEREREQkRSg5FxERERFJEUrORURERERShJJzEREREZEUoeRcRDCzkIPLEUk4zh9mdncSQs53ZrbKzPpkcVsdM9tsZpdncXs5M1tpZgNycbz+ZjYv7voJsde97nbu96SZTcnpcWL3qW1mt5vZ7gnbc3TMZDOz1mb2hpn9aWbrzWyBmT1tZg0KMo6cMLMKsZ+Ne7PZZ66ZDc/FY15jZhvjrjePvQ+Hbud+/zGzf3J6nNh9Ksfe+0YJ23N0TBHJf0rORQTg4LjLkbFtdyds/yEJxzkeeDIJjxOpEMJ84Bugaxa7dAIqAkN34DBf46/7oh14jKzUBm4Ddk/Ynp/HzJSZnQ18C5QDrgKOAvoAewKfFVQcORVC+Bf4H3BGZrebWRugLjv23s/A34dJO/AYWamMv/eNErbn5zFFJBdKRR2AiEQvhPBd+vdmVjH27ez47Vkxs7IhhLU5PE4yEvxUMRR41MxqhxAWJNzWFX/9xuX1wUMI/wDbff2TqaCPaWb7AE8Dg0MIlyXc/LKZnZDNfcuFENbka4BZGwp0NbODQgjfJ9zWFVgBfJDXBw8hrKbg3/sCP6aIZE4j5yKSY2bWI3bqu6WZfWVma4ArzT1kZlPM7F8zm29mL5pZrYT7b1XWYmbDzOxrMzvezKbGygW+NLOG24mjspk9YWYzzGy1mc0xs0FxHywws7KxWHuY2QNmtjRWNjHIzEonPF4HM/vJzNaa2Tgza5WDl+N1YBMJI6ixGI4nbuTUzE4zs8/NbLGZLTezb8ys3Xae4zYlJmZWy8xGxJ7zAjO7LpP77WVmQ8xsnpmtMbNfzOwWMysVu70pMCa2+7jYMVZlc8xKsdKZv2KPNyYxdjMbb2YvmNmFsZKO5Wb2jpntsp3XsEfsNbwxsxtDCO/FHWOJmd1pZneb2SJgYdxt55rZNDNbZ2a/xp5vibjba8Z+Hv+IvcfzzOzhuNv3MbO3YsdYbWYzzeymbOL+CPibhDMnsWOeDrwZQlgX23akmX0YO/bK2Gt1SnYvimVSYmJeTvNs7DEWm1k/Ev6Hm1l1M3sqFv9qM5sd+70sH7u9KjA/tvtbllGyVjWLY+5kZveb2e+x121iYuxm9raZfWJmJ5vZz7Hf4c/MrF52z1FEsqaRcxHJi9eAx4BbgWV4klAdL4VZBOwC3AB8bGYtQwghm8eqH7vf7cAGYACe2LbM5j6V8KSuL7AELyP4T+zryQn73gSMBLoBBwL9gNnAw+DJLPAe8BVeTrEXMAwoTTZCCIvN7FM8QXso7qZT8BKNYXHb9gZGAPfG7fOpmbUKIfyY3XESvAocAFwOLI09t9pAfN3xLnjienVse2PgDqAqcB3+3C8GngEuAH7BX8usvAwcjr/W82PH/tjMDgkhTIjb70j8tbsqdqyBwCPA/2Xz2O2Ab0IIK7fzvNNdgpdXXUzs/5eZnQq8iI/A9wJa4WUbVYDrY/d7HC/juAJYHIuzddzjDgNWAxcCK/Gfyb2yCiKEsN7M3gRON7PrQgibYzcdjpcKxZe01AU+AQbhP99HAm+Y2QkhhA9z+LwBHsUT/z7AHOBKYP+EfaoAa/EPO0uBfYBb8J+RM2LP7STg3dg+o2P3y+r1/y/+mtwCTAHOBt6MxR5/ZqBxbJ//xN3vJeCQXDw/EUkXQtBFF1102XLBa6UDcH4mt/WI3Xbpdh6jJFAvtm/ruO1/AHfHXR8GrAf2itvWNXa/urmIuRTQAdgM7BLbVjb2OB8n7PsR8EXc9YdjcZWJ23ZR7L59tnPc82L71Yvb9h4wKZv7lIjF+w3wcNz2/sC8uOsnxL8OeDIZgE5x+1QHVgFTsjiWxY7VHU/ULba9Teyx0hL2TzxmWux654TXeg7wRty28cBfQIW4bf+JvbclsnktFgBP5/A9XgLMBUolbJ8C/C9h252xY9eMXZ8HXJDNz+omoH0uf086xF6bdnHbnoy9DiW3896/ho+up2+/BtgYd7157LEPjV3fE9hI3O8dsBPwO/DPdn4vOsWeX7XYttqxxz4lYd/EY9bBP0xcnbDft8D3cdffxj8Q7B637fzYY+2am9dUF1108YvKWkQkL95P3GBmJ5nZd2a2HE8kZsVu2nc7jzUjhPBr3PVpsa+1s7tTrIRikpn9iycRn+DJaGKHj48Trk9LeOzWwEchVoYQ8+Z2Yk73Fp6YnBGLqRpwNAmTAc1sbzN71cwW4q/NBnxUcXuvTbzWeMK5ZbQ1hLAM+DLhWCXN7EYzmw6siR3rKXxUdXtlJpkdcwOegKUfcyPwBpDY1ePb4JMl003Dzz7svJ1jZHdWJdHI2PEBiJVrNMFLjOK9Fjt2ennSROA/ZnZpYrlFCGET8BPwkJmdY2Z75DCWz/EPdenvfSmgMzA89pjpMe4cKzWZj7+WG/CzCbl571viHyLeiYt7Pf5BcCux5/iTma2OHes9/ENBbstMWuDJfWavbZqZlY3bNiWEsDDueo5+h0Ukc0rORSQv/oy/YmZt8UR1Nn7q+2D8FD/4CHZ2ElvBrd/e/cysG/Asnph2AQ4io/438X6ZPX78Prvio51bhBD+xhObbIUQ0if+pR/7NHxEc0tJi5ntFNunOV4acgSeNH6ZSazZ2RVYGjJKKNL9lXD9JuAuvATmRDzBTi/vyM3xAHaLHTOx7OVPfNQ+Xq7fR3zkd89cxPNnwvXdstiefj09xovxD2l3A7NitdHxtdOnAD/jpSMLzOcdZNtSMPY+DAe6mFlJfCS9Jtt2aXkd6Bg7dgf8vX+d3L/34CU58bZ6783sAnz0/mP8Z/Eg4NzYzXl57yHz17YE/mEvXV7eexHJgmrORSQvEkc7OwO/hRDOSt9g25nUuYNOB74MIVwVd7xqeXysP0gY3Y09VrY153GGAq+bWWM8SR8TQpgXd3tTvN75sBDC13HHqADEjzTnJM4aZlYiIUFPHJk+HRgSQrgj7lityZtFsWOWTEjQd8HnGuyoL4DLzKxiCGFVDvZP/LlLb/mY+BqknyFYBhBCWAL0NLPL8A9JN+Pv2b4hhLmx9+usWJLdBp+X8J6Z7ZFwNiDRULzGvgP+3v+Gl30APoEX/5DaLYQQ/4Etpz9b6f6Ifa0V9z1k/t6PDCFsmShsZruRN/GvbXxrzV3w8rHleXxcEdkOjZyLSDKUI2O0LN1Zme2YxOOtS9iW1+ONA44zszJx207Lxf3fwyfUXQW0Z9uR03Kxr1viNV8AJrsJr5kZi4/Kd4x7nOr4pMrE4yW+NmcmXM/pyOZY/EPKlkm2sQT2NLwn+o56Ch8kynRBHzPrlN2dg7f/m4InpfH+D3+OYxP2D8En4PaNHbdBwu2bQgjf4Ml5FSDbEpfgrUbn4qPTpwDDQgjxHyDKx77Gv/e18NKn3PgBrxuPfx92wuvJ4+Xk9yKn7/0PeAlW4mt7OjA+5LB9qojknkbORSQZRgE9zOxBfMLl4WS9QE+yjvegmfUGfsQ7UOR1ZcMBeBeQ/5nZILzM4ga2/bCRqRDCWjN7G590uZlta3Qn4eUIj5jZ7UANfMLifHIhhDDWzD4Dno8972V4CUtiScEo4Dwzmxg7xoVklCikm40nXhear0y5LmTSNSaEMN7M3gWeiSWV84HL8Fri7Lqw5PQ5zTGz7rHntDfedeUPfDLiWUCz2PfZuRXvIPIEXlqVhr8ug0IIS8FbPeLdQ6bhtduX4a/bD7Ea82F4V5qZ+IToG4Ff8ddpe4bhHVSMbT+Y/QZMB+4xs834B51b2bYUKVshhN/M7BWgf6y2fS7erSXRKOBOM7sWr6PvjL8e8RbjPztnmdlv+M95Zu/9AjMbDNwXO+ZUvGTtEHzisIjkE42ci8gOCyG8ibdSOwtv03YQPpKYXx7B64Ovxycn7kxGbW2uhBDm4rXZu+MTQS/G2y5ut+Y8zlA8OfsihBBfdkCsXCO9Fv0tvIvJTXiHk9zqho9YP47XFr/BtpMC++ITBx/EE84lJPQRDyEsB3rio+5fxS5ZOQf/wHE3/vrUBI4NW7dRzLMQwktAWzxJfBxfFfQBPIk8Pgf3fwvvDnIE/lr0wGvue8ftNgb/8PQ2XotfLvYcluALBs3Ef5bex1tM/hW7PbsWk+nS3/vpIYSJCbEFfE7E0th+D+JnC97NweMmuhxvx3kfMAT/0Pd0wj4PAYPxn68ReMvRizOJ6SJ8gujn+JmjSlkcsxcZv2fv4h+WOoet2yiKSJLZ1mfgREREREQkKho5FxERERFJEUrORURERERShJJzEREREZEUoeRcRERERCRFKDkXEREREUkRSs5FRERERFKEknMRERERkRSh5FxEREREJEUoORcRERERSRFKzkVEREREUoSScxERERGRFKHkXEREREQkRSg5FxERERFJEUrORURERERShJJzEREREZEUoeRcRERERCRFKDkXEREREUkRSs5FRERERFKEknMRERERkRSh5FxEREREJEUoORcRERERSRFKzkVEREREUoSScxERERGRFKHkXEREREQkRSg5FxERERFJEaWiDiBKNWvWDHXr1o06DBEREREpwiZMmLAkhFArJ/sW6+S8bt26jB8/PuowRERERKQIM7Nfc7qvylpERERERFKEknMRERERkRSh5FxEREREJEWkVHJuZs+Z2V9mNiWL283MHjazWWY22cxaxt12npnNjF3OK7ioRURERESSI6WSc+AF4Lhsbu8INIhdugNPAJhZdeA24CCgNXCbmVXL10hFRERERJIspZLzEMJoYFk2u5wMDAnuO6Cqme0GHAuMCiEsCyH8DYwi+yRfRERERCTlFLZWinsA8+OuL4hty2q7iEih98cfcOGFcNllcMIJUUcjqWTzZrj6ahg1KupIUkeFCvDkk9CqVdSRiORNYUvOLZNtIZvt2z6AWXe8JIY999wzeZGJiOSDf/+FE0+E8eNh9Gj4/nto0iTqqCRV3HMPPPooHHssVK0adTSp4csv4bzz4McfoUyZqKMRyb3ClpwvAOrEXa8NLIxtPyJh+xeZPUAIYTAwGCAtLS3TBF5EJBVs2gRnngk//ABPPQW33QannAJjx0I1zaop9t57D269Fc46C156CSyzYapi6MMP4fjj4d574fbbo45GJPdSquY8B94Fzo11bWkDLA8hLAJGAseYWbXYRNBjYttERAqta6+Fd9+FQYOge3d44w349VdP2Ddtijo6idL06Z6Ut2gBTz+txDxex47QrZufVZg2LepoRHIvpZJzMxsKjAEamtkCM7vIzHqYWY/YLh8Ac4BZwNPAZQAhhGXAXcC42OXO2DYRkUJp0CB4+GHo1QuuuMK3HXKIlzB89BHccku08Ul0VqzwMyg77QRvvQXlykUdUeoZOBAqVYJLLvG6fJHCxEIovpUdaWlpYfz48VGHISKylbffhtNO8wTs9dehZMmtb7/0Uhg82G/r0iWaGCUamzf7z8Z778Enn8ARR0QdUep68UU4/3x47DGfTC0SJTObEEJIy8m+KTVyLiJS3I0d62UrrVrByy9vm5iDj6gfcognHj/9VOAhSoTuvhveeQcGDFBivj3nngtHHQV9+sCCBVFHI5JzSs5FRFLE3LnemWXXXb3WvHz5zPcrUwZGjIAqVXx0fZmK+IqFd9/1ScHnngtXXhl1NKnPzCdSb9wIl18OxbhQQAoZJeciIing77+9w8T69fDBB7DLLtnvv9tuPkF0wQKf/KYJokXbL7/A2WfDgQd6D29NAM2ZffaBO+7wDzZvvBF1NCI5o+RcRCRi69Z5HfHs2V5v3qhRzu7Xpo3X0378Mdx8c/7GKNFZvtzPkJQtqwmgedGrl3e1ufJK/xAskuqUnIuIRCgEuPhi+OILeP55aNcud/e/+GLo2RPuvx+GD8+XECVCmzf7iPns2V7KVKfO9u8jWytVCp55BhYvht69o45GZPuUnIuIROj2233i5113ed/qvBg4EA49FC64ACZNSmp4ErE77vDOLP/9Lxx+eNTRFF4tW/oI+jPP+AqiIqlMrRTVSlFEIvLCC55QX3ABPPvsjtUR//EHpKV57+tx46BGjaSFKRF5+2049VTvyvPcc6oz31GrV8P++3sHpMmTvUxIpKColaKISIr79FNfIOWoo7yjxI4mXrvuCm++Cb//7hNEN25MTpwSjWnT4JxzvKXmE08oMU+G8uV9Mu3MmX6mSiRVKTkXESlgU6b4BNCGDb2OuHTp5Dxu69aefIwaBX37JucxpeD9849PAC1f3j9waYQ3eY4+Gs47Dx54wEfPRVKRknMRkQK0aBF06uSJ1wcfeK/yZLrgAu/p3L8/DB2a3MeW/Jc+AXTuXP/gVrt21BEVPQ89BNWq+ZkrtSCVVKTkXESkgKxaBSecAEuXwvvvw5575s9x/vtfOOwwuOgimDgxf44h+eO22/xnY9Agfw8l+WrU8EnUY8fCo49GHY3ItpSci4gUgE2bvBZ84kQYNsy7R+SX0qXh9dc9CTn1VFiyJP+OJcnz5ptw993+oapnz6ijKdq6dYOOHX19gF9/jToaka0pORcRyWchwNVXe0u8Rx7x0fP8tssuvmDNokVwxhmaIJrqpk6Fc8+Fgw7yhaU0ATR/mflEW/APQsW4cZ2kICXnIiL5bOBAT7iuvx4uu6zgjpuW5p1gPvsMbryx4I4rufP33z4BtFIlX2K+TJmoIyoe9toL+vWDDz/0s1kiqULJuYhIPnrzTbjuOujc2VfxLGjnnQdXXQUDBsArrxT88SV7mzbBmWd6acWIEbDHHlFHVLxccYV3Obr6ap8LIpIKlJyLiOST77/3VT8POgheeglKRPQXt39/aNcOLr4Yfvghmhgkc7fcAh995OVObdtGHU3xU7IkPP20n7247rqooxFxSs5FRPLBnDlw4omw++7w7rtQrlx0sZQuDcOHQ61aPkF08eLoYpEMI0bAvfd6S79LL406muKrWTPo3RtefBE++STqaETAQjGeBZGWlhbGjx8fdRgiUsQsWwaHHOJJ8JgxsO++UUfkJkyAQw+Fgw+Gjz+GUqWijqj4+uknfx+aNYPPP1ededTWrvX3YtMmf2/Kl486IilqzGxCCCEtJ/tq5FxEJInWrfPR6blz4e23UycxBzjwQBg82JPBG26IOpria9kynwBaubKPnisxj17Zsv67MWcO3H571NFIcafkXEQkSUKACy+E0aPhhRdScxGZc86Ba67xDjIvvRR1NMVPer/7+fO9M8vuu0cdkaQ74giflzFggOZmSLSUnIuIJMmtt8Krr8I993gClqoefBDat4fu3b3URQrOzTd7SdFjj3lZi6SWBx6AmjU9SdfaABIVJeciIknw3HO+uuPFF0OfPlFHk71SpeC112Dnnb0E56+/oo6oeHjtNW+n2aOHTwKV1FOtGjz6KPz4o59dEomCJoRqQqiI7KBRo+D44+HII30V0NKlo44oZ3780dv3tWrlXSoKS9yF0aRJPkm4RQtfFGqnnaKOSLISgs8JGDUKpkyBffaJOiIpCjQhVESkgPz0E3TpAvvtB6+/XrgS3BYt4JlnvEZePZ7zz9KlfoaialWfAKrEPLWZedlRqVLe4rIYj2FKRJSci4jk0cKF0KkTVKwI77/v3TcKmzPPhGuv9UVwXngh6miKno0bff7B77/7arG77hp1RJITtWvDfff5GSVNnJaCpuRcRCQPVq2CE07wlQXffx/q1Ik6ory7/37o0MFroceNizqaoqVvXy+PeOIJXylWCo8ePbwUqVcvzcuQgqXkXEQklzZuhK5dYfJkX3mzefOoI9ox6RNEd9vNyy/+/DPqiIqGoUOhf3+47DJvsSmFS4kS8PTTsHKlJ+giBUXJuYhILoQAV13lo+WPPQYdO0YdUXLUqOGLJi1bBqefDuvXRx1R4TZxIlx0ka/I+t//Rh2N5FXjxnDTTd4i9cMPo45Gigsl5yIiuTBggJco9O7tk8WKkgMO8JaQX33ldeiSN0uWeLeP6tU1AbQo6NvXJ3z36OHlbCL5Tcm5iEgOjRgB11/vI8v33ht1NPmja1e44QY/K/Dcc1FHU/hs3AhnnAF//AFvvQW77BJ1RLKjypTx8pbffoNbbok6GikOlJyLiOTAmDFwzjk+QezFF70etai69144+mjo2RO+/z7qaAqXG2/0PuZPPun946VoaNvWfx8efhjGjo06GinqtAiRFiGKzt9/wy+/QJUq0KBB4WoQLcXK7NnQpo33qR4zxpf3LuqWLYO0NFi3DiZMUAvAnHj5Zf8Ad+WVnsRJ0bJ8udeg16jhvxP6lyW5UWgXITKz48xsupnNMrNtFsA2s73M7FMzm2xmX5hZ7bjb7jezKbHLGQUbuWRrzRr44QcYMsTPl3fs6E1kq1f3YcgmTaBCBWjaFP7v/+COO7x+YNo02LAh6uilmFu61Ff/DAE++KB4JObgv55vvw3//OOLLGmCaPZ++AEuuQTatYOHHoo6GskPVarA44/7wmP9+0cdjeRaCDBzJkyfHnUk25UyI+dmVhKYARwNLADGAd1CCNPi9nkdeC+E8KKZHQlcEEI4x8w6AdcAHYEywJfAkSGEFdkdUyPnSbZpE8ya5esd//RTxtdZs2DzZt+nTBkfemjaFPbf32fZ/PMPTJ3qyfjUqTBnTsaSbKVLw777+n2aNPFL48YaaS+K1qzxIeqZM/1nZuZM/5mqX98v9er51wJc6WftWi/vGDcOPv3UT20XN8OHew11jx4+EVa2tXixn2UIAcaPh513jjoiyU9dusB773kr1X33jToaydbff3ud2ccf+2XePD+9NWRIgYeSm5HzUvkdTC60BmaFEOYAmNkw4GRgWtw+jYH0bqOfA2/Hbf8yhLAR2Ghmk4DjgOEFEXixE4IvdxefgE+Z4sn1unW+T4kSnkg1berL46Un4/XqeVPl7Kxe7eUu6cn61Kk+LDVixLZJe3qynp6416+vpD2VpSfg6cl3fCK+YMHW+9asCSVLbtt0u1atrZP1+OS9Rg1fezsJNm+GCy6Ar7+GYcOKZ2IOfjLrhx98oaIDD4SLL446otSyYYN/ePnzT/9ZUWJe9D3yiK8ceumlnvcl6U+OJMPGjT5RJj0ZHzvW/5hXrgxHHultto47LuootyuVkvM9gPlx1xcAieupTQI6A4OAU4FKZlYjtv02MxsAlAfas3VSL3m1bJkn3vFJ+JQpPtqdbo89PPHu0MG/Nm3qI+LlyuXtmOXLQ8uWfomXWdI+YQK8/rqS9lSyZo2f/YhPvNO/nz9/631r1vT3pn17PxtSv37G16pVfZ9Vq/zxZs3KuMyeDaNHwyuvZLz34OedE0fa0y+77pqr/6K33OJJ+X33efJVnPXr5327L7/cf73btIk6otRxww3w+ec+STgtR2NiUtjtths8+CB07+4djS66KOqIirnZszOS8c8+gxUrfICwdWv4z3/gmGP8+0KUA6RSWcvpwLEhhItj188BWocQrozbZ3fgUWBvYDSeqDcJISw3s5uB04HFwF/A2BDCoEyO0x3oDrDnnnse+Ouvv+bvEyssVq+Gn3/eOgH/6SdYuDBjn6pVM5Lv9K9Nm0K1atHFDRlJe3xpzNSpMHdu5kl7fOKupD1v1q7NfgQ8/u9KjRqecMcn34kJ+I7EMXduRizxl3nzvCwmXfnymY+216/vcyBKltyy6zPPeP1w9+7edUMjY/45vXVr/3WbMMETlOLupZfg3HPh6qth4MCoo5GCtHmzjylMnuz/OjVhugAtX+6fiEeO9IR8zhzfvtdecOyxnowfeWT0uUmC3JS1pFJyfjBwewjh2Nj1vgAhhEy7CZtZReCXEELtTG57FXg5hPBBdscsljXnGzd64pJYkjJrVkZCVbbs1nXh6V93371wZSnxSXt84q6kPWfWrs0YAU8cBc8qAY8f+U7/GtUfyA0bvDFx/Gh7+vdz5mSUYIGvErPPPlCvHh+X7sTx717K0S2X8r8h/1Cqfl39LMRMmeKj5s2a+f/GMmWijig648f76p8HH+z5gX5Eip/p033hrpNO8rkZkk82bvRfuPTR8e++84GXihU9CT/mGL/Ur5/SOUphTc5L4RNCOwC/4xNCzwwhTI3bpyawLISw2cz6AZtCCLfGJpNWDSEsNbNmwKtA81gNepaKdHIegpcQJJak/Pzz1nXhDRpsOxper95Wo4hFTk6T9oYNt52IWtSS9vgEPLMSlMQEPDH5jjoBz6vNm33eREKpzOSfjENnPMs+zOErDqMSq/x3Ya+9Mi+V2Wcf/zBbjIwY4Yswde8OTz0VdTTR+Osvr78vUcJzhlq1oo5IotKvn1dOvPOOJ+mSJPPmZSTjn37qpbRmXjt2zDE+Qt6mTaH6f1wok3MAMzseGAiUBJ4LIfQzszuB8SGEd82sC3AvEPCylstDCOvMrCzwQ+xhVgA9QggTt3e8IpOcL126bYeUKVO87ipd7drbJuH77VfsEotspZf2xJfGTJtW+JP29AQ8sxKUxAS8evXMk+/69f22Iuz33/1vfQiB795dTO3VMzIvl4mfb2Hmcy4yK5WpVw8qVYruCeWjm27yhYqefNInxRUnGzbAUUf5PLNvvtl2aowUL+vXe764bJn/uyjAZlJFy8qVfjouPSGfOdO3166dUarSoYMPEhVShTY5L2iFLjlfvdp/+xOT8EWLMvapVi3zuvAdre0tzv79N+ua9nTpSXviRNR69QomaV+3LvMSlFmzvLQj/ve8WrWsa8CLeAKelZUr4fDD/eX6+ms/VZ2lZcsyL5WZNcuHVOPtskvWde6F+LXetAlOPNE7Vnz+efHqZHPVVd6t4+UtPZBsAAAgAElEQVSX4ayzoo5GUsH333t502WXwaOPRh1NIbFpk09eSU/Gx4zx8pXy5b2YP71UpWHDlC5VyQ0l5zmUssn5hg2eWCWOhsf3/y5b1pO/xER8t92KzA9yyivopD0+AY9PvmfOzDoBT0y+GzQo1Elhfti40U9Hf/yx9y7eoS5bK1dunbDHf5/YKrJataxbQu6yS8r/Hv/zjy9Pv2qV/4/dffeoI8p/L7zg7TV79YIBA6KORlLJ1Vf7h7avv/a19SQTv/0Go0b5H9tPPvGBDvAasfRk/OCDi+xkFiXnORR5ch6C/7AmJuG//JKxHF/JkpnXhe+zT9GuCy/M4pP2xJr2dPFJe3ziXqeOl5pkNgkzMQGvWjUj8U6chFmIT/0VpBB8tOvJJ71+unv3fDzYmjX+M5BYJjN7ttdXpi/UBb5ibmZlMuXL52OAuTd1TjnaXNKUpvus5ovHplFmpwL8fxKCj75t3rz118y25eS27ewz7rddOOyFC2lb+zdGnv4MpdiYb8fK0/1r1PC/KY0aZVwaNvRJc5LvVq70f80VK/q6AEU0v8ydVavgyy8zRsd/+cW37757RjJ+1FHFZtKGkvMciiQ5f+st+PDDjImaK1dm3FanzrZJeKNGqgsvKv79N+ua9qykJ+CZjYArAd9hDz7oa1L06eM11JFZvx5+/TXzUpm5czM+rKegNzmVzrzJRTzD01xCao/3582f7MyBTKAUGxlfsg01S/3jgyMlSmT+NbvbkrVP/PdmXlI1fbr//MR/0Ktde9uEvVEjnyuR4mdnCpsPPoBOneCOO+DWW6OOJgKbN8OPP2Yk499845UA5cpBu3YZCXnjxsXyZ0/JeQ5FkpxfcQUMHerJd3wi3qSJL6AixU980j5/Puy5Z0YiXr16sfwjVhBef91Xv+za1dcyKlEi6oiysGmTl8Qktn9MIbcMqc/dQ+vz+OVT6XnC/O3fIVmySmCTmBSv31iCDseVYsIE+PZbo3nzgnt6ebJunSfov/yy7SV+MKhixW1H2hs18g//GhDKs27d4M03fdGu/faLOpoCsGDB1qUqS5b49ubNM5Lxtm31M4WS8xyLJDlft857KivhEonMt996e9xWrfz/iv5v7JjNm71uf+RInyB66KFRR5Q8l18Ojz8Or77qiVehFYI3D5g+fduk/bffMvYrUQLq1t02aW/UyFf01f+ubP31lyfl++3nixin7If+vFq92p9Y+uj41Fi361133bpUZZddoo0zBSk5z6HIa85FpMDNmuUtE6tX9wYBqg5Kjn/+8RVEV6zw3t+1t1kervBJX5r9+uu9BKrI+vdfmDHDE/X45H36dG/Fmq569W3LYxo18jlQpUpFF3+KSZ84/MQT0KNH1NHsoM2bfRnU9GT8q6+8zK5MGW9xlZ6Q77+/Prhth5LzHFJyLlK8LFnizQD++ccT8/r1o46oaPn5ZzjoIM/XRo8u3Gckvv/ec4/DD/dpQsUy99y82UfVE0fap0+HP/7I2K90af9lShxpb9iwWJZrhgBHH+298H/+2cv7C5VFizJKVUaNymgRu//+Gcn4YYd5LbnkmJLzHFJyLlJ8rF3rZ1vHj/fSi4MPjjqioumdd+CUU3zk8NlnC+dg2h9/eHe3MmVg3DidXcnUP/9kXiIza5b3J023666Zl8jUqVMEaz4yzJ6dkcu+9VaK/x6sWeMj4umj4z/95Ntr1dq6VKU49EvNR7lJzovjWICIFDObN8P553vzgNdfV2Ken04+2TtV3HmnJ7iXXx51RLmzfj106eK557ffKjHPUtWqfprkoIO23r5hg3cYSkzahw3benXdcuVg3323Tdr33TflWobmRb16cPvtcOONPkG0c+eoI4oTgneLGznSk/HRozPmwx12GNx/vyfkzZoV6Q9QqUwj5xo5Fyny+vaF++7zuuHrr486mqJv82YfPf/wQ/j0Uy8NKSx69vS+96+95t18JElCgMWLt61r/+UXT+bjc5G99tq2rr1RIx+FT+kh6K1t3OjzMBYt8vKWSBfq/vNP76aSPjqeXpbUuHHG6Pjhh/saC5IvVNaSQ0rORYq+wYPh0ks96XrssUL1v71QW77cB1WXLfMVROvUiTqi7Xv6aV+IqndvHzyUArJ2rS+0Fl/Tnv79v/9m7Fe5cuZ17fXr+6hvqkhfIGv9eiaM20TrIyty8ZmrearfUj+zkHhZvz7z7XndL3Hf336DSZM8tho1vCD+mGP8a1GYuV1IKDnPISXnIkXbhx/CiSfCscd6LXSxnNQXoV9+8ZHDhg39zHkqzx8bM8bXSWnf3heT0QLMKSAE+P33zHu2//57xn4lS3rHmPSEvUED/2UviMQ3q0ucG3iA/tzAF7SjHaOT9/qY+WTcnXbyr1ldataEDh08IW/RQqUqEVFynkNKzkWKrokTvXyyQQNPDLWKeTTefdfr0M87D55/PjXPXCxcCGlp/uFh3DjvGCgpbuXKjPaP8ZcZM7a/om6JEjlLatMvO7jf6lCOpvedTelSm5l01/8oW7FUco6rT5CFiiaEikixtmCBL6NdtSq8954S8yiddJIvZ37bbdCyJVx1VdQRbW3dOp8AumKFz49TYl5IVKrkM44PPHDr7ekr6oaQdVJbwCPH5YGnDvCB67t/PYe77y7Qw0shpORcRIqUFSs8MV+50ruzqPtX9P7zH/jxR7j2Wm8AccQRUUeU4corvaRl+HBvfSeFXMmSPqE0xRx9NJx7rs9lOOMM/axJ9lR4JCJFxoYN3mFj2jR44w39A0wVJUrAiy96idHpp2+9WnyUnnrKJ4H27etxieSnhx7ys3mXXOID/CJZUXIuIkVCCHDZZV6a8OSTPlIlqaNyZXj7bS8HPvVUX/ckSt9846PmHTvCXXdFG4sUDzVrwsCBvvrsY49FHY2kMiXnIlIk3H8/PPMM3HwzXHRR1NFIZho2hFdf9RKX7t23bm1dkH7/3evM99wTXnlF8+qk4Jx5Jhx3HNx0U+qcQZLUo+RcRAq9YcO8NOHMMzUKmuo6dfLVQ19+GQYNKvjjr1vnqzWuXOntNatVK/gYpPgygyee8A+mPXtG9wFVUpuScxEp1L7+2tv0HXYYPPdcarbqk63ddJOXtlx/PXz2WcEdNwS4/HIvKxgyBJo0Kbhji6SrWxf69fN++q+9FnU0koqUnItIoTVjhvfQ3ntvr2cuUybqiCQn0ieINmzoE3jnzSuY4z75JDz7rJc+nXZawRxTJDNXXgmtWnlr0aVLo45GUo2ScxEplBYvhuOP93rhDz5Qf+rCplIl/0C1caOPoq9enb/H++orT4Q6dfK+6yJRKlnSOwUtW+ZnkETiKTkXkUJnzRofMf/9d1+Bcp99oo5I8qJBAxg6FCZN8vZy+VV/u2CBTwDde2+vddcEUEkFBxwAvXvDCy/Ap59GHY2kEiXnIlKobN7si3l8950nWm3aRB2R7IiOHeHuu72Ly3//m/zHX7vWS1hWr/aR+qpVk38Mkby65RaoXx8uvTT/zx5J4aHkXEQKlT59YMQI6N/fu25I4de3r49s33ADfPJJ8h43vSPGuHHw0kvQuHHyHlskGcqVg8GDYfZslVtJBiXnIlJoPPEEPPigd9zo1SvqaCRZzOD55z15PuMMmDs3OY/72GNeMnDrrXDKKcl5TJFka9/e12Z46CFfA0DEQhKL/MxsF+AcoB5wSwhhiZm1BRaGEJL05zZ50tLSwvjx46MOQ0Ry4IMP4MQTfRLoW29BqVJRRyTJNns2pKXBXnvBt99C+fJ5f6zRo6FDBy+beftt7xAjkqr+/hv22w9q1/aSPf19K3rMbEIIIS0n+ybtz5WZHQhMB84CLgIqx246GuiXrOOISPHz44/ecq95c59AqH9cRVO9ev7+Tp7sI4l5HTuaP9/LZOrV83IWJeaS6qpVg0cegQkTolmcS1JLMv9k9QcGhRBaAOvito8E2ibxOIXa4MHeleDvv6OORKRwmD/f299Vrw7vvQcVK0YdkeSn446De+/1VV/798/9/des8daMa9f6iHmVKsmPUSQ/dOniZwdvuQXmzIk6GolSMpPzA4EXM9m+CNgliccp1P7802sr99sPhg/X0r0i2Vm+3MtY/v3Xy1p22y3qiKQg9O7tZ0r69IFRo3J+vxCgRw8ffXz5ZWjUKP9iFEk2M58nUbKk/xwrPyi+kpmcrwGqZbK9EfBXEo9TqN1yi3cOqF3bJz6ddBL89lvUUYmkng0b4PTT4Zdf4I03oGnTqCOSgmIGzz0HTZr438mcjiI+8ggMGQK33+5/W0UKmzp14L77/EPpyy9HHY1EJWkTQs1sMLArcDqwBGgGBOAd4LMQQsr1VohyQujGjfDww56slygB/fp5BwotjiGF3fr1sGqVj3avWrX194lfs7ttyRJf1v255+CCC6J+VhKFOXN8gmjt2jBmDFSokPW+n38ORx8NJ5wAb76pOnMpvDZvhkMPhRkz4OefoVatqCOSZMjNhNBkJueVgQ/wpLwC8AdezvINcHwI4d+kHCiJUqFby7x53of3o4+gdWtfzrdZs0hDkmIgBFi3LndJc06T7I0bcx5HqVJeQ16xoide8V8rVoRjjvGJgVJ8jRrldehdungdutm2+/z6qyfxNWvC999D5crb7iNSmEydCi1aeHmXRtCLhkiS87iDHwm0xEtmfggh5HhJCTM7DhgElASeCSHcl3D7XsBzQC1gGXB2CGFB7LYHgE6x444Crg7beXKpkJyDJ0rDhsHVV/tE0euv97685cpFHZlELQSf2JbX0efsbtu0Kedx7LTT1klzZol04rac3LbTTvn32knR8eCDXod+331w441b37ZmjY8yzpoFY8dCw4bRxCiSbLfdBnfe6YN3xx4bdTSyowo8OTez0sDXwLkhhOl5fIySwAy89eICYBzQLYQwLW6f14H3Qggvxj4EXBBCOMfMDgEeBA6P7fo10DeE8EV2x0yV5DzdsmWemD//vLcAe+op79MrRd+GDX7W5Pnn4Z9/tk6kN2/O+eOUKZOcpDlxW+nS+ffcRbYnBDjzTHjtNZ8YfNxxGdvPPRdeeQXefddLWkSKinXrvH3smjUwZYo6VRV2uUnOk9ItOISwwcz2xmvM86o1MCuEMAfAzIYBJwPT4vZpDKTXrn8OvJ0eAlAW2AkwoDTw5w7EEonq1b2+9uyz4dJL4aij4PzzvZ1YjRpRRyf5IQRfUKdPH5g5E1q18vKmvCTUFSqo/7cUTWbwzDNef9utm0+qr18fBg70U/533aXEXIqeMmV80Oaww/xs+oABUUckBSWZ/8pfBC4Bbsjj/fcA5sddXwAclLDPJKAzXvpyKlDJzGqEEMaY2ed420YDHg0h/JzHOCJ35JG+CMddd/np3Pff939C3bplXm8phdO338INN/jX/faD//3P+3nrPRbZVoUK/kE2LQ1OOQXuucd/f049FW66KeroRPLHoYd6W8VBgzwHaNUq6oikICRzPnsFoLuZTTSzZ83s4fhLDu6fWUqSOBJ/PdDOzH4E2gG/AxvNrD6wH1AbT/KPNLPDyYSZdTez8WY2fvHixTl9bgWuXDn/5zNhAuy9N5x1lvd7njcv6shkR82YAZ07Q9u23o1i8GD/MHbCCUrMRbKz995e2vLzz3DyyV5f/uKL6swiRdt998Guu8LFF3sJpBR9yfyTth/wA/A3sA+wf9wlJx2KFwB14q7XBhbG7xBCWBhCOC22CunNsW3L8VH070IIq0IIq4APgTaZHSSEMDiEkBZCSKtVCPoTNWvmI6sPPwxff+19fx96KHcdMSQ1/PWXt8ts3Bg+/tgn+sya5SvGqhxFJGeOOspHEffe21cArVQp6ohE8leVKr440eTJ/v9fir6kd2vJKzMrhU8I7YCPiI8DzgwhTI3bpyawLISw2cz6AZtCCLea2Rl4Sc1x+Aj8R8DAEML/sjtmqk0I3Z758+Gyy3wJ8wMP9Fq0Fi2ijkq2599/4b//hfvv94k9l17q9YO7aN1ckTwLQWeapHjp3NknRE+eDA0aRB2N5FZuJoQm/WSgmZU1s6Zm1sTMyub0fiGEjcAVwEjgZ2B4CGGqmd1pZulrvR0BTDezGXgP9X6x7SOA2cBPeF36pO0l5oVRnTrekWD4cFiwwGvPbrgBVq+OOjLJzMaNPomtQQNfbOroo7137WOPKTEX2VFKzKW4eeQRnyR66aX+4VSKrmQuQlQauAdPsNO7pqwDHgFuDiGkXKVUYRs5j/f3397v9+mn/fTuk0/6gi0SvRB8dOPGGz0ZP/hgn9jbtm3UkYmISGE2eLAn588+CxdeGHU0khtRjZzfD5wN9AD2BRoAPYFzgHuTeBwBqlXzX9Ivv/SFXI49Fs45B1J4jmuxMH68d9s54QRfxv6NN+Cbb5SYi4jIjrv4Ym+teN118McfUUcj+SWZyfmZwEUhhBdDCLNjlxeAi4GzkngciXP44TBxotcwv/aat+QbMkSnvAra3Lm+SEqrVj5a/uij/vW003T6XUREkqNECT9jvnq1ryouRVMyk/MqeN13otlA1SQeRxKULQt33AE//uitxc47z0tcZmf2bkhSLV0K117rr/vbb8N//uMdWC6/XKtqiohI8jVs6POYhg/39TGk6Elmcj4JuCqT7VcDE5N4HMlCkybw1Vfw+OPw/few//7wwAPqi5of1qzx17ZePW/rdu65vsLnXXdB5cpRRyciIkVZ797QtKl3cFuxIupoJNmSmZz3Bs4zsxlm9qKZvWBm0/E69LyuGiq5VKIE9Ozpi3Qce6xPSmzVype7lh23eTO89JKPXNx4o6/eNmmSd2XZY4+ooxMRkeJgp538/87vv8PNN0cdjSRb0pLzEMJooCHwOlARqBz7vmEI4etkHUdyZo89fKnrN9/0SaJt2kCvXrBqVdSRFV6jRnl/+XPPhZ13hs8+857zTXOyxJaIiEgSHXQQXHGFt+cdMybqaCSZUmYRoigU5laKubF8OfTtC088AXvu6V+PPz7qqAqPSZN8lHzkSKhbF+65B844Q0uGi4hItFau9JLWypXhhx98RF1SUyStFM3sCjM7O5PtZ5vZZck6juRelSpeh/7111CxInTqBN26wZ9/Rh1Zaps/H84/31dhHTsWBgyAX37x106JuYiIRK1SJR9wmzrVV6GWoiGZKcY1wPxMts8DeiXxOJJHbdv6J+s77vByl/32g+eeU9vFRMuXQ58+sO++MGwYXH+9d77p1ctXZxMREUkVnTr52dy77/b5ZlL4JTM5rw38msn2BbHbJAWUKeM90SdN8lrpiy7yRXNmzIg6suitX++dV+rV8xGI00+H6dO9K0u1alFHJyIikrlBg6BCBeje3RsXSOGWzOT8D6B5JttbAkuSeBxJgkaN4IsvfJXRH3+EZs2gXz9PUIubEDIWcLrmGmje3M8wDBkCe+0VdXQiIiLZ22UXeOghL199+umoo5Edlczk/FXgYTM72sxKxy7HAAOBV5J4HEmSEiXgkkv8NNhJJ/kCOgceCN99F3VkBWf0aJ/x3rWrjzp89JF3ZWnRIurIREREcu788/1MeO/e3mJRCq9kJue3Ad8AI4HVsctHwLfALUk8jiTZbrv5SmPvvgv//AOHHAJXXlm0FzaYNs0/kLRrBwsXwvPP+xmEY48Fs6ijExERyR0zeOopPwN+5ZVRRyM7Ipl9zjeEELoB+wJnAmcBB4QQuoYQtEZlIXDiiZ60pvdNbdzYE/aiZNEir8nbf3/48ku4915f2fP886FkyaijExERybv69eH22zPWOZHCaYeTczPrYGb/l349hDALqA8MAX40s4/MrOqOHkcKRqVK8PDDvqBB9epw8snQpYsntYXZypVw223+h+uFF3xUYfZs78pSrlzU0YmIiCTHtdf63KkrrvCz4VL4JGPkvA9x3VjMrDXQD3gJ6A0cAGhx2ULmoINgwgRfcOe993yy5ODBhW8W+IYN8OST0KAB3HknnHCC19gPHAg1a0YdnYiISHKVLg3PPONrmfTpE3U0khfJSM73B76Mu3468G0I4ZIQwgDgKuCkJBxHCljp0r6y6E8/QcuWcOmlcMQRvhBPqgsB3n7by1d69vSe5d99511Z6tWLOjoREZH8c+CBvjbHU0954wMpXJKRnFcF/oq73hafCJpuHLBHEo4jEWnQAD791BcsmjIFDjjAFzJaty7qyDL33Xdw+OFw6qk+Qeadd7y+/KCDoo5MRESkYNxxB9StCxdfDMuWRR2N5EYykvNFQD0AMysDtADGxN1eCUjRNE5yygwuuMBHzTt39gknLVp4T9VUMXOmLxx08MEwa5aPGPz0k3dlUQcWEREpTipU8PU6fv3VGz6sXh11RJJTyUjOPwQeMLMjgfuBf4Gv4m5vBsxKwnEkBey8M7z6Knzwgf+iH3aYl40sXx5dTIsX+wTPxo3hww99tGDmTO/KUqpUdHGJiIhE6bDDYOhQP6PcpYvPw5LUl4zk/FZgLfAJcCFwSQghfp3JC4FRSTiOpJCOHb3E5dprfaLofvsVfNum1at9wmq9evDEE37qbtYsuPVWqFixYGMRERFJRaed5o0RPvzQz4AXtsYOxdEOJ+chhCUhhMOBakC1EMJbCbucDty5o8eR1FOxoi8X/P33vnRw585e571gQf4ed9Mmr39v0ABuvhk6dPAPCk88Abvumr/HFhERKWwuuQT69YNXXvFBtRCijkiyk8xFiJaHEDZlsn1Zwki6FDFpaTB2LDzwAIwc6eUljz2W/E/nIXg5TfPmcNFFsOee8NVXvthCo0bJPZaIiEhR0rcvXHMNDBrkZ50ldSUtOZfirXRpuOEGn4DZpo0vfnDooT6inQwTJsBRR0GnTrBmDbz+Onz7rR9DREREsmfmZ7vPPhv+8x9vmiCpScm5JFW9ej56PmQIzJjh/dFvuQXWrs3b482bB2ed5aPzkyfDI4/AtGk+sUUdWERERHKuRAkvC+3UyZs5jBgRdUSSGSXnknRmcM453naxa1e4+27vjf7ll9u/b7ply+D666FhQ59oetNNPtnziitgp53yL3YREZGirHRpGD4cDjnEB78++yzqiCSRknPJNzVr+gj6xx97+6YjjvBJKX//nfV91q6F/v19BH7AAD/9NnOmT2SpUqXAQhcRESmyypeH//3PV88++WQYPz7qiCSehWI8ZTctLS2M109kgVi92hcuGjDAk/ZBg+D//i+jNGXzZu/FevPNvmBCx45w//2w//6Rhi0pYsOGDSxYsIC1ea2PkjwpW7YstWvXpnTp0lGHIiL5YOFCaNsWVq3yRQUbNow6oqLLzCaEENJytK+ScyXnBenHH330fMIEr3l7/HEfGb/hBr+tZUvv+tKhQ9SRSiqZO3culSpVokaNGpgmGxSIEAJLly5l5cqV7L333lGHIyL5ZOZMb65Qtix88w3Urh11REVTbpJzlbVIgWrRwlcqGzAAPv8c6tf3LizLlnn/1XHjlJjLttauXavEvICZGTVq1NDZCpEirkED+OgjLzk99lhYujTqiETJuRS4UqWgVy+YOtX7lT/0kE8ePfNMn0kukhkl5gVPr7lI8dCiBbz7LsyeDSecAP/+G3VExZtSIYlM3bq+que11/rpNJFUtXTpUpo3b07z5s3Zdddd2WOPPbZcX78+Z2usXXDBBUyfPj1Xx33//fc58MADady4MY0aNeLGG2/kk08+4bDDDttqvw0bNrDzzjvz119/5erxRUTSHXEEDBvmiwp27gw5/NMm+SClknMzO87MppvZLDPrk8nte5nZp2Y22cy+MLPase3tzWxi3GWtmZ1S8M9ARIqiGjVqMHHiRCZOnEiPHj3o1avXlus7xXp7hhDYnM2yuM8//zwNczHbatKkSVxzzTUMHTqUadOmMWXKFOrWrUv79u2ZPXs2CxYs2LLvyJEjadGiBTvvvHPen6SIFHunnAKDB/t6Jeefn/yVviVnUiY5N7OSwGNAR6Ax0M3MGifs1h8YEkJoBtwJ3AsQQvg8hNA8hNAcOBJYDXxcYMGLSLE0a9YsmjZtSo8ePWjZsiWLFi2ie/fupKWl0aRJE+68884t+x566KFMnDiRjRs3UrVqVfr06cMBBxzAwQcfnOmI9/33388tt9zCvvvuC0CpUqXo2bMnJUuWpEuXLrz22mtb9h02bBjdunXL/ycsIkXeRRfBffd5B7VrroFi3DckMqWiDiBOa2BWCGEOgJkNA04GpsXt0xjoFfv+c+DtTB6nC/BhCGF1PsYqIlG55hqYODG5j9m8OQwcmKe7Tps2jeeff54nn3wSgPvuu4/q1auzceNG2rdvT5cuXWjceOtxhuXLl9OuXTvuu+8+rr32Wp577jn69Nn6ZOGUKVO4+eabMz1mt27duOqqq7juuutYu3YtI0eO5LHHHstT/CIiiXr3hr/+8uYNtWr5St9ScFJm5BzYA5gfd31BbFu8SUDn2PenApXMrEbCPl2BofkSoYhIgnr16tGqVast14cOHUrLli1p2bIlP//8M9OmTdvmPuXKlaNjx44AHHjggcybNy9Xxzz44INZunQps2fP5r333uOwww6jilbpEpEkMYMHH4Rzz4Vbb/X5YVJwUmnkPLO2AIknU64HHjWz84HRwO/Axi0PYLYbsD8wMsuDmHUHugPsueeeOxaxiBS8PI5w55cKFSps+X7mzJkMGjSIsWPHUrVqVc4+++xMWxGm16kDlCxZko0bN26zT5MmTZgwYQJNmjTJ9LhnnHEGw4YN48cff1RJi4gkXYkS8Mwz3ur48suhRg1fPFDyXyqNnC8A6sRdrw0sjN8hhLAwhHBaCKEFcHNs2/K4Xf4PeCuEsCGrg4QQBocQ0kIIabVq1Upe9CJS7K1YsYJKlSpRuXJlFi1axMiRWY4TbFfv3r25++67mTVrFgCbNm1iwIABW27v1q0bQ4YMYfTo0Zxwwgk7HLuISKLSpWH4cNqizhIAACAASURBVF9F9OyzYdSoqCMqHlJp5Hwc0MDM9sZHxLsCZ8bvYGY1gWUhhM1AX+C5hMfoFtsuIlLgWrZsSePGjWnatCn77LMPbdu2zfNjtWjRgv79+/N///d/rFmzBjPj5JNP3nJ7s2bNKF26NMcccwzlypVLRvgiItsoVw7+9z9o1w5OPdUXEIyr5JN8YCGFpuGa2fHAQKAk8FwIoZ+Z3QmMDyG8a2Zd8A4tAS9ruTyEsC5237rAN0CdWPK+XWlpaWH8+PHJfyIiklQ///wz++23X9RhFEt67UUEYNEiH0FfsQK+/hoaNYo6osLFzCaEENJysm8qjZwTQvgA+CBh261x348ARmRx33lsO4FURERERHbQbrvBxx/DoYfCMcfAN99AnTrbv5/kXirVnIuIiIhIiqpfHz76CJYvh2OPhaVLo46oaFJyLiIiIiI50rw5vPsuzJkDxx8Pq1ZFHVHRo+RcRERERHKsXTt47TUYPx46d4b166OOqGhRci4iIiIiuXLyyd4H/eOPfbGiTZuijqjoSKkJoSIiIiJSOFxwASxZAr17Q82a8Mgjvrqo7BiNnIuIbMcRRxyxzYJCAwcO5LLLLsv2fhUrVgRg4cKFdOnSJcvH3l5L14EDB7J69epcROz69+9Po0aNaNq0KQcccABDhgzh9ttvp2/frZeDmDhxotolikie3HCDXx57DO68M+poigYl5yIi29GtWzeGDRu21bZhw4bRrVu3HN1/9913Z8SITLvA5khekvMnn3ySUaNGMXbsWKZMmcLo0aMJIdCtWzdee+21rfYdNmwYZ555ZhaPJCKSvfvvh/PPh9tvh8cfjzqawk/JuYjIdnTp0oX33nuPdevWATBv3jwWLlzIoYceyqpVq+jQoQMtW7Zk//3355133tnm/vPmzaNp06YArFmzhq5du9KsWTPOOOMM1qxZs2W/nj17kpaWRpMmTbjtttsAePjhh1m4cCHt27enffv2AHz88cccfPDBtGzZktNPP51VmbRLuOeee3j88cepXLkyAFWqVOG8886jYcOGVK1ale+//37LvsOHD6dr165JerVEpLgxg6efhpNOgiuugISxDMkl1ZyLSKFyzTUwcWJyH7N5cxg4MOvba9SoQevWrfnoo484+eSTGTZsGGeccQZmRtmyZXnrrbeoXLkyS5YsoU2bNpx00klYFoWXTzzxBOXLl2fy5MlMnjyZli1bbrmtX79+VK9enU2bNtGhQwcmT57MVVddxYABA/j888+pWbMmS5Ys4e677+aTTz6hQoUK3H///QwYMIBbb92yXhsrV65k5cqV1KtXL9MY0s8EHHTQQXz33XfUqFGDBg0a5O3FExEBSpXypPy443yCaPXqvliR5J5GzkVEciC+tCW+pCWEwE033USzZs046qij+P333/nzzz+zfJzRo0dz9tlnA9CsWTOaNWu25bbhw4fTsmVLWrRowdSpU5k2bdo29//uu++YNm0abdu2pXnz5rz44ov8+uuvW+0TQsjywwFA165dGTFiBJs3b85VeY6ISHbKlfMe6I0bw6mnQtwJOskFjZyLSKGS3Qh3fjrllFO49tpr+eGHH1izZs2WEe9XXnmFxYsXM2HCBEqXLk3dunVZu3Ztto+VWeI8d+5c+vfvz7hx46hWrRrnn39+po8TQuDoo49m6NChWT5+5cqVqVChAnPmzGGfffbZ5vY6depQt25dvvzyS9544w3GjBmzvacvIpIjVar4KqKHHuqLFH31lSfrknMaORcRyYGKFStyxBFHcOGFF2410rx8+XJ23nlnSpcuzeeff77NKHaiww8/nFdeeQWAKVOmMHnyZABWrFhBhQoVqFKlCn/++ScffvjhlvtUqlSJlStXAtCmTRu++eYbZs2aBcDq1auZMWPGNsfp27cvl19+OStWrNjy+IMHD95ye7du3ejVqxf16tWjdu3aeXlJREQyteuu3v98p53g2GPht9+ijqhwUXIuIpJD3bp1Y9KkSVtNnjzrrLMYP348aWlpvPLKKzRq1Cjbx+jZsyerVq2iWbNmPPDAA7Ru3RqAAw44gBYtWtCkSRMuvPBC2rZtu+U+3bt3p2PHjrRv355atWrxwgsv0K1bN5o1a0abNm345ZdfMj1O+/btadWqFU2bNqVdu3aUL19+y+2nn346U6dO1URQEckX++zjI+grV3rt+ZIlUUdUeFgIIeoYIpOWlha2119YRKL3888/qw93RPTai8iO+OorT8733x8+/RQqVYo6omiY2YQQQlpO9tXIuYiIiIjki8MOg+HD4Ycf4LTTINaRVrKh5FxERERE8s2JJ8Kzz8Inn8A558CmTVFHlNrUrUVERERE8tV553nd+fXXQ40avpJoNh1fizUl5yJSKGyvd7ckX3GekyQiyXfddbB4Mdx/P9SqBXfeGXVEqUnJuYikvLJly7J06VJq1KihBL2AhBBYunQpZcuWjToUESlC7r3XE/S77oKaNeGqq6KOKPUoOReRlFe7dm0WLFjA4sWLow6lWClbtqx6oItIUpnBU0/BsmVw9dWeoJ95ZtRRpRYl5yKS8kqXLs3ee+8ddRgiIpIEpUrB0KFw3HFei169un8vTt1aRERERKRAlS0L77wDTZtC584wZkzUEaUOJeciIiIiUuCqVPFVRHffHTp14v/bu/dwKet67+PvbwsENDwh2lZEaGMlpxBW5PZYSoq581BpYB7KA88TmafMqF2atjVNH9u6tdyalqmFhak8aqGkmWWPnEQR2RQZyUJTIMEjKPp9/phh7SWuBYOsWXOz5v26Li5m7vs3M59xRvhwr9/9u5k7t9aJisFyLkmSpJrYYQe4557SkfSDDoK//a3WiWrPci5JkqSa6d8fpkyBl1+GAw8sreZSzyznkiRJqqkhQ+DOO+Gpp+Dgg+HFF2udqHYs55IkSaq5vfaCSZNg9mw4/HBYtarWiWrDci5JkqRCOOQQ+NGP4L774LOfhTfeqHWijmc5lyRJUmEceyxcdhnceiuMHw+ZtU7UsbwIkSRJkgrljDNKJ4Z+5zvQuzf8+7/XOlHHsZxLkiSpcC64AJYuLf3euzecdlqtE3UMy7kkSZIKJwJ+8ANYtgxOPx169YJjjql1quor1JzziBgdEfMjYkFETGhl/y4R8ZuIeCwifhsRfVrs6xsR90TEvIh4IiL6dWR2SZIkta+GBrj5ZvjoR+Hzn4e77651ouorTDmPiAbgKuBgYCAwNiIGrjXsUuAnmTkUOB/4Tot9PwEuyczdgJHAc9VPLUmSpGrq3h1uvx2GDoVPfxoeeqjWiaqrMOWcUqFekJlPZuZrwETgsLXGDAR+U759/5r95RLfJTPvBcjMlzLzlY6JLUmSpGrackv41a+gT5/ScouPP17rRNVTpHK+E7Coxf2m8raWHgU+Vb59BNAzInoB7wOWR8QvI+KRiLikfCRekiRJncD228M998Dmm8NBB8HChbVOVB1FKufRyra1V7Y8C9gvIh4B9gMWA6spndi6T3n/h4D3Ap9r9UUixkXEjIiYsWTJknaKLkmSpGrr1w+mTIFXX4WPfQye64STmItUzpuAnVvc7wM83XJAZj6dmZ/MzN2BfytvW1F+7CPlKTGrgduB4a29SGZek5mNmdnYu3fvarwPSZIkVcngwXDnnbB4MYweDS+8UOtE7atI5Xw6sGtE9I+IzYAxwOSWAyJiu4hYk/lrwPUtHrtNRKxp2/sDT3RAZkmSJHWwPfcsXUF0zhw47DBYubLWidpPYcp5+Yj3KcAUYB7w88ycGxHnR8Sh5WEfAeZHxJ+AHYALyo99g9KUlt9ExBxKU2Su7eC3IEmSpA5y8MHw4x/Db38LRx8Nq1fXOlH7iMy1p3XXj8bGxpwxY0atY0iSJOkduvzy0kWKTjwRrr22dPGioomImZnZWMlYrxAqSZKkTdZpp8GSJXDBBaUVXS68sNaJNo7lXJIkSZu0b38bli6F73wHeveGM86odaJ3znIuSZKkTVoEXHUVLFsGZ54JvXrBccfVOtU7YzmXJEnSJq+hAW66CZ5/Hk44AbbdFv71X2udasMVZrUWSZIkaWN06wa33QbDhsGRR8Lvf1/rRBvOci5JkqROo2dP+NWvoG/f0pHzxx6rdaINYzmXJElSp9K7N9xzD7z73XDQQfDkk7VOVDnLuSRJkjqdXXaBKVNg1So48EB49tlaJ6qM5VySJEmd0qBBcPfd8MwzMHo0rFhR60TrZzmXJElSp7XHHnDrrfD44zBuXK3TrJ9LKUqSJKlTGz0afvELGDKk1knWz3IuSZKkTu/ww2udoDJOa5EkSZIKwnIuSZIkFYTlXJIkSSoIy7kkSZJUEJZzSZIkqSAs55IkSVJBWM4lSZKkgojMrHWGmomIJcDfavDS2wFLa/C6Kj6/G1oXvx9qi98NtcXvRjHskpm9KxlY1+W8ViJiRmY21jqHisfvhtbF74fa4ndDbfG7selxWoskSZJUEJZzSZIkqSAs57VxTa0DqLD8bmhd/H6oLX431Ba/G5sY55xLkiRJBeGRc0mSJKkgLOcdLCJGR8T8iFgQERNqnUfFEBE7R8T9ETEvIuZGxGm1zqRiiYiGiHgkIu6sdRYVS0RsHRGTIuK/y3+G/EutM6kYIuKM8t8pj0fEzyKie60zaf0s5x0oIhqAq4CDgYHA2IgYWNtUKojVwJczczdgD+CLfje0ltOAebUOoUK6HPh1Zn4A+CB+TwRExE7AqUBjZg4GGoAxtU2lSljOO9ZIYEFmPpmZrwETgcNqnEkFkJnPZOas8u0XKf3lulNtU6koIqIPcAjww1pnUbFExJbAvsB1AJn5WmYur20qFUgXoEdEdAE2B56ucR5VwHLesXYCFrW434QFTGuJiH7A7sDDtU2iAvkP4GzgzVoHUeG8F1gC/Kg87emHEbFFrUOp9jJzMXAp8BTwDLAiM++pbSpVwnLesaKVbS6Xo2YR8W7gVuD0zHyh1nlUexHxr8BzmTmz1llUSF2A4cAPMnN34GXA85lERGxD6afz/YEdgS0i4pjaplIlLOcdqwnYucX9PvgjJpVFRFdKxfzmzPxlrfOoMPYCDo2IhZSmwu0fETfVNpIKpAloysw1P2mbRKmsS6OAv2bmksx8HfglsGeNM6kClvOONR3YNSL6R8RmlE7MmFzjTCqAiAhKc0bnZeZltc6j4sjMr2Vmn8zsR+nPjPsy06NfAiAz/w4sioj3lzcdADxRw0gqjqeAPSJi8/LfMQfgycKbhC61DlBPMnN1RJwCTKF01vT1mTm3xrFUDHsBxwJzImJ2edvXM/PuGmaStGn4EnBz+aDPk8Dna5xHBZCZD0fEJGAWpRXBHsGrhW4SvEKoJEmSVBBOa5EkSZIKwnIuSZIkFYTlXJIkSSoIy7kkSZJUEJZzSZIkqSAs55IkSVJBWM4lSZKkgrCcS5IkSQVhOZckSZIKwnIuSZIkFYTlXJIkSSoIy7kkSZJUEJZzSZIkqSAs55IkSVJBWM4lSZKkgrCcS5IkSQVhOZckSZIKwnIuSZIkFYTlXJIkSSoIy7kkSZJUEJZzSZIkqSAs55IkSVJBWM4lSZKkguhS6wC1tN1222W/fv1qHUOSJEmd2MyZM5dmZu9KxtZ1Oe/Xrx8zZsyodQxJkiR1YhHxt0rHOq1FkiRJKgjLuSRJklQQlnNJkiSpIOp6zrkkqWO8/vrrNDU1sXLlylpHkdpF9+7d6dOnD127dq11FHUylnNJUtU1NTXRs2dP+vXrR0TUOo60UTKTZcuW0dTURP/+/WsdR52M01okSVW3cuVKevXqZTFXpxAR9OrVy58EqSos55KkDmExV2fi91nV4rQWSVKnt2zZMg444AAA/v73v9PQ0EDv3qXrgUybNo3NNtusoue5/vrr+fjHP8573vOet+3LTC655BKuu+46unbtSpcuXfjKV77CvHnziAi+/e1vN4+dMWMGJ5xwAo899lhFr7v33ntz3nnnNb8HgEsvvZSnnnqKK664otXHrF69mu22247ly5ezaNEizjrrLG655ZZWn/vKK69k2LBhbb7+ZZddxvjx4+nevTsABx10EJMmTaJnz54V5V+XH//4x1x66aVkJgAnnXQSPXv25IEHHuDGG29sHvfss88yZMgQFi9e/JZ53n/4wx8488wzWbVqFatWreLoo4/mm9/85kbn0lv1m3BXrSO0i4UXHVLrCOtlOZckdbj2/ot+fX/h9urVi9mzZwPwrW99i3e/+92cddZZG/w6119/PcOHD2+1nF911VXcf//9zJgxg549e7J8+XImT57M2LFjOeKII95SzidOnMjYsWMrft2xY8cyceLEt5TziRMn8p//+Z8VPX7nnXdutZhX6rLLLuOEE05oLudTpkx5x8/V0p133smVV17J1KlTec973sOrr77KzTffzKc+9SkmTJjAypUrm1/zF7/4BUccccTbTsA8/vjjuf322xk8eDBvvPEG8+fP3+hcb7zxBg0NDRv9PNI74bQWSVJdu+GGGxg5ciTDhg1j/PjxvPnmm6xevZpjjz2WIUOGMHjwYK644gpuueUWZs+ezWc+8xmGDRvGa6+99pbnufDCC7n66qubjyZvvfXWHHfccQwaNIju3bszc+ZMoHSE/Re/+AVjxoypOOORRx7J5MmTef311wFYsGABy5YtY4899uCFF15g//33Z/jw4QwdOpQ777zzbY9fsGBB85HxV155hSOPPJKhQ4cyZsyYt8ybHjduHI2NjQwaNIjzzz8fgO9973s899xz7LPPPowaNQqAPn36sHz5cgC++93vMnjwYAYPHtz8j4UFCxYwePBgTjzxRAYNGsTBBx/c6vzsCy+8kMsuu6z5Hzs9evTgpJNOYptttmHPPffkrrv+5x9xbf2DZsmSJc2Pb2hoYODAgQC8+OKLHH/88QwZMoShQ4dy++23A3DTTTc1f65f//rXgdJPGbbeemu+8Y1vMHLkSKZNm8b06dPZb7/9GDFiBAcffDDPPvtsZR+WtJEs55KkuvX4449z22238dBDDzF79mxWr17NxIkTmTlzJkuXLmXOnDk8/vjjHHfccc2lfE1JbzkV5vnnn+f1119nl112afV11hz5htI0jB133HGDVvnYfvvtGTZsGPfccw9QKqpjxowhIujRowd33HEHs2bNYurUqZxxxhnrfK4rr7ySbbbZhscee4yvfvWrPPLII837LrroImbMmMGjjz7KvffeyxNPPMEZZ5zB9ttvz4MPPsjUqVPf8lzTpk3j5ptvZtq0afzxj3/k+9//fvNUnfnz53P66aczd+5cevTo0VyOW5o7dy4jRoxY73+zRYsWsXDhQvbdd9+3jTv99NPZdddd+eQnP8m1117LqlWrgNJPSHr37s2cOXN49NFH2W+//WhqauIb3/gG999/P4888gh/+MMfmv8xs2LFCoYPH860adMYPnw4p512GrfeeiszZ87kmGOOcaqMOozlXJJUt6ZOncr06dNpbGxk2LBhPPDAA/zlL39hwIABzJ8/n9NOO40pU6aw1VZbrfN51syXbsvYsWP5+c9/TmZu8JSWls+xpqy2fI7M5Ktf/SpDhw7lwAMPZNGiRSxdurTN5/nd737HMcccA8Duu+/OoEGDmvf97Gc/Y/jw4QwfPpx58+bxxBNPrDPTgw8+yKc+9Sk233xzevbsyeGHH87vf/97AAYMGMCQIUMAGDFiBAsXLtyg93vooYfy29/+lpdeeolbbrmFo446ine96+215bzzzmP69OmMGjWKn/zkJxxySGmK09SpU/niF78IlE7e3GabbXj44YfZf//92W677ejatStHH300v/vd7wDYbLPNOOKIIwCYN28ec+fOZdSoUQwbNoyLLrqIRYsWbVB+6Z1yzrkkqW5lJieccMJb5oOv8dhjj/GrX/2KK664gltvvZVrrrmmzefZdttt6dq1K0899RR9+/Z92/5+/fqx44478uCDD3Lbbbc1T3Fp6aGHHmL8+PFAabrHxz/+8bfs/+QnP8nZZ5/NjBkzePPNNxk6dCgAP/nJT1ixYgWzZs2iS5cu9OnTZ71L/LW20sif//xnLr/8cqZNm8bWW2/NMcccs97nWdc/Srp169Z8u6GhgdWrV79tzMCBA5k5c2arR8S32GILRo0axR133MHEiRP5wQ9+0OZrDRgwgAEDBnDyySfTq1cvVqxYQWa+7X2uK2+PHj2ax2cmQ4cO5cEHH2xzvFQtHjmXJNWtUaNG8fOf/7z5SPOyZct46qmnWLJkCZnJkUceyXnnncesWbMA6NmzJy+++GKrzzVhwgTGjx/fvH/58uVce+21zfvHjh3Lqaeeym677dbqCaV77rkns2fPZvbs2W8r5gBbbrkle++9NyeddBJHH3108/YVK1aw/fbb06VLF+69914WL168zve87777cvPNNwPw6KOPMnfuXABeeOEFevbsyZZbbskzzzzzlpM+23rf++67L7fddhuvvvoqL730EnfccQf77LPPOl+/pa997WucddZZzfO5V65c+ZaTXMeOHcsll1zC8uXL+dCHPtTqc9x1113NpftPf/oT3bp1o2fPnhx44IFceeWVQKlsP//88+yxxx7cf//9LFu2rHkK03777fe25xw4cCCLFy9m2rRpALz22mvN/52kavPIuSSpbg0ZMoRzzz2XUaNG8eabb9K1a1euvvpqGhoaOPHEE5uPvl588cUAfP7zn+ekk06iR48eb1uC8Utf+hIvv/wyI0aMYLPNNqNr166cffbZzfuPOuoozjzzTK6++up3nHfs2LEcddRRTJo0qXnbscceyyc+8QkaGxsZPnw4u+666zqf45RTTuH4449n6NChDB8+nMbGRgCGDx/OwIEDGTx4MO9973vZa6+9mh8zbtw4Ro0axc477/yWeecjR45k7NixzcX5C1/4AkOGDGHBggUVvZ9DDz2UJUuWsP/++wOlI/onn3xy8/7Ro0fzuc99rvknCq358Y9/zBlnnMHmm29O165d+elPf8q73vUuzj33XMaPH8/gwYNpaGjg29/+Noceeijnn38+H/nIR8hMPvGJT3DIIYe87ah+t27dmDRpEqeeeiovvvgiq1ev5stf/vJbpgBJ1RLrmyfXmTU2NuaMGTNqHUOSOr158+ax22671TqG1K7q6XvtOucbJyJmZmZjJWOd1iJJkiQVhOVckiRJKgjLuSRJklQQhSrnETE6IuZHxIKImNDK/m4RcUt5/8MR0a+8fWREzC7/ejQijujo7JKkdavnc5zU+fh9VrUUppxHRANwFXAwMBAYGxED1xp2IvB8Zg4AvgdcXN7+ONCYmcOA0cB/RYQr0UhSQXTv3p1ly5ZZaNQpZCbLli2je/futY6iTqhIBXYksCAznwSIiInAYUDLy5MdBnyrfHsScGVERGa+0mJMd8A//SWpQPr06UNTUxNLliypdRSpXXTv3p0+ffrUOoY6oSKV852AltfGbQI+3NaYzFwdESuAXsDSiPgwcD2wC3BsZr79UmRARIwDxgGtXsVNktT+unbtSv/+/WsdQ5IKrzDTWoC3X0v47UfA2xyTmQ9n5iDgQ8DXIqLVnzVl5jWZ2ZiZjb17996owJIkSVJ7KlI5bwJ2bnG/D/B0W2PKc8q3Av7RckBmzgNeBgZXLakkSZJUBUUq59OBXSOif0RsBowBJq81ZjJwfPn2p4H7MjPLj+kCEBG7AO8HFnZMbEmSJKl9FGbOeXkO+SnAFKABuD4z50bE+cCMzJwMXAfcGBELKB0xH1N++N7AhIh4HXgTGJ+ZSzv+XUiSJEnvXGHKOUBm3g3cvda2c1rcXgkc2crjbgRurHpASZIkqYqKNK1FkiRJqmuWc0mSJKkgLOeSJElSQVjOJUmSpIKwnEuSJEkFYTmXJEmSCsJyLkmSJBWE5VySJEkqCMu5JEmSVBCWc0mSJKkgLOeSJElSQVjOJUmSpILY4HIeETtEhKVekiRJamcVleyI6BoR342IF4HFQL/y9osjYnwV80mSJEl1o9Ij4OcCnwCOAVa12D4N+Fw7Z5IkSZLqUpcKx40FTsjMByLizRbbHwfe1/6xJEmSpPpT6ZHzHYG/tbK9C5UXfEmSJEnrUGk5nwvs28r2o4CZ7RdHkiRJql+VHvU+D7gpInYGGoAjI+IDwNHAIdUKJ0mSJNWTio6cZ+b/pXSU/EDgTUoniO4KfCIzp1YvniRJklQ/Kp4vnplTgClVzCJJkiTVtUrXOd8vIvZrY3trc9ElSZIkbaBKTwj9HrBNK9u3LO+TJEmStJEqLefvBx5tZfuc8j5JkiRJG6nScv4qpbXO19YHeK394kiSJEn1q9JyPgW4KCKap7ZExLbAhXiSqCRJktQuKl2t5Szgd8DCiHisvG0o8BwwphrBJEmSpHpTUTnPzGci4oPAZ4FhQAA3AD/NzFeqmE+SJEmqGxuyzvkrwLVVzEJEjAYup3QV0h9m5kVr7e8G/AQYASwDPpOZCyPiY8BFwGaU5sB/JTPvq2ZWSZIkqb1VXM4jYmdgH2B71pqrnpmXbWyQiGgArgI+BjQB0yNicmY+0WLYicDzmTkgIsYAFwOfAZZSulrp0xExmNI8+J02NpMkSZLUkSoq5xHxWeB6YDWwBMgWuxPY6HIOjAQWZOaT5decCBwGtCznhwHfKt+eBFwZEZGZj7QYMxfoHhHdMnNVO+SSJEmSOkSlR87PB/4P8M3MfKNKWXYCFrW43wR8uK0xmbk6IlYAvSgdOV/jU8AjFnNJkiRtaiot5ztQmgNerWIOpZNM15YbMiYiBlGa6nJgmy8SMQ4YB9C3b98NTylJkiRVSaXrnN/N249it7cmYOcW9/sAT7c1JiK6AFsB/yjf7wPcBhyXmX9p60Uy85rMbMzMxt69e7djfEmSJGnjVHrk/F7g4vKR6TnA6y13ZuYv2yHLdGDXiOgPLKa0wYwFpwAAE41JREFUfvrRa42ZDBwP/BH4NHBfZmZEbA3cBXwtM//QDllUBf0m3FXrCO1i4UWH1DqCJEnqpCot5/9V/v3rrexLSksfbpTyHPJTKK200gBcn5lzI+J8YEZmTgauA26MiAWUjpivuQDSKcAA4JsR8c3ytgMz87mNzSVJkiR1lEovQlTp9JeNkpl3U5pC03LbOS1urwSObOVx/w78e9UDSpIkSVXUIaVbkiRJ0vpVVM6jZHxEzI2IVyLiveXtEyLiqOpGlCRJkupDpUfOTwO+AVzDW5czXExpvrckSZKkjVRpOf/fwMmZeTmlq4SuMQsY1O6pJEmSpDpUaTnfBXi8le2vAz3aL44kSZJUvyot508Cw1vZ/nHgifaLI0mSJNWvStc5vxS4MiI2pzTn/F8i4ljgbOCEaoWTJEmS6kml65z/KCK6ABcCmwM3UjoZ9NTMvKWK+SRJkqS6sd5yHhHvAj4A/DQzr42I7YB3efVNSZIkqX1VMuc8gdnAPwFk5lKLuSRJktT+1lvOMzOB+UDv6seRJEmS6lelq7WcDVwSEcMiItY7WpIkSdIGq3S1lp8D3YGZwOqIWNVyZ2Zu2d7BJEmSpHpTaTk/paopJEmSJFW8lOIN1Q4iSZIk1btK55wTETtExFkR8YPycopExF4R0b968SRJkqT6UVE5j4gRlFZs+SxwIrBmjvnHgAuqE02SJEmqL5UeOb8UuDwzdwdangw6Bdir3VNJkiRJdajScj4CaG3e+TPADu0XR5IkSapflZbzV4FtWtn+AcCrhUqSJEntoNJyfgdwbkR0K9/PiOgHXAzcWoVckiRJUt2ptJyfBWwLLAE2B34PLACWA9+oTjRJkiSpvlS6zvkLwN4RsT8wnFKpn5WZU6sZTpIkSaonbZbziHgD+KfMfC4irgdOy8z7gPs6LJ0kSZJUR9Y1reVV4N3l28cD3asfR5IkSapf65rW8hBwe0TMBAK4IiJebW1gZp5QjXCSJElF0m/CXbWO0C4WXnRIrSOoDesq58dSOhF0QPl+L956ASJJkiRJ7ajNcp6ZzwJfAYiIvwJjM3NZRwWTJEmS6k2bc84j4o2I2L58937gtWqHiYjRETE/IhZExIRW9neLiFvK+x8ur7VORPSKiPsj4qWIuLLaOSVJkqRqKMwJoRHRAFwFHAwMBMZGxMC1hp0IPJ+ZA4DvUboIEsBK4JuUpuFIkiRJm6QinRA6EliQmU8CRMRE4DDgiRZjDgO+Vb49CbgyIiIzXwZ+HxEDkCRJkjZRlZ4QmlT/hNCdgEUt7jcBH25rTGaujogV5VxLq5hLkiRJ6hBFOiE0WovxDsas+0UixgHjAPr27bshD5UkSZKqal1zzptlZv8OWKmlCdi5xf0+wNNtjYmILsBWwD825EUy85rMbMzMxt69e29EXEmSJKl9tXnkPCLOBL6fmSvLt9uUmZe1Q5bpwK4R0R9YDIwBjl5rzGRKJ6f+Efg0cF9mbtCRc0kdwwt1SJK04dY15/xLwA2UVkL50jrGJbDR5bw8h/wUYArQAFyfmXMj4nxgRmZOBq4DboyIBZSOmI9Z8/iIWAhsCWwWEYcDB2bmE2u/jiRJklRU65pz3r+129WUmXcDd6+17ZwWt1cCR7bx2H5VDSdJkiRV2bqOnEuSVLHOMJXJaUySam1dc87PaWvf2jLz/PaJI0mSJNWvdR05X3v6yC7A5vzPCio7Aq8ACwHLuSRJkrSR1jXnfMia2xHxeeA44PjMfKq8rS/wI+DmaoeUNmWd4Uf94I/7JUnqCBWtcw6cA5y+ppgDlG9/GTi3GsEkSZKkelNpOd8B6NHK9u7Adu0XR5IkSapflZbze4FrI2KPiGgo/9oD+K/yPkmSJEkbqdJyfhKwCHiI0kWJVgJ/oHQlz5OrE02SJEmqLxWtc56ZS4CPR8SuwG5AAPMy80/VDCdJkiTVkw26CFFm/hn4c5Wy1A1X75AkSVJrKp3WIkmSJKnKLOeSJElSQVjOJUmSpIKwnEuSJEkFUXE5j4gdIuKsiPhBRGxX3rZXRPSvXjxJkiSpflRUziNiBDAf+CxwIrBledfHgAuqE02SJEmqL5UeOb8UuDwzdwdWtdg+Bdir3VNJkiRJdajScj4CuKGV7c8AO7RfHEmSJKl+VVrOXwW2aWX7B4Dn2i+OJEmSVL8qLed3AOdGRLfy/YyIfsDFwK1VyCVJkiTVnUrL+VnAtsASYHPg98ACYDnwjepEkyRJkupLl0oGZeYLwN4RsT8wnFKpn5WZU6sZTpIkSaon6y3nEdGV0pHy4zLzPuC+qqeSJEmS6tB6p7Vk5utAfyCrH0eSJEmqX5XOOb8BOLmaQSRJkqR6V9Gcc2AL4LMR8TFgJvByy52ZeWp7B5MkSZLqTaXlfDdgVvn2e9fa53QXSZIkqR1UulrLR6sdRJIkSap3lc45ByAiukfE4IgYFBHd2ztMRIyOiPkRsSAiJrSyv1tE3FLe/3D5Qkhr9n2tvH1+RBzU3tkkSZKkaquonEdE14i4BHgeeBSYAzwfEd8tL7W40SKiAbgKOBgYCIyNiIFrDTsReD4zBwDfo3SFUsrjxgCDgNHA98vPJ0mSJG0yKj1yfjFwDPC/gfcBuwJfAI4FvtNOWUYCCzLzycx8DZgIHLbWmMMorRwDMAk4ICKivH1iZq7KzL9SunrpyHbKJUmSJHWISk8IPRo4ITPvbrHtLxGxBPghcFY7ZNkJWNTifhPw4bbGZObqiFgB9Cpv/39rPXandsgkSZIkdZhKy/lWwF9a2f4XYOt2yhKtbFt7JZi2xlTy2NITRIwDxgH07dt3Q/K1m4UXHVKT160133d9qdf3DdBvwl21jrDR3snnV6+feWf4vGHDP796fd/1+j2v1/ddC5VOa3kUaG0t89OA2e2UpQnYucX9PsDTbY2JiC6U/tHwjwofC0BmXpOZjZnZ2Lt373aKLkmSJG28So+cnw3cXb4I0R8pHZX+F2BHSidwtofpwK4R0R9YTOkEz6PXGjMZOL6c4dPAfZmZETEZ+GlEXFbOtCswrZ1ySZIkSR2i0nXOfxcR7wfGAx+gNI3kF8D3M7PVI9QbqjyH/BRgCtAAXJ+ZcyPifGBGZk4GrgNujIgFlI6Yjyk/dm5E/Bx4AlgNfDEz32iPXJIkSVJHqfTIOZm5GPi3KmahfMLp3WttO6fF7ZXAkW089gLggmrmkyRJkqqp0nXOT4mIY1rZfkxEjG//WJIkSVL9qfSE0NN56zKHaywEzmi3NJIkSVIdq7Sc9wH+1sr2pvI+SZIkSRup0nL+d2BYK9uHA0vbL44kSZJUvyo9IfSnwBUR8TLw2/K2jwL/AdxchVySJElS3am0nJ8L9Ke0zOGaJQrfRWk5xW9WIZckSZJUdypd5/x1YGxEfBPYndI657Myc0E1w0mSJEn1pOJ1zgHKZXxBRHQBulcnkiRJklSf1nlCaEQcEBFHrbVtAvASsDwifh0RW1czoCRJklQv1rdaywRaLJUYESOBC4EbgbOBD1Llq4ZKkiRJ9WJ95XwI8ECL+0cCD2XmyZl5GXAqcGi1wkmSJEn1ZH3lfGvguRb39wJ+3eL+dGCn9g4lSZIk1aP1lfNngH8GiIhulFZq+WOL/T2BVdWJJkmSJNWX9ZXzXwHfjYj9gYuBl4EHW+wfCricoiRJktQO1reU4jnAL4GplFZoOT4zX2ux/wTg3iplkyRJkurKOst5Zi4F9o2IrYCXMvONtYYcSam0S5IkSdpIlV4hdEUb2//RvnEkSZKk+rW+OeeSJEmSOojlXJIkSSoIy7kkSZJUEJZzSZIkqSAs55IkSVJBWM4lSZKkgrCcS5IkSQVhOZckSZIKwnIuSZIkFYTlXJIkSSoIy7kkSZJUEIUo5xGxbUTcGxF/Lv++TRvjji+P+XNEHN9i+wURsSgiXuq41JIkSVL7KkQ5ByYAv8nMXYHflO+/RURsC5wLfBgYCZzbosT/3/I2SZIkaZNVlHJ+GHBD+fYNwOGtjDkIuDcz/5GZzwP3AqMBMvP/ZeYzHZJUkiRJqpKilPMd1pTr8u/btzJmJ2BRi/tN5W2SJElSp9Clo14oIqYC72ll179V+hStbMt3kGMcMA6gb9++G/pwSZIkqWo6rJxn5qi29kXEsxHxT5n5TET8E/BcK8OagI+0uN8H+O07yHENcA1AY2PjBpd7SZIkqVqKMq1lMrBm9ZXjgTtaGTMFODAitimfCHpgeZskSZLUKRSlnF8EfCwi/gx8rHyfiGiMiB8CZOY/gG8D08u/zi9vIyK+GxFNwOYR0RQR36rBe5AkSZI2SodNa1mXzFwGHNDK9hnASS3uXw9c38q4s4Gzq5lRkiRJqraiHDmXJEmS6l4hjpxLkrSpWnjRIbWOIKkTsZxLUjuzrEmS3imntUiSJEkFYTmXJEmSCsJyLkmSJBWE5VySJEkqCMu5JEmSVBCWc0mSJKkgLOeSJElSQVjOJUmSpILwIkSSJGmDebEtqTo8ci5JkiQVhOVckiRJKgjLuSRJklQQlnNJkiSpICznkiRJUkFYziVJkqSCsJxLkiRJBWE5lyRJkgoiMrPWGWomIpYAf6t1jirZDlha6xDqMH7e9cXPu/74mdcXP+/OZ5fM7F3JwLou551ZRMzIzMZa51DH8POuL37e9cfPvL74edc3p7VIkiRJBWE5lyRJkgrCct55XVPrAOpQft71xc+7/viZ1xc/7zrmnHNJkiSpIDxyLkmSJBWE5byTiYjRETE/IhZExIRa51F1RcTOEXF/RMyLiLkRcVqtM6n6IqIhIh6JiDtrnUXVFRFbR8SkiPjv8v/n/1LrTKqeiDij/Gf54xHxs4joXutM6niW804kIhqAq4CDgYHA2IgYWNtUqrLVwJczczdgD+CLfuZ14TRgXq1DqENcDvw6Mz8AfBA/904rInYCTgUaM3Mw0ACMqW0q1YLlvHMZCSzIzCcz8zVgInBYjTOpijLzmcycVb79IqW/uHeqbSpVU0T0AQ4BfljrLKquiNgS2Be4DiAzX8vM5bVNpSrrAvSIiC7A5sDTNc6jGrCcdy47AYta3G/ColY3IqIfsDvwcG2TqMr+AzgbeLPWQVR17wWWAD8qT2P6YURsUetQqo7MXAxcCjwFPAOsyMx7aptKtWA571yilW0ux1MHIuLdwK3A6Zn5Qq3zqDoi4l+B5zJzZq2zqEN0AYYDP8jM3YGXAc8l6qQiYhtKP+3uD+wIbBERx9Q2lWrBct65NAE7t7jfB38k1ulFRFdKxfzmzPxlrfOoqvYCDo2IhZSmre0fETfVNpKqqAloysw1Pw2bRKmsq3MaBfw1M5dk5uvAL4E9a5xJNWA571ymA7tGRP+I2IzSiSSTa5xJVRQRQWk+6rzMvKzWeVRdmfm1zOyTmf0o/f99X2Z6ZK2Tysy/A4si4v3lTQcAT9QwkqrrKWCPiNi8/Gf7AXgCcF3qUusAaj+ZuToiTgGmUDrL+/rMnFvjWKquvYBjgTkRMbu87euZeXcNM0lqP18Cbi4fcHkS+HyN86hKMvPhiJgEzKK0EtcjeKXQuuQVQiVJkqSCcFqLJEmSVBCWc0mSJKkgLOeSJElSQVjOJUmSpIKwnEuSJEkFYTmXpE1URLwnIiZGxF8i4omIuDsi3tdBr31kRMyLiPvXMeYjEXFnG/sWRsR263js/4qIz0XEsIi4uj0yS9KmwHIuSZug8kVKbgN+m5n/nJkDga8DO6w1rqFKEU4ExmfmR6v0/PsADwL7lX+XpLpgOZekTdNHgdczs/mocmbOzswHy0es74+InwJzACLizIh4vPzr9PK2LSLiroh4tLz9M+XtF5WPxD8WEZeu/cIRcQ6wN3B1RFwSEd0j4kcRMSciHomItxX2iOgVEfeU9/8XEK29qYg4o3xBrSOAW4HzgH/z6LmkeuEVQiVp0zQYmLmO/SOBwZn514gYQenKkh+mVIofjogHgPcCT2fmIQARsVVEbEupGH8gMzMitl77iTPz/IjYHzgrM2dExJfL24dExAeAe1qZXnMu8PvyYw8BxrUWOjO/FxE3Addl5qERMT0zP1TxfxVJ2sR55FySOqdpmfnX8u29gdsy8+XMfAn4JaVpI3OAURFxcUTsk5krgBeAlcAPI+KTwCsVvNbewI0AmfnfwN+Atcv5vsBN5TF3Ac+v4/mGA49GRM/1jJOkTsdyLkmbprnAiHXsf7nF7VankGTmn8rPMQf4TkSck5mrKR11vxU4HPh1RDRExOzyr/NbeapWn7+1l1zXzojYvjyl5UfAZ4FHgA+WX/efK3wNSdqkWc4ladN0H9AtIk5esyEiPhQR+7Uy9nfA4RGxeURsQWnayoMRsSPwSmbeBFwKDI+IdwNbZebdwOnAsMx8IzOHlX+d08bzf7ac4X1AX2D+OsYcDGyz9pNk5nOZOQyYRekfCDcBny+/7l8q/Q8jSZsy55xL0iaoPB/8COA/ImICpakoCykV6p3WGjsrIn4MTCtv+mFmPhIRBwGXRMSbwOvAF4CewB0R0Z3SEfEzKojzfUonh84BVgOfy8xVpQVlmp0H/CwiZgEPAE+19kTl1WV6ZebSiNgTuKyC15ekTiMy1/lTRkmSJEkdxGktkiRJUkFYziVJkqSCsJxLkiRJBWE5lyRJkgrCci5JkiQVhOVckiRJKgjLuSRJklQQlnNJkiSpIP4/+5YNujI9AxEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1aa56ef3c8>"
      ]
     },
     "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",
      " [[ 65   2]\n",
      " [  3 118]]\n",
      "Accuracy  0.973404255319149\n",
      "Recall    0.9752066115702479\n",
      "Precision 0.9833333333333333\n",
      "F1        0.979253112033195\n",
      "ROC AUC   0.9726779326507956\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.9842105263157894 0.024118819447136022\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": 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
}