03_random_forest_models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# random forest models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier\n",
    "from sklearn.model_selection import cross_val_score, RandomizedSearchCV, GridSearchCV\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from imblearn.pipeline import Pipeline as imbPipeline\n",
    "from sklearn.metrics import confusion_matrix, plot_confusion_matrix, classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the presplit data\n",
    "X_train = pd.read_csv('data/X_train.csv', index_col='id')\n",
    "X_test = pd.read_csv('data/X_test.csv', index_col='id')\n",
    "y_train = pd.read_csv('data/y_train.csv', index_col='id')\n",
    "y_test = pd.read_csv('data/y_test.csv', index_col='id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 40095 entries, 58975 to 23269\n",
      "Data columns (total 21 columns):\n",
      " #   Column             Non-Null Count  Dtype  \n",
      "---  ------             --------------  -----  \n",
      " 0   gps_height         40095 non-null  int64  \n",
      " 1   installer          40095 non-null  object \n",
      " 2   longitude          40095 non-null  float64\n",
      " 3   latitude           40095 non-null  float64\n",
      " 4   num_private        40095 non-null  int64  \n",
      " 5   basin              40095 non-null  object \n",
      " 6   region             40095 non-null  object \n",
      " 7   region_code        40095 non-null  int64  \n",
      " 8   district_code      40095 non-null  int64  \n",
      " 9   population         40095 non-null  int64  \n",
      " 10  public_meeting     40095 non-null  object \n",
      " 11  scheme_management  40095 non-null  object \n",
      " 12  permit             40095 non-null  object \n",
      " 13  construction_year  40095 non-null  int64  \n",
      " 14  extraction_type    40095 non-null  object \n",
      " 15  management         40095 non-null  object \n",
      " 16  payment            40095 non-null  object \n",
      " 17  water_quality      40095 non-null  object \n",
      " 18  quantity           40095 non-null  object \n",
      " 19  source             40095 non-null  object \n",
      " 20  waterpoint_type    40095 non-null  object \n",
      "dtypes: float64(2), int64(6), object(13)\n",
      "memory usage: 6.7+ MB\n"
     ]
    }
   ],
   "source": [
    "X_train.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function will taken in a given model, X_test, y_test and return the accuracy for each type of well status\n",
    "def model_predictions(model, X=X_test, y=y_test):\n",
    "    y_pred = model.predict(X)\n",
    "    cm = confusion_matrix(y_test, y_pred)\n",
    "    func = cm[0][0] / (cm[0][0] + cm[0][1] + cm[0][2])\n",
    "    func_nr = cm[1][1] / (cm[1][0] + cm[1][1] + cm[1][2])\n",
    "    non_func = cm[2][2] / (cm[2][0] + cm[2][1] + cm[2][2])\n",
    "    print(f'The model correctly predicts {round(func*100, 2)}% of the funtional wells.')\n",
    "    print(f'The model correctly predicts {round(func_nr*100, 2)}% of the funtional-needs-repair wells.')\n",
    "    print(f'The model correctly predicts {round(non_func*100, 2)}% of the non-functional wells.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = np.array(y_train)\n",
    "# reshape y_train to an array\n",
    "y_train = y_train.reshape(40095, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test = np.array(y_test)\n",
    "# reshape y_test to an array\n",
    "y_test = y_test.reshape(13365, )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# first model of rfc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* In this model I only used numeric data to see if there was any trends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipeline_0 = imbPipeline([('ss', StandardScaler()), ('smote', SMOTE(random_state=42)), ('rfc', RandomForestClassifier())])\n",
    "\n",
    "X_train_nums = X_train.select_dtypes(exclude=object)\n",
    "X_test_nums = X_test.select_dtypes(exclude=object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pipeline_0.fit(X_train_nums, y_train)\n",
    "\n",
    "preds = pipeline_0.predict(X_test_nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Mode's accuracy on the training data is 0.9816\n",
      "The Model's accuracy on the test data is 0.6777\n"
     ]
    }
   ],
   "source": [
    "train_scores = pipeline_0.score(X_train_nums, y_train)\n",
    "test_scores = pipeline_0.score(X_test_nums, y_test)\n",
    "print('The Mode\\'s accuracy on the training data is', round(train_scores, 4))\n",
    "print('The Model\\'s accuracy on the test data is', round(test_scores, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log Loss: 1.16549643728395\n"
     ]
    }
   ],
   "source": [
    "log_loss_rfc = cross_val_score(pipeline_0, X_train_nums, y_train, scoring='neg_log_loss', n_jobs = -2, cv = 2)\n",
    "log_loss_rfc = -log_loss_rfc.mean()\n",
    "print('Log Loss:', log_loss_rfc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log Loss: 1.2730952887911073\n"
     ]
    }
   ],
   "source": [
    "log_loss_rfc = cross_val_score(pipeline_0, X_test_nums, y_test, scoring='neg_log_loss', n_jobs = -2, cv = 2)\n",
    "log_loss_rfc = -log_loss_rfc.mean()\n",
    "print('Log Loss:', log_loss_rfc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(pipeline_0, X_test_nums, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 71.02% of the funtional wells.\n",
      "The model correctly predicts 49.33% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 66.66% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(pipeline_0, X_test_nums, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  this inital model that only contains numerical data is severly overfitting the data. the next model will need to tune some hyperparameters to reduce the gap between the training and testing data. our log loss has been decreased from the dummy classifer, but there is still room for improvement. the total score of non-functional and functional needs repairs is only 91.96%, which is very low."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tuning some hyperparameters to see if the model can be improved\n",
    "\n",
    "*  no categorial colums have yet been introduced. But I will run a randomized search to see if tuning some hyperparamters will improve the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipline_1 = imbPipeline([('ss', StandardScaler()), ('smote', SMOTE(random_state=42)), ('rfc', RandomForestClassifier())])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'memory': None,\n",
       " 'steps': [('ss', StandardScaler()),\n",
       "  ('smote', SMOTE(random_state=42)),\n",
       "  ('rfc', RandomForestClassifier())],\n",
       " 'verbose': False,\n",
       " 'ss': StandardScaler(),\n",
       " 'smote': SMOTE(random_state=42),\n",
       " 'rfc': RandomForestClassifier(),\n",
       " 'ss__copy': True,\n",
       " 'ss__with_mean': True,\n",
       " 'ss__with_std': True,\n",
       " 'smote__k_neighbors': 5,\n",
       " 'smote__n_jobs': None,\n",
       " 'smote__random_state': 42,\n",
       " 'smote__sampling_strategy': 'auto',\n",
       " 'rfc__bootstrap': True,\n",
       " 'rfc__ccp_alpha': 0.0,\n",
       " 'rfc__class_weight': None,\n",
       " 'rfc__criterion': 'gini',\n",
       " 'rfc__max_depth': None,\n",
       " 'rfc__max_features': 'auto',\n",
       " 'rfc__max_leaf_nodes': None,\n",
       " 'rfc__max_samples': None,\n",
       " 'rfc__min_impurity_decrease': 0.0,\n",
       " 'rfc__min_impurity_split': None,\n",
       " 'rfc__min_samples_leaf': 1,\n",
       " 'rfc__min_samples_split': 2,\n",
       " 'rfc__min_weight_fraction_leaf': 0.0,\n",
       " 'rfc__n_estimators': 100,\n",
       " 'rfc__n_jobs': None,\n",
       " 'rfc__oob_score': False,\n",
       " 'rfc__random_state': None,\n",
       " 'rfc__verbose': 0,\n",
       " 'rfc__warm_start': False}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipline_1.get_params()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "params_1 = {\n",
    "    'rfc__max_depth': list(range(5,50,5)),\n",
    "    'rfc__min_samples_leaf': list(range(5,50,5)),\n",
    "    'rfc__n_estimators': list(range(25,500,25)),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 10 candidates, totalling 50 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  18 tasks      | elapsed:  1.2min\n",
      "[Parallel(n_jobs=-2)]: Done  50 out of  50 | elapsed:  2.2min finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "RandomizedSearchCV(estimator=Pipeline(steps=[('ss', StandardScaler()),\n",
       "                                             ('smote', SMOTE(random_state=42)),\n",
       "                                             ('rfc',\n",
       "                                              RandomForestClassifier())]),\n",
       "                   n_jobs=-2,\n",
       "                   param_distributions={'rfc__max_depth': [5, 10, 15, 20, 25,\n",
       "                                                           30, 35, 40, 45],\n",
       "                                        'rfc__min_samples_leaf': [5, 10, 15, 20,\n",
       "                                                                  25, 30, 35,\n",
       "                                                                  40, 45],\n",
       "                                        'rfc__n_estimators': [25, 50, 75, 100,\n",
       "                                                              125, 150, 175,\n",
       "                                                              200, 225, 250,\n",
       "                                                              275, 300, 325,\n",
       "                                                              350, 375, 400,\n",
       "                                                              425, 450, 475]},\n",
       "                   verbose=3)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rs_1 = RandomizedSearchCV(pipline_1, params_1, n_jobs=-2, verbose=3, n_iter=10)\n",
    "\n",
    "rs_1.fit(X_train_nums, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The train score for the random search with some hyperparameter tuning is 0.7068\n",
      "\n",
      "The test score for the random search with some hyperparameter tuning is 0.631\n"
     ]
    }
   ],
   "source": [
    "print('The train score for the random search with some hyperparameter tuning is',\n",
    "      round(rs_1.score(X_train_nums, y_train), 4))\n",
    "print('')\n",
    "print('The test score for the random search with some hyperparameter tuning is',\n",
    "      round(rs_1.score(X_test_nums, y_test), 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'rfc__n_estimators': 50, 'rfc__min_samples_leaf': 5, 'rfc__max_depth': 15}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rs_1.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log Loss: 0.7866014680117359\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:  2.7min finished\n"
     ]
    }
   ],
   "source": [
    "log_loss_rfc = cross_val_score(rs_1, X_train_nums_scaled, y_train, scoring='neg_log_loss', n_jobs = -2, verbose=1, cv = 2)\n",
    "log_loss_rfc = -log_loss_rfc.mean()\n",
    "print('Log Loss:', log_loss_rfc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log Loss: 0.827434644865076\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:  1.3min finished\n"
     ]
    }
   ],
   "source": [
    "log_loss_rfc = cross_val_score(rs_1, X_test_nums_scaled, y_test, scoring='neg_log_loss', n_jobs = -2, verbose=1, cv = 2)\n",
    "log_loss_rfc = -log_loss_rfc.mean()\n",
    "print('Log Loss:', log_loss_rfc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(rs_1, X_test_nums_scaled, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 0.0% of the funtional wells.\n",
      "The model correctly predicts 99.18% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 3.86% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(rs_1, X_test_nums_scaled, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  this model is very inaccurate. It is unable to predict any functional or non functional wells."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# introduction of categorial features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# model 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  this is he first model that will contain the categorical colums, there will be no hyperparameter tuning done yet. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_nums = X_train.select_dtypes(exclude = object)\n",
    "\n",
    "X_train_cat = X_train.select_dtypes('object')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "numerical_pipeline = Pipeline(steps=[\n",
    "    ('ss', StandardScaler())\n",
    "])\n",
    "                \n",
    "categorical_pipeline = Pipeline(steps=[\n",
    "    ('ohe', OneHotEncoder(handle_unknown = 'ignore'))\n",
    "])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "trans = ColumnTransformer(transformers=[\n",
    "    ('numerical', numerical_pipeline, X_train_nums.columns),\n",
    "    ('categorical', categorical_pipeline, X_train_cat.columns)\n",
    "], verbose=True, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_pipe = imbPipeline(steps=[\n",
    "    ('trans', trans),\n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('rfc', RandomForestClassifier(verbose=1, n_jobs=-2))\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  36 tasks      | elapsed:   17.0s\n",
      "[Parallel(n_jobs=-2)]: Done 100 out of 100 | elapsed:   42.0s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('trans',\n",
       "                 ColumnTransformer(n_jobs=-1,\n",
       "                                   transformers=[('numerical',\n",
       "                                                  Pipeline(steps=[('ss',\n",
       "                                                                   StandardScaler())]),\n",
       "                                                  Index(['gps_height', 'longitude', 'latitude', 'num_private', 'region_code',\n",
       "       'district_code', 'population', 'construction_year'],\n",
       "      dtype='object')),\n",
       "                                                 ('categorical',\n",
       "                                                  Pipeline(steps=[('ohe',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore'))]),\n",
       "                                                  Index(['installer', 'basin', 'region', 'public_meeting', 'scheme_management',\n",
       "       'permit', 'extraction_type', 'management', 'payment', 'water_quality',\n",
       "       'quantity', 'source', 'waterpoint_type'],\n",
       "      dtype='object'))],\n",
       "                                   verbose=True)),\n",
       "                ('smote', SMOTE(random_state=42)),\n",
       "                ('rfc', RandomForestClassifier(n_jobs=-2, verbose=1))])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 100 out of 100 | elapsed:    0.2s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9945878538471131"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 100 out of 100 | elapsed:    0.0s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7859334081556304"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:   31.2s remaining:    0.0s\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:   31.2s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.864429998970367"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_1 = cross_val_score(model_pipe, X_train, y_train, scoring='neg_log_loss', n_jobs = -2, verbose = 3, cv = 2)\n",
    "-cv_1.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:    6.5s remaining:    0.0s\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:    6.5s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8919356179482123"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_1 = cross_val_score(model_pipe, X_test, y_test, scoring='neg_log_loss', n_jobs = -2, verbose = 3, cv = 2)\n",
    "-cv_1.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 100 out of 100 | elapsed:    0.0s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAFzCAYAAABioD1WAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/BUlEQVR4nO3deZyVdd3/8dd7ZmBYZAeRRcEFNUXcUHHNrdRyyzI1S83KrdwqS++678xuTUszl8T0zlzSFHOvVJRE8+eCoCiKooYICILsO8zy+f1xXQMHmA2YmeucM+9nj/OY6/pe2+ec8HzOd7m+lyICMzOzfFeSdQBmZmaN4YRlZmYFwQnLzMwKghOWmZkVBCcsMzMrCE5YZmZWEJywzMxsg0jqKulvkt6T9K6kfSV1l/SMpA/Sv91y9r9M0oeSJkk6Iqd8T0kT0m03SlJ913XCMjOzDXUD8FRE7AjsCrwLXAqMiohBwKh0HUk7AScDOwNHArdIKk3PMxw4CxiUvo6s76LyjcO2KXp2L42BW7bJOoy89cHETlmHkP9KSxvep5VbtHLWnIjotbHHH3FIx5g7r6pR+457a+XTEVFn4pDUGXgT2CZyEoikScDBETFTUh9gdETsIOkygIj4dbrf08DlwBTguTTpIemU9Piz67p2WaPegVkdBm7ZhjFPb5l1GHnrS7scmnUI+a9716wjyHtPv/+bjzfl+Lnzqhjz9FaN2re0zwc9G9hlG+Az4M+SdgXGARcCvSNiJkCatDZP9+8HvJJz/PS0rCJdXre8Tm4SNDMrcgFUN/J/QE9JY3NeZ61zujJgD2B4ROwOLCVt/qtDbf1SUU95nVzDMjMrekFVVDd25zkRMbSe7dOB6RHxarr+N5KENUtSn5wmwdk5++c2w/QHZqTl/Wspr5NrWGZmRS6ASqoa9WrwXBGfAtMk7ZAWHQZMBB4HTk/LTgceS5cfB06WVC5pa5LBFWPS5sPFkoalowNPyzmmVq5hmZkVuSCoatoBducD90pqC0wGvk1SARoh6TvAVOBEgIh4R9IIkqRWCXw/Imoy47nAnUB74Mn0VScnLDOzVqC6/u6hDRIR44Hamg0Pq2P/K4EraykfCwxu7HWdsMzMilwAVU2YsLLihGVm1go0ZQ0rK05YZmZFLoCKIpgkwgnLzKzIBeEmQTMzKwABVYWfr5ywzMyKXTLTReFzwjIzK3qiqtaZkAqLE5aZWZELoNpNgmZmlu8CWFUEM/E5YZmZtQLV4SZBMzPLc8lMF05YZmaW5wJR5SZBMzMrBG4SNDOzvOcmQTMzKwiBqIjC/7ov/HdgZmYNcg3LzMzyXoSoCg+6MDOzAlDtGpaZmeW7ZNCFa1hmZpbnPOjCzMwKRpXvwzIzs3znmS7MzKxgVHuUoJmZ5TsPujAzs4IQyH1YZi1hycJSrv/xlkx5rx0S/PB3U+m/7UquOmcgs6a3pXf/Vfzsj1Po1LWK997owA2XbAkkvyq/9aNP2f+ohQA890hX7r+pNxJ0713BT2/6mC49qjJ8Z82npCS44f6xzJ1dzuU/GALAMd+YzjEnT6eqSrz2Qg/uuH47AL7+nY/54gkzqa6CW68exOsv9cgy9GbXb8vFXPqL11av9+m7lHvu+ByP/W07jjnhPxzzlcnJZ/TKFtxx62BKS6u58Cevs932CykpreZfT2/FiHt3yPAdbLgIPErQGibpAuBc4PWIOLUJzjcQ2C8i7kvXhwKnRcQFm3ruda4zBRgaEXOa8rwbY/j/9GPowYv479unULFKrFxewv03bs7uByzmpPNn88BNm/PAzZvz3Z/PZOAOy7n5qUmUlsHcWWWce/gODPvCwtXnuX30e3TpUcX//aoPj/+5F9/68acZv7vmcdw3pzHtow506Jgk5CF7zWfYIXM476t7U1lRQpfuqwDYcpulHHTULM45fm96bL6Sq24fz/eOHkZ1deH/Gq/LJ9M6cf53DwWSxH73357k5X/3ZcjunzFs/5mcd+ahVFaU0qXrSgAOPOQT2rSp5rxvH0Z5eSW33jWK0aP6M/vTjlm+jQ2korhxuPAbNfPfecCXmiJZpQYC36hZiYixTZ2s8snSxSVMeKUjR35jHgBt2gabdani5ae7cPjXk7LDvz6Pl5/qAkC7DkFp+jOsYmUJSv8bjQBCrFheQgQsXVJKjy0qWvrttIgevVew14FzefqhvqvLvnzSJzz4p62orEj+k184ry0A+x4yhxee7E1lRQmzPmnPjKnt2X6XRZnEnYVd95jNpzM6MntWB7583Ec8eN/2VFaUArBwQTmQ/Ntp176KktJq2pZXUVkpli1tk2XYGyyAqihp1Cuf5Xd0BU7SrcA2wOOSFkr6cc62tyUNTF/vSrpd0juSRkpqn+6znaRnJb0p6XVJ2wJXAwdKGi/pYkkHS/p7un93SY9KekvSK5KGpOWXS7pD0mhJk9NaX00cj0oal177rJb8fBrj04/L6dKjkusu3orzvrA91/9oS1YsK2H+nDb06F0JQI/elSyYu6ax4L3XO/C9g3fg7EN34IJrplNaBmVt4Pyrp3HOoTvyjd13Zur77TjilLlZva1mdfZPPuSO67ejunpNWd8By9l5j4Vcf+9Yrvnz6wzaOUlKPXqv5LNZ5av3mzOrHT02X9nSIWfm84dNZ/So/gD07b+EnYfM5frho7nmhhcYtON8AF4c3Y8Vy0u59+EnuWvE0zz0wCCWLG6bZdgbpYqSRr0aQ9IUSRPS76GxaVl3Sc9I+iD92y1n/8skfShpkqQjcsr3TM/zoaQbJdVbDXTCakYRcQ4wAzgEuL6eXQcBf4iInYEFwFfT8nvT8l2B/YCZwKXAvyNit4hY95y/BN6IiCHAfwF352zbETgC2Bv4haSan4hnRsSewFDgAkl51YFRVQUfTujA0afN4ZZn3qddh2oeuHnzeo/ZcY9l3D56Ejc9+T7337Q5q1aIygr4+909+cPISdz3xjts/bnlPHBT7xZ6Fy1n74PmsGBeGz6c2Gmt8tLSYLPOFVx86p786brtuOzad4Cg1q+HaJFQM1dWVs0++33Ki6P7AVBaWs1mnVZx8bmf50/DB3PZ5WOAYIfPzae6WnzzhKP49slHcMLXP2SLPkuzDX4DBaI6GvfaAIek30ND0/VLgVERMQgYla4jaSfgZGBn4EjgFkml6THDgbNIvgMHpdvr5D6s/PBRRIxPl8cBAyV1AvpFxCMAEbECoIEfIAeQJruI+JekHpK6pNv+ERErgZWSZgO9gekkSeor6T5bkvyjqbfqkdbEzgLYql/z/hPq2aeCXn0q2HGPZQAccPQCRty8Od16VjB3Vhk9elcyd1YZXXtUrnfsVoNW0q5DNVMmtUuaBIG+A5O+m88fu4AHbi6+hLXT7gsZdshc9jrwZdqUV9OhYyU//vVE5swq56VnewHi/bc7EwGdu1Uw59NyevVeU6Pq2XsFcz8rr/sCRWToPp/ynw+6smB+OwDmfNael17oC4j33+tOVIvOXVZx8OHTGDemN1VVJSxcUM7Et7szaMf5fDqzkPqwWmRY+3HAwenyXcBo4Kdp+f3p989Hkj4E9k77yTtHxMsAku4GjgeerOsCrmG1nErW/rzb5SzntsFUkfyQ2Jge0vp+L693DUkHA4cD+6a1uDfWiatWEXFbRAyNiKG9epQ2tPsm6b55JT37rmLah8mX6Ph/d2KrQSsZ9sVFPDuiOwDPjujOvkckAys+ndqWqjR3zZrehun/aUfv/qvouUUFU99vx4K5Sbyvv9CJLQetaNbYs3DnDdty2uH78e0j9+WaS3birTHduPaynXjlXz3ZdZ+kiavfgGWUtQkWzW/DK6N7ctBRsyhrU03vfsvpO2A570/onPG7aBmfP2w6z6fNgQCvvNiXXff4DIB+/RdT1qaaRQvbMntWh7Q8KG9XyY47zWfax53qOGt+SuYSLG3Uq9GnhJFpd0JNV0LviJgJkP6taQrpB0zLOXZ6WtYvXV63vE6uYbWcKcDRAJL2ALaub+eIWCRpuqTjI+JRSeVAKbAYqOu/lheAU4FfpcloTnqeui7TBZgfEcsk7QgM27C31DK+/7+fcM0PBlBZIbbYahU/un4qUQ1XnjOQp+7vweb9kmHtAG+P6cgDN29NWVkyAuz8q6avHrp+6g8/5cdfGURZm2Dzfqv48e+nZviuWtbIR/pw0a/e45aHx1BZIX73s88BYup/OvLvpzfnj4+9SlWlGH7l9kU9QrBGeXkluw+dzU3X7b66bOQ/B3DRT1/nlj8/S2VlCb+7ak9A/P3Rbbj40nEMv3MUEjzz5FZMmdyl7pPnoWCDZrroWdMvlbotIm5bZ5/9I2KGpM2BZyS9V8/56vohvcEN0k5YLech4DRJ44HXgPcbccy3gD9KugKoAE4E3gIqJb0J3ElSK6pxOfBnSW8By4DTGzj/U8A56f6TgFca+2Za0raDl3PzU+t/XNeM+M96ZYd/bT6Hf21+rec5+rS5HH1acQ60qM2Esd2YMDbp966sLOHay3aqdb8Hbh/IA7cPbMHIsrdyZRknH3v0WmWVlSVce+XQ9fZdsbyMX/9in5YKrdlswBOH5+T0S9UqImakf2dLeoSkb3yWpD4RMVNSH2B2uvt0ku6GGv1J+vanp8vrltfJCauZRcTAnNUv1rHb4Jz9r81Z/gA4tJb9D1tnfXS6/zyS9uJ1Y7h8nfXBOatH1RbQOnGbWQGLUJPNJSipI1ASEYvT5S8CVwCPk/xIvjr9+1h6yOPAfZJ+B/Ql6ScfExFVkhZLGga8CpwG3FTftZ2wzMxagSa8x6o38Eja1VAG3BcRT0l6DRgh6TvAVJIWISLiHUkjgIkkffnfj4iaKWbOJWkpak8y2KLOARc1FzMzsyJWM+iiSc4VMRnYtZbyuazf+lOz7UrgylrKx5LTwtQQJywzsyKXDLoo/ME0TlhmZq2AHy9iZmZ5r2ami0LnhGVm1gpUu4ZlZmb5LgI/wNHMzPJfICqrm3catZbghGVm1gpswEwXecsJy8ysyHlYu5mZFYimm5opS05YZmatQLWbBM3MLN9FQIUHXZiZWb7zjcNmZlYw3CRoZmZ5z6MEzcysYHiUoJmZ5b9wH5aZmRWAACpdwzIzs3znPiwzMysYTlhmZpb3fB+WmZkVDN+HZWZm+S/cJGhmZgUggMpqjxI0M7M85z4sMzMrGOGEZWZmhcCDLszMLO+FB12YmVlhEFVFMOii8N+BmZk1KEKNejWWpFJJb0j6e7reXdIzkj5I/3bL2fcySR9KmiTpiJzyPSVNSLfdKKneAFzDsk3ywdubcdQOB2YdRt5SeeE3wzS3qg8mZx1C0WumuQQvBN4FOqfrlwKjIuJqSZem6z+VtBNwMrAz0Bd4VtL2EVEFDAfOAl4B/gkcCTxZ1wVdwzIzK3aR9GM15tUYkvoDXwb+L6f4OOCudPku4Pic8vsjYmVEfAR8COwtqQ/QOSJejogA7s45plauYZmZtQJNPErw98BPgE45Zb0jYiZARMyUtHla3o+kBlVjelpWkS6vW14n17DMzIpcsEF9WD0ljc15nZV7LklHA7MjYlwjL19bpox6yuvkGpaZWdETVdWNrmHNiYih9WzfHzhW0peAdkBnSX8BZknqk9au+gCz0/2nA1vmHN8fmJGW96+lvE6uYZmZtQJNNUowIi6LiP4RMZBkMMW/IuKbwOPA6elupwOPpcuPAydLKpe0NTAIGJM2Hy6WNCwdHXhazjG1cg3LzKzIJQMqmn3E6tXACEnfAaYCJybXjnckjQAmApXA99MRggDnAncC7UlGB9Y5QhCcsMzMWoXmmOkiIkYDo9PlucBhdex3JXBlLeVjgcGNvZ4TlplZK9DYIev5zAnLzKwV8GztZmaW9/w8LDMzKwwtM+ii2TlhmZm1Bu7DMjOzQlDUNSxJN1FPTo6IC5olIjMza3LFPkpwbItFYWZmzSYCogge4FhnwoqIu3LXJXWMiKXNH5KZmTW1YqhhNZhyJe0raSLJg7qQtKukW5o9MjMzazrRyFcea0wd8ffAEcBcgIh4EzioGWMyM7Mm1biJb/N9YEajRglGxLRkMt3Vqura18zM8lCe154aozEJa5qk/YCQ1Ba4gLR50MzMCkCR3DjcmCbBc4Dvkzy6+BNgt3TdzMwKRahxrzzWYA0rIuYAp7ZALGZm1lyKoEmwMaMEt5H0hKTPJM2W9JikbVoiODMzayKtZJTgfcAIoA/QF3gQ+GtzBmVmZk0oKIomwcYkLEXEPRFRmb7+Qt7nYTMzyxXRuFc+q28uwe7p4nOSLgXuJ0lUJwH/aIHYzMysqeR5MmqM+gZdjCN5izV1xLNztgXwq+YKyszMmpaq87u5rzHqm0tw65YMxMzMmkkBDKhojEbNdCFpMLAT0K6mLCLubq6gzMysKeX/gIrGaDBhSfoFcDBJwvoncBTwIuCEZWZWKIqghtWYUYJfAw4DPo2IbwO7AuXNGpWZmTWtIrgPqzFNgssjolpSpaTOwGzANw5bi2vTtprf3vsWbdpWU1oKLz7dg7/cNACAY785g2O+OZOqSjHm+W7c8dutKWtTzfm//JBBg5cQAbdeuQ0TxnTN9k20kJKS4Ia/vsbc2eVcfv6uABxzyjSOOeUTqirFa//uwR3Xb7d6/15brODWR1/l3uFb8/BdW2UVdov44e+mss/hi1kwp4yzD91hrW1fO2c23/ufmZw4eGcWzUu+Hk/6wSyOPGUeVdVi+M/7Mu75zlmEvWkCKOZBFznGSuoK3E4ycnAJMKahgyRdAJwLvB4RTTK1k6SBwH4RcV+6PhQ4LSIuaIrz51xnCjA0nZaq2UkaDfw4IjJ7yrOkvsCNEfG1rGJoSMUqcenpu7BiWSmlZdVce99bjH2hG23bVTPssLmcd8zuVFSU0KX7KgCOPPFTAM47dg+6dF/Fr25/hwu/tltRTALakONOnca0jzrSoWMlAEP2ms+wQ+Zw3lf3pjLnM6px1k8+YOyL3Ws7VdEZ+UB3Hv9zTy65Ydpa5b36rmL3gxYza3qb1WVbDVrBwcct4KxDdqB77wqufmAy3zmgE9UF+OWvPK89NUaDTYIRcV5ELIiIW4EvAKenTYMNOQ/4UlMlq9RA4Bs5sY1t6mRVSCQ1atBMY0TEjNqSVVNeY9OJFctKASgrC8rKggjx5VM+ZcRtW1JRkfxzXjivLQBbbbec8a90XV22dHEZgwYvySTyltSj9wr2OmguTz/cZ3XZl7/+CQ/+aQCV63xGAPse8hkzp7dn6n86tnisWXj71c1YPH/9f9ZnXz6DP/1v37Vunt33iIWMfqwrFatKmDWtnBlT2rLD7staMNomVARNgnUmLEl7rPsCugNl6XKdJN1K0mz4uKSLJV0u6cc529+WNDB9vSvpdknvSBopqX26z3aSnpX0pqTXJW0LXA0cKGl8et6DJf093b+7pEclvSXpFUlD0vLLJd0habSkyWnNryaORyWNS699VkMflqQlkq5MY3pFUu+0vJekhyS9lr72T8s7ptd+TdIbko5Ly9tLuj+N9QGg5j2XSroz/XwmSLq4lhjulPQ7Sc8B10jaVtJT6fv4t6Qdc/a7NS17X9LRafnAtOz19LVfTvnb6fIZkh6U9AQwsqHPpSWVlAQ3P/oGf33pVd54qSuT3upEv4HLGTx0IdePGM9v7nmL7XdZDMBH73Vk38PmUlIa9O6/gu12XkKvPiszfgfN7+yffMAdv9t2rVpA3wHL2HnPBVx/71iuueN1Bu28CIDy9lV87cyPuW/4wIyizQ/DvriQOZ+2YfLE9muV9+xTwWcz1iT3OTPb0mOLipYOz1L1/Xq+rp5tARxa58aIcyQdCRwSEXMkXV7PuQYBp0TE9ySNAL4K/AW4F7g6Ih6R1I4kuV5K0nRW8+V7cM55fgm8ERHHSzqUZBTjbum2HYFDgE7AJEnDI6ICODMi5qVJ8jVJD0XE3Hpi7Qi8EhE/k/Qb4HvA/wI3ANdHxIuStgKeBj4H/Az4V0ScmTarjpH0LMlN2MsiYkiaWF9Pz78b0C8iBqfvr2sdcWwPHB4RVZJGAedExAeS9gFuYc3/NwOBzwPbksxYsh1JH+QXImKFpEEk80IOreUa+wJDImLeuhvS5H4WQDu17K/y6mrxg+N3p2OnSv77D+8yYNBSSkuDzTpXcvHXd2X7XZZw2e/f49uHDeXph3qz5bbLuPGh8cyeUc67b3SmqqrwmnI2xN4HzWHBvLZ8+G5ndhk6f3V5aVmwWadKLj51T7YfvJjLrn2bM4/al2+eN5lH79mSFcvzqCLdwsrbV3PKBbO57JRauuZr++eS57WQujRVk2D6ffwCyeC7MuBvEfGLdHakB0i+d6YAX4+I+ekxlwHfIXn47wUR8XRavidwJ8mP9n8CF0bUPUFUfTcOH7Kpb6yRPoqI8enyOGCgpE4kX9yPpLGsAJDq/bI5gCTZERH/ktRDUpd02z8iYiWwUtJsoDcwHbhA0lfSfbYkSZ71JaxVwN9zYv1Cunw4sFNOfJ3T9/BF4Nic2mU7YCvgIODGNNa3JL2Vbp8MbCPpJpLpr+qq3TyYJqvNgP2AB3OunTuCc0REVAMfSJpMkrg/Am6WtBvJP57t67jGM7UlqzTm24DbALqU9szkP9+li8t469UuDD1wPnNmteX/PdMDEO9P6ERUiy7dKlk4vw23/XrNl9B1f32TGVPa133SIrDTbgsZdvAc9jpgLm3Kq+nQsZIfX/UOc2aV89KoXoB4/+3ORDV07lbBDrss4oDDP+PMi/9Dx06VRMCqlSX8/f7+Wb+VFtNnwEq22GoVw5+dBECvPhX84en3ueBLg5gzow29+q7p7+vZZxVzZ7Wp61T5ren6blcCh0bEEkltgBclPQmcAIyKiKuVTOd3KfBTSTsBJwM7k0yg/qyk7SOiChhO8uP3FZKEdSTwZF0XbqmfVZWs3fzYLmc5t42miiTTbswnW99voXWvUZbWzg4H9o2IZUoGPrSjfhU52b+KNZ9fSXqe5WsFlGSRr0bEpHXKc2NbE2zEfEm7AkeQPCTz68CZtcSxNOe6CyJitzriXfcaAVwMzCK5PaEEWFHHsUvrKM9Ml24VVFaKpYvLaFtexe77LeDB2/uzfFkpuw1byIQxXek3cDllbapZOL+M8nZVIFi5vJTd95tPVZWY+p8OWb+NZnXnjdty543bArDL0Pl89fSpXPtfO/OlEz9h173nM2FsN/oNWEZZm2DR/Db85Iw9Vx976rmTWb6srFUlK4Ap77XnpCE7r16/69WJnH/U9iyaV8YrI7tw6R8+5uHbetG9dwX9tl7FpDcK8N9QANVNdKrkO7CmM7hN+grgOJJ7dgHuAkYDP03L708rDR9J+hDYW8ngts4R8TKApLuB48mDhDUFqGnG2wOod9qniFgkabqk4yPiUUnlQCmwmKRZrzYvkDxo8ldpMpqTnqeuy3QB5qfJakdg2Ia9pbWMBH4A/BZA0m5prfFp4HxJ50dESNo9It7IifU5JbOI1PS39QRWRcRDkv5DUlWuU/r+PpJ0YkQ8mCbIIRHxZrrLiZLuIvm8twEmpe97enqrwukkn2tB6Lb5Kn589fuUlAYS/PupnowZ3Z2yNtVcfNUHDH/idSorxHWXbg+ILj0quPJP71BdDXNnteXan9RVmSx+Ix/pw0VXvMstD79KZYX43c8/x8b9Lix8l97yMUP2XUKX7pX8ZexE7rmuN0//tUet+378fjteeKIrt42eRFWVuPm/+hXkCEHYoCbBnpJyRyzflraqrDmXVErSyrQd8IeIeFVS74iYCRARMyVtnu7ej6QGVWN6WlaRLq9bXqeWSlgPAadJGg+8BrzfiGO+BfxR0hUkb+xE4C2gUtKbJF/mb+Tsfznw57R5bRlwegPnfwo4J91/Emt/oBvqAuAP6bnKSBLSOSQTBP8eeCtNJlNIEvfwnFjHs+Y2gX5peU1t9LJGXPtUYLikn5P80rkfqElYk4DnSZpAz0n7rW4BHpJ0IvAceViTqsuUSR35wVd2X6+8sqKE316yw3rlsz9px/eO3HO98tZiwthuTBjbDYDKyhKu/a+d693/3uGt4/bKq88bUO/20/fZaa31v97Ym7/e2Ls5Q2oZjU9YcyKitn7tNadKmvN2S/vZH0l/eNelrtavDe4hVD39W8kOyRftqcA2EXFFOqhgi4ho8F4sy46kO4G/R8TfmvM6XUp7xrDNjm3OSxQ0lbdteKdWrmpOfd3GBvBs/G1cQ0mkPuVbbhn9L1xv0HGtJl/yow26lpLp+5aSDEI7OK1d9QFGR8QO6YALIuLX6f5Pk1QwpgDPRUTNyOZT0uPPXv8qicZMzXQLyYixU9L1xcAfGvtmzMwsW4rGvxo8V3IbT9d0uT3JWID3gMdZ07J1OvBYuvw4cLKkcklbkwxuG5M2Hy6WNCytGJ2Wc0ytGtMkuE9E7CHpDVg9MMA/G/NcRJyRdQxmlkearu+tD3BX2o9VQjIa+e+SXgZGSPoOMJWkG4eIeCe9ZWkiyQC876dNipDMhnQnyWC7J6lnwAU0LmFVpIEFJNmVJhtvYmZmLaGp7sOKiLeA9TqT03tYD6vjmCuBK2spHwvU1/+1lsY0Cd4IPAJsLulKkkeLXNXYC5iZWR4ogqmZGqxhRcS9ksaRZE4Bx0fEu80emZmZNY1G9k/lu8Y8wHErkmHiT+SWRcTU5gzMzMyaUGtIWCRTBNWMmW9HchPqJJJpNszMrBC0hoQVEbvkrqczVdQ5Tt7MzPJPq2gSXFdEvC5pr+YIxszMmklrSFiSfpizWgLsAXzWbBGZmVnTai2DLlh7stlKkj6th5onHDMzaxbFnrDSG4Y3i4hLWigeMzNrDsWcsCSVRURlOsjCzMwKlCj+JsExJP1V4yU9DjxIzqMoIuLhZo7NzMyaQoCKYEK9xvRhdSd5bPyhrLkfKwAnLDOzQlHkNazN0xGCb7P+w7aK4K2bmbUiRfCtXV/CKgU2YyOeCmlmZvml2PuwZkbEFS0WiZmZNZ8iT1hN9rQvMzPLUCsYdFHrg7jMzKwAFXMNKyLmtWQgZmbWfIq9D8vMzIqFE5aZmeW9wAnLzMzynyiOUXROWGZmrUCxjxI0M7Ni4SZBMzMrCE5YZmaW91rRE4fNzKzQOWGZmVkhcA3LrLwtbNM/6yjyVtVb72UdQt6b88T2WYeQ/47e9FMUwyjBkqwDMDOzZhYb8GqApC0lPSfpXUnvSLowLe8u6RlJH6R/u+Ucc5mkDyVNknRETvmekiak226UVO/tYk5YZmatQRMlLKAS+FFEfA4YBnxf0k7ApcCoiBgEjErXSbedDOwMHAncIqk0Pddw4CxgUPo6sr4LO2GZmRU5kfRhNebVkIiYGRGvp8uLgXeBfsBxwF3pbncBx6fLxwH3R8TKiPgI+BDYW1IfoHNEvBwRAdydc0yt3IdlZtYaNH7QRU9JY3PWb4uI22rbUdJAYHfgVaB3RMyEJKlJ2jzdrR/wSs5h09OyinR53fI6OWGZmRW7AFU3OmPNiYihDe0kaTPgIeCiiFhUT/dTbRuinvI6uUnQzKwVaKomQQBJbUiS1b0R8XBaPCtt5iP9Ozstnw5smXN4f2BGWt6/lvI6OWGZmbUGTTdKUMCfgHcj4nc5mx4HTk+XTwceyyk/WVK5pK1JBleMSZsPF0salp7ztJxjauUmQTOzVqAJbxzeH/gWMEHS+LTsv4CrgRGSvgNMBU4EiIh3JI0AJpKMMPx+RFSlx50L3Am0B55MX3VywjIzaw2aKGFFxIvU/Xitw+o45krgylrKxwKDG3ttJywzs2LnyW/NzKwQiOKYmskJy8ysNYjCr2I5YZmZtQJuEjQzs/zX+HkC85oTlplZK+A+LDMzKwyuYZmZWd7bsLkE85YTlplZK+BBF2ZmVhicsMzMLN/VPMCx0DlhmZkVuwjfOGxmZoXBw9rNzKwguEnQzMzyXwAe1m5mZgWh8POVE5aZWWvgJkEzMysMHiVoZmZ5LzxK0MzMCkBy47BrWGZmVghcwzIzs0LgGpZZCzvuuEkceeRkpOCpp7bl0Ud3WL3tq199j+9+dzwnnfQVFi0qp7S0mosuGsO2286ntDQYNWogI0bslGH0ze+H101ln8MXsWBOGWcftiMA/zV8Cv23XQFAx85VLF1UynlfTLZt/bnlXHDNNDpuVk11NZz/5e2pWFmSWfzNqiro+sOpVHcvY9Ev+qHFVXT6zUxKZ1VQ1bsNi3/ah9isFID2D86j3TMLiRJYetbmVOzREVZU0/mamZTMXAUlYtXeHVl2Rq+M31Qj+YnD1hiSfgt8CfhnRFzSROfcDegbEf9M148FdoqIq5vi/DnXWRIRmzXlOTfFgAELOPLIyVx00ReoqCjhf//3ecaM6cuMGZ3o2XMpu+/+KbNmdVi9/4EHTqVNm2rOO+8oyssr+eMf/8no0Vsxe3bevKUmN3JEdx7/c08uuWHq6rKrzh24evms//mEpYuSL+WS0uAnN37Mby8cwOSJ7enUrZKqCrV0yC2m3RMLqOzflpJlSdtY+7/No2JIBxad2J32D86j/d/mseyMXpROXUn5C4uY/4cBlMytost/T2f+rQMBWP6VblQM6QAVQZefT6fN2KVUDO2Y4btqrOKYS7BIf0rllbOBPZoqWaV2I0mCAETE402drPLRllsu4r33erByZRnV1SVMmNCL/fabDsDZZ7/Bn/6061r7R4h27SopKammbdsqKipKWbasTRaht5i3X92MxQtK69gaHHTMAp57rBsAe35+MR+9257JE9sDsHh+GdXVxZmwSuZU0Pa1Jaz8YpfVZW1fXcKKwzoDsOKwzrR9ZUlavpSVB3WGNiVUb9GGqj5tKPtgBbQrSZIVQBtRuW05JXMrWvy9bCxVR6Ne+cwJC5A0UNK7km6X9I6kkZLap9t2k/SKpLckPSKpW1o+WtI1ksZIel/SgbWc93GgI/CqpJMk3Snpaznbl6R/D07P9zdJ70m6V5LSbXtJeknSm+m1ugBXACdJGp+e9wxJN6f7D5A0Ko13lKSt0vI7Jd2YnmtyTRySNkv3e13SBEnHNednvSk+/rgLgwd/RqdOKykvr2SvvWbSq9cy9tnnE+bM6cBHH3Vba/8XX9ySFSvKuO++x7j77sd5+OEdWLKkPKPoszd4n6XM/6yMGR8ln0H/bVYQwJX3/oebn5rEiefOyjbAZtTx9s9Y+u1ea33jlSyoIronjUzRvYySBVVJ+dwKqnuuaXyq7llGydzKtc6nJVW0HbOUil07UBDSYe2NeeUzJ6w1BgF/iIidgQXAV9Pyu4GfRsQQYALwi5xjyiJib+CidcoBiIhjgeURsVtEPNDA9XdPz7MTsA2wv6S2wAPAhRGxK3A4sBT4H+CBOs57M3B3Gu+9wI052/oABwBHAzU1shXAVyJiD+AQ4LqaZJlvpk3rwoMP7shVV43mV796nsmTu1JVJU4++R3uuWfwevvvsMNcqqvFqacexxlnHMMJJ0xiiy2WZBB5fjjk+PmMfmxNUi8thcF7LeWaHwzgR8cPYr+jFrLbAYszjLB5tBmzhOoupVRt165xBzRUyagKOv12JsuP6Ur1Fm03Ob4WU/OIkYZeecx9WGt8FBHj0+VxwMC0NtM1Ip5Py+8CHsw55uHc/Tfx+mMiYjqApPHp+RYCMyPiNYCIWJRur+88+wInpMv3AL/J2fZoRFQDEyX1TssEXCXpIJKBr/2A3sCndV1A0lnAWQDt2nSpa7dmMXLktowcuS0Ap5/+JgsWtOOQQz7mllueAqBnz+XcdNPTXHTRFzj44I8ZO3YLqqpKWLiwHRMn9mTQoHl8+mnx9mHVpaQ02P+ohfzgqO1Xl302sw1vvdKRRfOTr4HX/tWZ7QYvZ/yLnbIKs1m0eXc5bccspe24yWhVoGXVbHbdTKq7lqJ5lUT3MjSvkuquSVNqdc82lMxZU6MqmVNJdY81X5Wb3TyLqr5tWXFct/WuldfyOxc1imtYa6zMWa6iccm85pjG7l9J+pmntZjcn2e1XV9s+j+z3ONzr1GT9U4FegF7RsRuwCyg3p+iEXFbRAyNiKFty1q2SaRLl2S0W69eS9l//+mMGrU1p5zyFc4441jOOONY5sxpz/nnH8H8+e357LOO7LrrbCAoL69kxx3nMm1a5xaNN1/sceBipn1YzpyZa/7JjXu+E1t/bgXl7aopKQ2GDFvC1A+Kr8l02em9mH/nNsz/0zYs/kkfKoZ0YMmP+rBq781oN2oRAO1GLWLVPskPmVV7d6T8hUVQUU3JpxWUzqigclDyn0SHe+agpdUs/V6BjA7MoYhGvRo8j3SHpNmS3s4p6y7pGUkfpH+75Wy7TNKHkiZJOiKnfM+0G+LDtLuiwZYd17DqERELJc2XdGBE/Bv4FvB8Q8fVYwqwJzACOA5oaATAe0BfSXtFxGuSOgHLgcVAXT+DXwJOJqldnQq82MA1ugCzI6JC0iHAgMa8kaz8/Ocv0rnzKiorS7jllj1ZsqTuJpknntiOH/5wDLfe+iQSjBy5NVOmdG25YDNw6R+mMGTfJXTpXslfxr7DPdduwdP39+Dzx63dHAiwZGEZD9/Wi5v++T4RMOZfnRkzqmVrzFla/rXudLpmBu2eWUhVrzIWX9oXgKoB5aw8oBPdzvuYKIUl52wOpaJkTgUdRsyjsn9bul6UjMJc/uWurDyiAD6zAKqarIp1J2nXQ07ZpcCoiLha0qXp+k8l7UTyfbQz0Bd4VtL2EVEFDCdpqXkF+CdwJPBkfRd2wmrY6cCtkjoAk4Fvb8K5bgcekzQGGEXSH1WniFgl6STgpnQQyHKSfqzngEvTpsNfr3PYBcAdki4BPmtEvPcCT0gaC4wnSZJ565JLDq93+xlnHLt6ecWKNlx11f7NHVJeufr7A2stv+7i2n+H/Ovh7vzr4e7NGFF+qdilAxW7JK0C0bmURVduWet+y0/qwfKTeqxVVt2zDXOe2L7W/fOdaFztqTEi4gVJA9cpPg44OF2+CxgN/DQtvz8iVgIfSfoQ2FvSFKBzRLwMIOlu4HicsBoWEVOAwTnr1+YsjweG1XLMwTnLc6ijDyv3PqaImLXOuS5Ly0eT/B9cs98PcpZfq+36wF7rrN+Z814OrSWOM2qLK41934ZiN7MC1/iE1TP9AVvjtoi4rYFjekfEzOQyMVPS5ml5P5IaVI3paVlFurxueb2csMzMWoPGJ6w5ETG0ia5aW79U1FNeLw+6MDMrdkEyBrgxr40zS1IfgPTv7LR8OpDb7tofmJGW96+lvF5OWGZmrUBTjRKsw+Mk/f2kfx/LKT9ZUrmkrUnudx2TNh8uljQsHR14Ws4xdXKToJlZ0QuobpppLCT9lWSARU9J00kmTbgaGCHpO8BU4ESAiHhH0ghgIsltPd9PRwgCnEvS996eZLBFvQMuwAnLzKz4BU02i0VEnFLHpsPq2P9K4MpayseSM9itMZywzMxagzyfJ7AxnLDMzFoBP8DRzMwKgxOWmZnlvQioKvw2QScsM7PWwDUsMzMrCE5YZmaW9wKodsIyM7O8FxDuwzIzs0LgJkEzM8t7gUcJmplZgXANy8zM8l84YZmZWQEImmy29iw5YZmZtQauYZmZWUFwwjIzs7wXQVRVNbxfnnPCMjNrDTzThZmZFQQ3CZqZWd6L8ChBMzMrEK5hmZlZ/vOgCzMzKwR+vIiZmRUMP17EzMzyXQDhGpaZmeW98AMczcysQBRDDUtRBEMdLTuSPgM+zjqOHD2BOVkHkef8GdUvHz+fARHRa2MPlvQUyftqjDkRceTGXqs5OWFZUZE0NiKGZh1HPvNnVD9/PvmrJOsAzMzMGsMJy8zMCoITlhWb27IOoAD4M6qfP5885T4sMzMrCK5hmZlZQXDCMjOzguCEZVbEJJVKejbrOMyagme6sIIlqXt92yNiXkvFkq8iokrSMkldImJh1vHkE0mLSabZW28TEBHRuYVDsgY4YVkhG0fyhaNatgWwTcuGk7dWABMkPQMsrSmMiAuyCyl7EdEp6xhswzhhWcGKiK2zjqFA/CN9WT0kbQ60q1mPiKkZhmO18LB2KwqSugGDWPsL54XsIrJCIelY4DqgLzAbGAC8GxE7ZxqYrcc1LCt4kr4LXAj0B8YDw4CXgUMzDCtzkkZExNclTaCWvpqIGJJBWPnoVyT/Zp6NiN0lHQKcknFMVgsnLCsGFwJ7Aa9ExCGSdgR+mXFM+eDC9O/RmUaR/yoiYq6kEkklEfGcpGuyDsrW54RlxWBFRKyQhKTyiHhP0g5ZB5W1iJiZ/s2nx7/kowWSNgNeAO6VNBuozDgmq4Xvw7JiMF1SV+BR4BlJjwEzMo0oj0gaJuk1SUskrZJUJWlR1nHlkeOA5cDFwFPAf4BjMo3IauVBF1ZUJH0e6AI8FRGrso4nH0gaC5wMPAgMBU4DtouIn2UamNkGcg3LikI6o0Nf4COSgRdbZBtRfomID4HSiKiKiD8Dh2QdU76QdIKkDyQtlLRI0mLXQPOT+7Cs4Ek6H/gFMAuoTosD8Ci4xDJJbYHxkn4DzAQ6ZhxTPvkNcExEvJt1IFY/NwlawZP0IbBPRMzNOpZ8JGkASTJvS9JP0wW4Ja11tXqS/l9E7J91HNYwJywreJKeA74QER7ZVYe0hrUjSc1zkvv31pB0A0kT8qPAypryiHg4q5isdm4StGIwGRgt6R+s/YXzu+xCyh+SvgzcSjL6TcDWks6OiCezjSxvdAaWAV/MKQvACSvPuIZlBU/SL2orjwjfPAxIeg84uqYJUNK2wD8iYsdsIzPbMK5hWcGrSUySOiWrsSTjkPLN7HX6qyaTzJlngKT+wE3A/iQ1qxeBCyNieqaB2Xo8rN0KnqTBkt4A3gbekTROkicuXeMdSf+UdIak04EngNfS4dwnZB1cHvgz8DjJ5Lf9SD6fP2cakdXKTYJW8CS9BPwsIp5L1w8GroqI/bKMK19Iqu/LNyLizBYLJg9JGh8RuzVUZtlzk6AVg441yQogIkZL8n1GqYj4dtYx5Lk5kr4J/DVdPwXwLRJ5yE2CVgwmS/pvSQPT189JZrwwQNL2kkZJejtdH5J+RpY4E/g68CnJTdVfS8ssz7hJ0Ape+vDGXwIHkAzbfgG4PCLmZxpYnpD0PHAJ8MeI2D0tezsiBmcbmdmGcZOgFbw0MV2QdRx5rENEjJGUW9bqb7KW9JOI+I2km6j9AZf+N5VnnLCsYEn6fURcJOkJav/COTaDsPLRnPTeqwCQ9DWSpq/WrmbuwLGZRmGN5oRlheye9O+1mUaR/74P3AbsKOkTkv69U7MNKXsR8US6uCwiHszdJunEDEKyBrgPywqepAsj4oaGylojSaXA1RFxSTpysiQiFmcdVz6R9HpE7NFQmWXPCcsKXh1fOG/UDDBo7ST9KyIOzTqOfCPpKOBLJCMEH8jZ1BnYKSL2ziQwq5ObBK1gSToF+AbJZK6P52zqhO+jyfVG+vk8CCytKfRs5Mwg6b86FhiXU76Y5DEslmdcw7KClT7naWvg18ClOZsWA2/5cSOJOma6aPUzXNSQ1BlYGhFV6XopUB4Ry7KNzNblhGUFT9I2wIyIWJGutwd6R8SUTAOzgiDpFeDwmkmTJW0GjPTUXvnHM11YMRgBVOesV5E0f5k1RrvcGf7T5Q4ZxmN1cMKyYlCW+wTddLlthvFYYVkqafWgHUl7AsszjMfq4EEXVgw+k3RsRDwOIOk4YE7GMVnhuAh4UNKMdL0PcFJ24Vhd3IdlBS+dxeFekucZCZgGnLbOQwtbLUkXkjzfaTHwf8DuwKURMTLTwPKIpDbADiT/ft6LiIqMQ7JaOGFZ0Ug7y+UbY9cm6c2I2FXSESSzXvw38GffGLuGpP2AgeS0OkXE3ZkFZLVyk6AVPEnlwFdJv3BqJnmNiCsyDCuf1Mx6+yWSRPWm1pkJtzWTdA+wLTCeZMAOJPMuOmHlGScsKwaPAQtJbv5cmXEs+WicpJEk96xdJqkTa4+qbO2Gksxs4eamPOeEZcWgf0QcmXUQeew7wG7A5IhYJqkH4KcQr/E2sAWewT7vOWFZMXhJ0i4RMSHrQPJJ7lDt1DZuCaxVT2CipDHk1ND9eJr840EXVvAkTQS2I3lsxkqSPpuIiCGZBpYxSc+li+2APYG3SD6bIcCrEXFAVrHlE0mfr608Ip5v6Visfk5YVvDSOQXXExEft3Qs+UjS/cCVNTVQSYOBH0fEGZkGZraB3CRoxcC/uuq3Y25zaUS8LWm3DOPJK5IWs+bfUFugDclkuJ2zi8pq44RlxeAfJF84Imn+2hqYBOycZVB55F1J/wf8heRz+iZrHg/f6kVEp9x1SccDfhZWHnKToBWddLDB2RFxdtax5ANJ7YBzgYPSoheA4TWz29v6JL0SEcOyjsPW5oRlRcmPOF9b+siVrSJiUtax5BtJJ+SslpDcl/X5iNg3o5CsDm4StIIn6Yc5qyUkI+I+yyicvCPpWOC3JP0zW6f9V1d42PZqx+QsVwJTgOOyCcXq4xqWFSxJ90TEtyQtAK5Pi2u+cB5yk1dC0jjgUGB0ROyelr3lYf+6JiJ+KunrETEi63isYa5hWSHbMx3SPhW4aZ1tHQAnrERlRCz0TcPr+ZKknwOXkjwE1PKcE5YVsluBp0hGBY7NKRfJaLhtsggqD70t6RtAqaRBwAXASxnHlA+eInluWkdJi3LKa24897D2POMmQSt4koZHxLlZx5GvJHUAfgZ8MS16GvhfN5kmJD0WEe6zKgBOWGathKSOEbE06zjMNlZJ1gGYWfOStF863+K76fqukm7JOCyzDeaEZVb8rgeOAOYCRMSbrLmJ2KxgOGGZtQIRMW2doqpadzTLYx4laFb8pknaDwhJbUlGCXouwZSk/YHLgQEk34k1owQ9yjTPeNCFWZGT1BO4ATic5Mt4JHBhRMzNNLA8Iek94GJgHDk1T38++ccJy8xaNUmvRsQ+WcdhDXPCMityknoB3wMGktMNEBFnZhVTPpF0NVAKPEzyxGoAIuL1zIKyWrkPy6z4PQb8G3gWD7aoTU3tamhOWZDMv2h5xDUssyInaXxE7JZ1HGabysPazYrf3yV9Kesg8pWkLpJ+J2ls+rpOUpes47L1uYZlVuQkLQY6kvTPVODJXdci6SHgbeCutOhbwK4RcULdR1kWnLDMrFWrrcnUzaj5yU2CZtbaLZd0QM1KeiPx8gzjsTq4hmVmrZqkXYG7gS4kzaXzgDPSORctjzhhmZkBkjoDRMSihva1bDhhmRUpSd3r2x4R81oqlnwmqRz4KuvfWH1FVjFZ7XzjsFnxGkdyA6xq2RaAJ3dNPAYsJPm8Vjawr2XINSwza9UkvR0Rg7OOwxrmGpZZKyCpGzAIaFdTFhEvZBdRXnlJ0i4RMSHrQKx+rmGZFTlJ3wUuBPoD44FhwMsR4bnyAEkTge2Aj0iaBGturB6SaWC2HtewzIrfhcBewCsRcYikHYFfZhxTPjkq6wCscZywzIrfiohYIQlJ5RHxnqQdsg4qX0TEx1nHYI3jhGVW/KZL6go8CjwjaT4wI9OIzDaC+7DMWhFJnyeZ0eGpiFiVdTxmG8IJy6wVkFQK9GbtG2OnZheR2YZzk6BZkZN0PvALYBZQnRYH4FFwVlBcwzIrcpI+BPaJiLlZx2K2Kfx4EbPiN41k6iGzguYmQbPiNxkYLekf5MyVFxG/yy4ksw3nhGVW/Kamr7bpy6wguQ/LrJWQ1IlkyqElWcditjHch2VW5CQNlvQG8DbwjqRxknbOOi6zDeWEZVb8bgN+GBEDImIA8CPg9oxjMttgTlhmxa9jRDxXsxIRo4GO2YVjtnE86MKs+E2W9N/APen6N0kepWFWUFzDMit+ZwK9gIeBR9Llb2cakdlG8ChBMzMrCG4SNCtSkn4fERdJeoJk7sC1RMSxGYRlttGcsMyKV02f1bWZRmHWRJywzIpURIxLF3eLiBtyt0m6EHi+5aMy23gedGFW/E6vpeyMlg7CbFO5hmVWpCSdAnwD2FrS4zmbOgF+1IgVHCcss+L1EjAT6Alcl1O+GHgrk4jMNoGHtZsVOUnbADMiYkW63h7oHRFTMg3MbAO5D8us+I0AqnPWq4AHM4rFbKM5YZkVv7KIWFWzki77uVhWcJywzIrfZ5JW3yQs6ThgTobxmG0U92GZFTlJ2wL3An0BAdOA0yLiw0wDM9tATlhmrYSkzUj+m1+cdSxmG8MJy6zISSoHvgoMJOdWloi4IquYzDaG78MyK36PAQuBccDKjGMx22iuYZkVOUlvR8TgrOMw21QeJWhW/F6StEvWQZhtKtewzIqcpInAdsBHJE2CAiIihmQamNkGcsIyK3KSBtRWHhEft3QsZpvCgy7Mip9/lVpRcA3LrMhJmkCStAS0A7YGJkXEzpkGZraBXMMyK3IRsdaAC0l7AGdnFI7ZRvMoQbNWJiJeB/bKOg6zDeUallmRk/TDnNUSYA/gs4zCMdtoTlhmxa9TznIl8A/goYxiMdtoTlhmRUrSPRHxLWBBRNyQdTxmm8qjBM2KVHrD8FHA48DBJKMEV4uIeRmEZbbRXMMyK163Ak8B25BMfJubsCItNysYrmGZFTlJwyPi3KzjMNtUTlhmZlYQfB+WmZkVBCcsMzMrCE5YZs1MUpWk8ZLelvSgpA6bcK47JX0tXf4/STvVs+/BkvbbiGtMkdSzseXr7LNkA691uaQfb2iM1jo5YZk1v+URsVv61N9VwDm5GyWVbsxJI+K7ETGxnl0OBjY4YZnlKycss5b1b2C7tPbznKT7gAmSSiX9VtJrkt6SdDaAEjdLmijpH8DmNSeSNFrS0HT5SEmvS3pT0ihJA0kS48Vp7e5ASb0kPZRe4zVJ+6fH9pA0UtIbkv7IOvdr1UbSo5LGSXpH0lnrbLsujWWUpF5p2baSnkqP+bekHZvk07RWxfdhmbUQSWUkN/I+lRbtDQyOiI/SL/2FEbGXpHLg/0kaCewO7ADsAvQGJgJ3rHPeXsDtwEHpubpHxDxJtwJLIuLadL/7gOsj4kVJWwFPA58DfgG8GBFXSPoysFYCqsOZ6TXaA69Jeigi5gIdgdcj4keS/ic99w+A24BzIuIDSfsAtwCHbsTHaK2YE5ZZ82svaXy6/G/gTyRNdWMi4qO0/IvAkJr+KaALMAg4CPhrRFQBMyT9q5bzDwNeqDlXPTNYHA7sJK2uQHWW1Cm9xgnpsf+QNL8R7+kCSV9Jl7dMY50LVAMPpOV/AR6WtFn6fh/MuXZ5I65hthYnLLPmtzwidsstSL+4l+YWAedHxNPr7PclGn5isBqxDyRdAPtGxPJaYmn0DZmSDiZJfvtGxDJJo0keDFmbSK+7YN3PwGxDuQ/LLD88DZwrqQ2ApO0ldQReAE5O+7j6AIfUcuzLwOclbZ0e2z0tX8zaM7WPJGmeI91vt3TxBeDUtOwooFsDsXYB5qfJakeSGl6NEqCmlvgNkqbGRcBHkk5MryFJuzZwDbP1OGGZ5Yf/I+mfel3S28AfSVpAHgE+ACYAw4Hn1z0wIj4j6Xd6WNKbrGmSewL4Ss2gC+ACYGg6qGMia0Yr/hI4SNLrJE2TUxuI9SmgTNJbwK+AV3K2LQV2ljSOpI/qirT8VOA7aXzvAMc14jMxW4unZjIzs4LgGpaZmRUEJywzMysITlhmZlYQnLDMzKwgOGGZmVlBcMIyM7OC4IRlZmYFwQnLzMwKwv8H4AI8Yb0rgcQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(model_pipe, X_test, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 83.1% of the funtional wells.\n",
      "The model correctly predicts 47.69% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 78.07% of the non-functional wells.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 100 out of 100 | elapsed:    0.0s finished\n"
     ]
    }
   ],
   "source": [
    "model_predictions(model_pipe, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  this first model is a significant improvement from the first random forest classifer model. the train score increase by $0.0736$. However, the model is still significanly overfitting and that will need to be reduced by hyperparameter tuning. \n",
    "\n",
    "*  the log loss also improved from about $1$ with the first model with only numeric colums to about $0.88$ with all colums included. This was an improvement of about $0.12$.\n",
    "\n",
    "*  the total accuracy score of non-functional and functional needs repairs is $124.97$, which is better than the previous model, but there is till remove for improvement. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# hyperparameter tuning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## the first model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  since the training scores are severly overfitting the test scores in the data, we will first limit the max depth of the tree. this should certainly help to limit overfitting. we will leave other hyperparamters in their default state for now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_pipe_1 = imbPipeline(steps=[\n",
    "    ('trans', trans),\n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('rfc', RandomForestClassifier(verbose=1, n_jobs=-2))\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'memory': None,\n",
       " 'steps': [('trans', ColumnTransformer(n_jobs=-1,\n",
       "                     transformers=[('numerical',\n",
       "                                    Pipeline(steps=[('ss', StandardScaler())]),\n",
       "                                    Index(['gps_height', 'longitude', 'latitude', 'num_private', 'region_code',\n",
       "          'district_code', 'population', 'construction_year'],\n",
       "         dtype='object')),\n",
       "                                   ('categorical',\n",
       "                                    Pipeline(steps=[('ohe',\n",
       "                                                     OneHotEncoder(handle_unknown='ignore'))]),\n",
       "                                    Index(['installer', 'basin', 'region', 'public_meeting', 'scheme_management',\n",
       "          'permit', 'extraction_type', 'management', 'payment', 'water_quality',\n",
       "          'quantity', 'source', 'waterpoint_type'],\n",
       "         dtype='object'))],\n",
       "                     verbose=True)),\n",
       "  ('smote', SMOTE(random_state=42)),\n",
       "  ('rfc', RandomForestClassifier(n_jobs=-2, verbose=1))],\n",
       " 'verbose': False,\n",
       " 'trans': ColumnTransformer(n_jobs=-1,\n",
       "                   transformers=[('numerical',\n",
       "                                  Pipeline(steps=[('ss', StandardScaler())]),\n",
       "                                  Index(['gps_height', 'longitude', 'latitude', 'num_private', 'region_code',\n",
       "        'district_code', 'population', 'construction_year'],\n",
       "       dtype='object')),\n",
       "                                 ('categorical',\n",
       "                                  Pipeline(steps=[('ohe',\n",
       "                                                   OneHotEncoder(handle_unknown='ignore'))]),\n",
       "                                  Index(['installer', 'basin', 'region', 'public_meeting', 'scheme_management',\n",
       "        'permit', 'extraction_type', 'management', 'payment', 'water_quality',\n",
       "        'quantity', 'source', 'waterpoint_type'],\n",
       "       dtype='object'))],\n",
       "                   verbose=True),\n",
       " 'smote': SMOTE(random_state=42),\n",
       " 'rfc': RandomForestClassifier(n_jobs=-2, verbose=1),\n",
       " 'trans__n_jobs': -1,\n",
       " 'trans__remainder': 'drop',\n",
       " 'trans__sparse_threshold': 0.3,\n",
       " 'trans__transformer_weights': None,\n",
       " 'trans__transformers': [('numerical',\n",
       "   Pipeline(steps=[('ss', StandardScaler())]),\n",
       "   Index(['gps_height', 'longitude', 'latitude', 'num_private', 'region_code',\n",
       "          'district_code', 'population', 'construction_year'],\n",
       "         dtype='object')),\n",
       "  ('categorical',\n",
       "   Pipeline(steps=[('ohe', OneHotEncoder(handle_unknown='ignore'))]),\n",
       "   Index(['installer', 'basin', 'region', 'public_meeting', 'scheme_management',\n",
       "          'permit', 'extraction_type', 'management', 'payment', 'water_quality',\n",
       "          'quantity', 'source', 'waterpoint_type'],\n",
       "         dtype='object'))],\n",
       " 'trans__verbose': True,\n",
       " 'trans__numerical': Pipeline(steps=[('ss', StandardScaler())]),\n",
       " 'trans__categorical': Pipeline(steps=[('ohe', OneHotEncoder(handle_unknown='ignore'))]),\n",
       " 'trans__numerical__memory': None,\n",
       " 'trans__numerical__steps': [('ss', StandardScaler())],\n",
       " 'trans__numerical__verbose': False,\n",
       " 'trans__numerical__ss': StandardScaler(),\n",
       " 'trans__numerical__ss__copy': True,\n",
       " 'trans__numerical__ss__with_mean': True,\n",
       " 'trans__numerical__ss__with_std': True,\n",
       " 'trans__categorical__memory': None,\n",
       " 'trans__categorical__steps': [('ohe',\n",
       "   OneHotEncoder(handle_unknown='ignore'))],\n",
       " 'trans__categorical__verbose': False,\n",
       " 'trans__categorical__ohe': OneHotEncoder(handle_unknown='ignore'),\n",
       " 'trans__categorical__ohe__categories': 'auto',\n",
       " 'trans__categorical__ohe__drop': None,\n",
       " 'trans__categorical__ohe__dtype': numpy.float64,\n",
       " 'trans__categorical__ohe__handle_unknown': 'ignore',\n",
       " 'trans__categorical__ohe__sparse': True,\n",
       " 'smote__k_neighbors': 5,\n",
       " 'smote__n_jobs': None,\n",
       " 'smote__random_state': 42,\n",
       " 'smote__sampling_strategy': 'auto',\n",
       " 'rfc__bootstrap': True,\n",
       " 'rfc__ccp_alpha': 0.0,\n",
       " 'rfc__class_weight': None,\n",
       " 'rfc__criterion': 'gini',\n",
       " 'rfc__max_depth': None,\n",
       " 'rfc__max_features': 'auto',\n",
       " 'rfc__max_leaf_nodes': None,\n",
       " 'rfc__max_samples': None,\n",
       " 'rfc__min_impurity_decrease': 0.0,\n",
       " 'rfc__min_impurity_split': None,\n",
       " 'rfc__min_samples_leaf': 1,\n",
       " 'rfc__min_samples_split': 2,\n",
       " 'rfc__min_weight_fraction_leaf': 0.0,\n",
       " 'rfc__n_estimators': 100,\n",
       " 'rfc__n_jobs': -2,\n",
       " 'rfc__oob_score': False,\n",
       " 'rfc__random_state': None,\n",
       " 'rfc__verbose': 1,\n",
       " 'rfc__warm_start': False}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe_1.get_params()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    'rfc__max_depth': list(range(10,100,10))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 9 candidates, totalling 18 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  12 out of  18 | elapsed:  3.2min remaining:  1.6min\n",
      "[Parallel(n_jobs=-2)]: Done  18 out of  18 | elapsed:  4.0min finished\n",
      "[Parallel(n_jobs=-2)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  36 tasks      | elapsed:   17.1s\n",
      "[Parallel(n_jobs=-2)]: Done 100 out of 100 | elapsed:   41.9s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=2,\n",
       "             estimator=Pipeline(steps=[('trans',\n",
       "                                        ColumnTransformer(n_jobs=-1,\n",
       "                                                          transformers=[('numerical',\n",
       "                                                                         Pipeline(steps=[('ss',\n",
       "                                                                                          StandardScaler())]),\n",
       "                                                                         Index(['gps_height', 'longitude', 'latitude', 'num_private', 'region_code',\n",
       "       'district_code', 'population', 'construction_year'],\n",
       "      dtype='object')),\n",
       "                                                                        ('categorical',\n",
       "                                                                         Pipeline(steps=[('ohe',\n",
       "                                                                                          OneHotEncoder(handle_unk...\n",
       "                                                                         Index(['installer', 'basin', 'region', 'public_meeting', 'scheme_management',\n",
       "       'permit', 'extraction_type', 'management', 'payment', 'water_quality',\n",
       "       'quantity', 'source', 'waterpoint_type'],\n",
       "      dtype='object'))],\n",
       "                                                          verbose=True)),\n",
       "                                       ('smote', SMOTE(random_state=42)),\n",
       "                                       ('rfc',\n",
       "                                        RandomForestClassifier(n_jobs=-2,\n",
       "                                                               verbose=1))]),\n",
       "             n_jobs=-2,\n",
       "             param_grid={'rfc__max_depth': [10, 20, 30, 40, 50, 60, 70, 80,\n",
       "                                            90]},\n",
       "             verbose=3)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_1 = GridSearchCV(model_pipe_1, params, n_jobs=-2, verbose=3, cv = 2)\n",
    "gs_1.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 100 out of 100 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9945629130814316"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_1.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 100 out of 100 | elapsed:    0.0s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7856341189674523"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_1.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:   31.3s remaining:    0.0s\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:   31.3s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8528580424974856"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_1 = cross_val_score(model_pipe_1, X_train, y_train, scoring='neg_log_loss', n_jobs = -2, verbose = 3, cv = 2)\n",
    "-cv_1.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:    6.5s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.881934690231128"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_1 = cross_val_score(model_pipe_1, X_test, y_test, scoring='neg_log_loss', n_jobs = -2, verbose = 1, cv = 2)\n",
    "-cv_1.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'rfc__max_depth': 50}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_1.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 100 out of 100 | elapsed:    0.0s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(gs_1, X_test, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 83.09% of the funtional wells.\n",
      "The model correctly predicts 48.1% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 77.94% of the non-functional wells.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 100 out of 100 | elapsed:    0.0s finished\n"
     ]
    }
   ],
   "source": [
    "model_predictions(gs_1, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  this model that limited the max depth of the trees had a slighly better log loss on the test data. the accuracy scores were about the same as the previous model.\n",
    "\n",
    "*  the total accuracy score of non-functional and functional needs repairs is $126.62$, which is a bit lower than the previous model, so now we will begin to change some more hyperparamters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# WARNING: THESE NEXT MODELS WILL TAKE A LONG TIME TO RUN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## model 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  in this second iteration we will still change max depth, but will also change the number of estimators to see how a change in the number of trees would effect the accuracy score. we will also use criterion to see if it has any effect on the score of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_pipe_2 = imbPipeline(steps=[\n",
    "    ('trans', trans),\n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('rfc', RandomForestClassifier(verbose=1, n_jobs=-2))\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    'rfc__max_depth': list(range(10,100,10)),\n",
    "    'rfc__criterion': ['gini', 'entropy'],\n",
    "    'rfc__n_estimators': list(range(50,250,50))   \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 72 candidates, totalling 144 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  18 tasks      | elapsed:  3.1min\n",
      "[Parallel(n_jobs=-2)]: Done 114 tasks      | elapsed: 30.5min\n",
      "[Parallel(n_jobs=-2)]: Done 144 out of 144 | elapsed: 39.5min finished\n",
      "[Parallel(n_jobs=-2)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  36 tasks      | elapsed:   17.2s\n",
      "[Parallel(n_jobs=-2)]: Done 186 tasks      | elapsed:  1.3min\n",
      "[Parallel(n_jobs=-2)]: Done 200 out of 200 | elapsed:  1.4min finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=2,\n",
       "             estimator=Pipeline(steps=[('trans',\n",
       "                                        ColumnTransformer(n_jobs=-1,\n",
       "                                                          transformers=[('numerical',\n",
       "                                                                         Pipeline(steps=[('ss',\n",
       "                                                                                          StandardScaler())]),\n",
       "                                                                         Index(['gps_height', 'longitude', 'latitude', 'num_private', 'region_code',\n",
       "       'district_code', 'population', 'construction_year'],\n",
       "      dtype='object')),\n",
       "                                                                        ('categorical',\n",
       "                                                                         Pipeline(steps=[('ohe',\n",
       "                                                                                          OneHotEncoder(handle_unk...\n",
       "       'permit', 'extraction_type', 'management', 'payment', 'water_quality',\n",
       "       'quantity', 'source', 'waterpoint_type'],\n",
       "      dtype='object'))],\n",
       "                                                          verbose=True)),\n",
       "                                       ('smote', SMOTE(random_state=42)),\n",
       "                                       ('rfc',\n",
       "                                        RandomForestClassifier(n_jobs=-2,\n",
       "                                                               verbose=1))]),\n",
       "             n_jobs=-2,\n",
       "             param_grid={'rfc__criterion': ['gini', 'entropy'],\n",
       "                         'rfc__max_depth': [10, 20, 30, 40, 50, 60, 70, 80, 90],\n",
       "                         'rfc__n_estimators': [50, 100, 150, 200]},\n",
       "             verbose=3)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_2 = GridSearchCV(model_pipe_2, params, n_jobs=-2, verbose=3, cv = 2)\n",
    "gs_2.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.4s\n",
      "[Parallel(n_jobs=7)]: Done 200 out of 200 | elapsed:    0.4s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9946127946127946"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_2.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.1s\n",
      "[Parallel(n_jobs=7)]: Done 200 out of 200 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7851103628881406"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_2.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:   31.4s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8571030263463021"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_2 = cross_val_score(model_pipe_2, X_train, y_train, scoring='neg_log_loss', n_jobs = -2, verbose = 1, cv = 2)\n",
    "-cv_2.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:    6.4s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8874503193110341"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_2 = cross_val_score(model_pipe_2, X_test, y_test, scoring='neg_log_loss', n_jobs = -2, verbose = 1, cv = 2)\n",
    "-cv_2.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'rfc__criterion': 'gini', 'rfc__max_depth': 80, 'rfc__n_estimators': 200}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_2.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.1s\n",
      "[Parallel(n_jobs=7)]: Done 200 out of 200 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(gs_2, X_test, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.1s\n",
      "[Parallel(n_jobs=7)]: Done 200 out of 200 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 83.15% of the funtional wells.\n",
      "The model correctly predicts 47.38% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 77.84% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(gs_2, X_test, y_test)\n",
    "# The model correctly predicts 91.69% of the funtional wells.\n",
    "# The model correctly predicts 27.85% of the funtional-needs-repair wells.\n",
    "# The model correctly predicts 73.78% of the non-functional wells."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  this second model with more hyperparamter tuning done to it has still a better log loss on the test data, but like all previous models it is still overfitting on the training data. the accuracy scores were no better than the previous model. \n",
    "\n",
    "*  the total accuracy score of non-functional and functional needs repairs is $125.16$, which is similar to the previous two models, but still not the highest score. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## model 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in this next model we will greatly expand the hyperparamters that we are going to tune. this will allow me to see if there is any improvement in the model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_pipe_3 = imbPipeline(steps=[\n",
    "    ('trans', trans),\n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('rfc', RandomForestClassifier(verbose=1, n_jobs=-2))\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    'rfc__max_depth': list(range(10,100,10)),\n",
    "    'rfc__criterion': ['gini', 'entropy'],\n",
    "    'rfc__n_estimators': list(range(100,250,50)),\n",
    "    'rfc__min_samples_leaf': list(range(2,12,2)),\n",
    "    'rfc__min_samples_split': list(range(2,12,2)),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 1350 candidates, totalling 2700 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  18 tasks      | elapsed:  1.5min\n",
      "[Parallel(n_jobs=-2)]: Done 114 tasks      | elapsed:  8.4min\n",
      "[Parallel(n_jobs=-2)]: Done 274 tasks      | elapsed: 31.5min\n",
      "[Parallel(n_jobs=-2)]: Done 498 tasks      | elapsed: 74.0min\n",
      "[Parallel(n_jobs=-2)]: Done 786 tasks      | elapsed: 127.3min\n",
      "[Parallel(n_jobs=-2)]: Done 1138 tasks      | elapsed: 192.6min\n",
      "[Parallel(n_jobs=-2)]: Done 1554 tasks      | elapsed: 252.0min\n",
      "[Parallel(n_jobs=-2)]: Done 2034 tasks      | elapsed: 342.3min\n",
      "[Parallel(n_jobs=-2)]: Done 2578 tasks      | elapsed: 446.9min\n",
      "[Parallel(n_jobs=-2)]: Done 2700 out of 2700 | elapsed: 468.5min finished\n",
      "[Parallel(n_jobs=-2)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  36 tasks      | elapsed:   10.7s\n",
      "[Parallel(n_jobs=-2)]: Done 186 tasks      | elapsed:   50.5s\n",
      "[Parallel(n_jobs=-2)]: Done 200 out of 200 | elapsed:   53.7s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=2,\n",
       "             estimator=Pipeline(steps=[('trans',\n",
       "                                        ColumnTransformer(n_jobs=-1,\n",
       "                                                          transformers=[('numerical',\n",
       "                                                                         Pipeline(steps=[('ss',\n",
       "                                                                                          StandardScaler())]),\n",
       "                                                                         Index(['gps_height', 'longitude', 'latitude', 'num_private', 'region_code',\n",
       "       'district_code', 'population', 'construction_year'],\n",
       "      dtype='object')),\n",
       "                                                                        ('categorical',\n",
       "                                                                         Pipeline(steps=[('ohe',\n",
       "                                                                                          OneHotEncoder(handle_unk...\n",
       "       'quantity', 'source', 'waterpoint_type'],\n",
       "      dtype='object'))],\n",
       "                                                          verbose=True)),\n",
       "                                       ('smote', SMOTE(random_state=42)),\n",
       "                                       ('rfc',\n",
       "                                        RandomForestClassifier(n_jobs=-2,\n",
       "                                                               verbose=1))]),\n",
       "             n_jobs=-2,\n",
       "             param_grid={'rfc__criterion': ['gini', 'entropy'],\n",
       "                         'rfc__max_depth': [10, 20, 30, 40, 50, 60, 70, 80, 90],\n",
       "                         'rfc__min_samples_leaf': [2, 4, 6, 8, 10],\n",
       "                         'rfc__min_samples_split': [2, 4, 6, 8, 10],\n",
       "                         'rfc__n_estimators': [100, 150, 200]},\n",
       "             verbose=3)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_3 = GridSearchCV(model_pipe_3, params, n_jobs=-2, verbose=3, cv = 2)\n",
    "gs_3.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.3s\n",
      "[Parallel(n_jobs=7)]: Done 200 out of 200 | elapsed:    0.3s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9025314877166729"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_3.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.1s\n",
      "[Parallel(n_jobs=7)]: Done 200 out of 200 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7807706696595585"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_3.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:   31.3s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8725128013782077"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_3 = cross_val_score(model_pipe_3, X_train, y_train, scoring='neg_log_loss', n_jobs = -2, verbose = 1, cv = 2)\n",
    "-cv_3.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:    6.4s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9221941854834051"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_3 = cross_val_score(model_pipe_3, X_test, y_test, scoring='neg_log_loss', n_jobs = -2, verbose = 1, cv = 2)\n",
    "-cv_3.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'rfc__criterion': 'gini',\n",
       " 'rfc__max_depth': 50,\n",
       " 'rfc__min_samples_leaf': 2,\n",
       " 'rfc__min_samples_split': 4,\n",
       " 'rfc__n_estimators': 200}"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_3.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.1s\n",
      "[Parallel(n_jobs=7)]: Done 200 out of 200 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(gs_3, X_test, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.1s\n",
      "[Parallel(n_jobs=7)]: Done 200 out of 200 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 82.09% of the funtional wells.\n",
      "The model correctly predicts 54.68% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 76.82% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(gs_3, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  this model does not over fit as severly as the previous models, but still does over fit. the accuracy for the test data is no better than the other models. however, the log loss is lower than previous models, so there is some improvement in our model. the accuracy scores for function and non-functional wells are about the same, but the accuracy for functional-needs-repairs is much higher. \n",
    "\n",
    "*  the total accuracy score of non-functional and functional needs repairs is $131.79$, which is the best of all the random forest models. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# model 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "here we will attempt to see if the previous model can be improved by changing some hyperparamters by hand to increase the accuracy of the test scores or to see if the predictions can be increased."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_pipe_4 = imbPipeline(steps=[\n",
    "    ('trans', trans),\n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('rfc', RandomForestClassifier(verbose=1, n_jobs=-2, \n",
    "                                   criterion = 'entropy',\n",
    "                                   max_depth = 80,\n",
    "                                   min_samples_leaf = 2,\n",
    "                                   min_samples_split = 2,\n",
    "                                   n_estimators = 250,\n",
    "                                   class_weight='balanced'))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  36 tasks      | elapsed:   11.3s\n",
      "[Parallel(n_jobs=-2)]: Done 186 tasks      | elapsed:   51.1s\n",
      "[Parallel(n_jobs=-2)]: Done 250 out of 250 | elapsed:  1.1min finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('trans',\n",
       "                 ColumnTransformer(n_jobs=-1,\n",
       "                                   transformers=[('numerical',\n",
       "                                                  Pipeline(steps=[('ss',\n",
       "                                                                   StandardScaler())]),\n",
       "                                                  Index(['gps_height', 'longitude', 'latitude', 'num_private', 'region_code',\n",
       "       'district_code', 'population', 'construction_year'],\n",
       "      dtype='object')),\n",
       "                                                 ('categorical',\n",
       "                                                  Pipeline(steps=[('ohe',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore'))]),\n",
       "                                                  Index(['in...lic_meeting', 'scheme_management',\n",
       "       'permit', 'extraction_type', 'management', 'payment', 'water_quality',\n",
       "       'quantity', 'source', 'waterpoint_type'],\n",
       "      dtype='object'))],\n",
       "                                   verbose=True)),\n",
       "                ('smote', SMOTE(random_state=42)),\n",
       "                ('rfc',\n",
       "                 RandomForestClassifier(class_weight='balanced',\n",
       "                                        criterion='entropy', max_depth=80,\n",
       "                                        min_samples_leaf=2, n_estimators=250,\n",
       "                                        n_jobs=-2, verbose=1))])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe_4.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.3s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.5s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.902830776904851"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe_4.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7817433595211373"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe_4.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.1s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAFwCAYAAADkNE/4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAA9CUlEQVR4nO3debxVZdn/8c/3HOZZBpFRRFFDElScS9EszUxtsDRzSMssC7XHSrPBIcvKBi017XlKTXP6OeeEmTjkCIgKKoKAQCBwmGfOcP3+WOvABs4EnHPW3vt836/Xfp217r2Ga282+9r3sO6liMDMzCzflWQdgJmZWUM4YZmZWUFwwjIzs4LghGVmZgXBCcvMzApCq6wDsMLWs3tpDBrQOusw8tbUd7tmHUIBUNYB5L3l6+eXRUSvbd3/6CM6xqLFlQ3advyb656MiGO29VxNyQnLtsugAa159ckBWYeRtz5z4HFZh5D/St3QU58nZvzug+3Zf9HiSl59cmCDti3tM7Xn9pyrKTlhmZkVuQCqqMo6jO3mhGVmVvSCynDCMjOzPBdABQ3rw8pnTlhmZkUuCCqLYBo+JywzsxagCicsMzPLcwFUOmGZmVkhcA3LzMzyXgDl7sMyM7N8F4SbBM3MrAAEVBZ+vnLCMjMrdslMF4XPCcvMrOiJyiKYZNgJy8ysyAVQ5SZBMzPLdwGsL4LbHzphmZm1AFXhJkEzM8tzyUwXTlhmZpbnAlHpJkEzMysEbhI0M7O85yZBMzMrCIEoj8L/ui/8V2BmZvVyDcvMzPJehKgMD7owM7MCUOUalpmZ5btk0IVrWGZmluc86MLMzApGpa/DMjOzfOeZLszMrGBUeZSgmZnlOw+6MDOzghDIfVhmzeH0A4bSvlMlJSVQ2ir40xPv8f7kdvzx4gGsWVVC7/7r+eH1H9CxcxUV5fD7iwYy7a32VFaIo05azMnfXQDAj74ymMULWlNZAcMOXMV3fjGH0tKMX1wT6NipnNGXvsnOg1dAwB9+PpyeO67lK994jwGDVnLh1w5l2rvdNmw/aLflfOfit+jQsYKoEhd87VDK1xfhG5Pq2Kmc0Ze8wc6Dl0OIP/xiOO9O6s5nvziD474wg8pK8dqLvfnbDUMZ9ak5fOEr72/Yd9Buyzn/a4cxfWrXDF/B1ovAowStfpJGA98CJkTEqY1wvEHAIRHxj3R9JHB6RIze3mNvdp6ZwMiIKGvM426rX987ja49Kjes/+GigXzjp/9l74NX8eSd3fl/N+7IGT/4kOce6Ub5OnHTv6ewdrU4Z9RHGHXiUnYasJ5Lb5pJx85VRMCV3xjE8490Y9SJS7N7UU3knO9NZvxLvfjlJfvRqlUVbdtVsmplK6764X585+K3Ntm2pLSKiy6byG8vH8GMqV3o3GU9lRWF33RUl3MumMT4l3vxy0tHbnh/9t63jIM+/iHnnX44FeWldN1hHQBjx/Rn7Jj+AOw8eDk//dVrBZesEiqKC4eL+5OZH74NHNsYySo1CPhK9UpEjGvsZFUI5rzflo8etAqAfQ5bwQuPdgNAgrWrS6isgPVrS2jVpooOnZJE17FzFQCVFVCxXhTB/98ttO9YzrB9FjPm4QEAVFSUsGpla2bP7Mx/Z3XaYvt9Dyxj5rTOzJjaBYAVy9tQVVWEb0yqfYdyho1YxJhHBgIb359jPzeTe/++GxXlSc1y2ZK2W+x7+Cf/y7P/6tus8TaWACqjpEGPhpA0U9JbkiZKGpeWdZf0lKSp6d8dcra/RNI0SVMkHZ1Tvl96nGmSrpNU54fPCasJSfozMBh4WNIySRflPDdJ0qD08Y6kv0iaLGmMpPbpNrtJ+pekNyRNkLQrcDXw8fSDcqGkUZL+mW7fXdKDkt6U9LKkvdPyyyT9VdJYSdPTWl91HA9KGp+e+5zmfH8aTMGPTtmV847encdu7wHAznus5aUnky/Z5//ZjYVzWwPw8eOW0q5DFaeMGMZX9x/KF89dSJcdNtbMfnTKYL689zDad6ri48ctbfaX0tT69F3NsiVtuPAnb3Ldbc8z+kdv0rZdRa3b9xu4ikBcce0rXHvr83zhq+/Xum0x6NNvNcuWtuXCSydy3S3PMvriN2jbroJ+A1ax1/DF/O4vz3P19f9hyEeWbrHvYUfN5dmn+jV/0I2kkpIGPbbCERExIiJGpusXA09HxBDg6XQdSUOBk4G9gGOAGyRVtznfCJwDDEkfx9R1QiesJhQR5wJzgSOA39ex6RDg+ojYC1gKfCEtvyMtHw4cAswj+RA8n35QNj/m5cDrEbE38CPgtpzn9gSOBg4AfiapdVp+VkTsB4wERkvqsU0vtgn9/qGpXD/mPa66YzoP39KTt17uyPd+N4tHbunJeUfvzpqVJbRqEwBMeb0jJaXBP16fxG2vvMN9f+7FvA/abDjWL+6czp2vT6Z8vZj4wpY1jkJXUhrstsdyHrt/IKNP/zhr15Zy0hm1J6HS0iqGDl/MNT/dhx+ccwgHj/qQ4SPzohW4SZSUBrvtvozHHhjE6DMPT96f06ZR0iro1KWc733jY/z1T0O5+MpxJPWSxB5Dl7BubSkfTO+SXfDbIRBV0bDHdjgBuDVdvhU4Maf8rohYFxEzgGnAAZL6AF0i4qWICJLvqxOpgxNWfpgRERPT5fHAIEmdgX4R8QBARKyNiNX1HOdjwN/T7f8N9JBU3eD+aPqBKQMWAL3T8tGS3gBeBgaQJM86STpH0jhJ4xYuqqxv8+3WY6ekhtCtZwWHHrOMd1/vwMAh6/jlXdO5/sn3GHXiUvrsnPQ5PPNAN0YesYJWrZPth+6/ivfe6LDJ8dq0Cw7+1DJeerIQ+yLqtmhBO8oWtGPK5KQ15j//7sNueyyrdfuyBe2ZNKEHy5e1Yd26Usa9uCO77ln79oVu0YJ2lC1sx5S30/fnmeT9WbSgHS+O3QkQ772zAxGiS7f1G/Y77Kj/FnTtCraqhtWz+v93+qip5SWAMWnrTPXzvSNiHkD6d8e0vB8wO2ffOWlZv3R58/JaOWE1nwo2fb/b5Syvy1muJBkMsy0/dWrap/pn4hbnkDQKOAo4OK3Fvb5ZXDWKiJsjYmREjOzVo2lHk61dXcLqlSUblsc/25lBe65laVkyXqiqCv5xbW+OO20RAL36lTPxhU5EJNu/O6EjA3Zby5pVJSyan+xTWQGvPt2FAbutq/mkBWzJ4nYsXNCOfgNXAjB8ZBmzZnSudfsJL/di0G7Ladu2kpLSKj66zyJmzyi+mme1JYvbsXB++y3en5ee24nh+yU1y74DVtKqVRXLlyY1cyn42JHzeK5A+6+gei7B0gY9gLLq/9/p4+YaDnloROwLfBo4T9JhdZy+tu+lur6vauRRgs1nJnAcgKR9gV3q2jgilkuaI+nEiHhQUlugFFgB1PYN9BxwKnBlmozK0uPUdpquwJKIWC1pT+CgrXtJTW/JwlZcfnbyVlVWwBGfW8r+R6zggf/tySO39ATg0E8v41MnLwbg+K+V8dsLB3LOEXtAiE99eRGDh65lycJWXHbmYMrXi8pKGHHoSo47vTibvm66Zi++f8VEWrWq4sO5HfjDlcM5+PAPOfeiyXTttp7Lfv8a09/rwk/PP5CVK1rz4J278PtbXiACxr24I6/9p3f9JylgN/1+GN//2QRatU7fn6tGsHZNKy64dCLX3z6WinLxu5/vQ/X36bARiyhb0I4P53bMNvDtEDTuTBcRMTf9u0DSAyRdDfMl9YmIeWlz34J08zkkrTfV+pN0lcxJlzcvr5WSpkNrKtXDw4FVwEMk1eTXSJrvPp1u9s+IGJZufxHQKSIukzQEuAnoCZQDJ5FUrZ9Iy24hqRVdFBHHSeoO/I0kGa4GzomINyVdBqyMiGvSc0wiSZ7zgAdJquFTgF7AZRExtqHD2kcObxevPjmgrk1atM8ceFzWIeS/Ujf01OeJGb8bnzO4Yav1H9Y1zrvn0AZt+6O9Hq/zXJI6AiURsSJdfgq4AvgEsCgirpZ0MdA9In4gaS/gHyRJrS/JgIwhEVEp6TXgu8ArwGPAHyPisdrO7RpWE4uIQTmrn6pls2E521+TszwVOLKG7T+x2frYdPvFJB2cm8dw2Wbrw3JWP00NNovbzApYhBqzhtUbeCBtuWkF/CMinkiTzz2SzgZmkfzAJiImS7oHeJuka+S8iKju/P4WyQ/v9sDj6aNWTlhmZi1AQ6+xqk9ETAeG11C+iC1/TFc/dxVwVQ3l48j5wV4fJywzsyJXPeii0DlhmZkVuWTQReHPYOKEZWbWAvj2ImZmlveqZ7oodE5YZmYtQJVrWGZmlu8i8A0czcws/wWiosqjBM3MrABUFsEN4JywzMyKnIe1m5lZgWjUqZky44RlZtYCVLlJ0MzM8l0ElHvQhZmZ5TtfOGxmZgXDTYJmZpb3PErQzMwKhkcJmplZ/gv3YZmZWQEIoMI1LDMzy3fuwzIzs4LhhGVmZnnP12GZmVnB8HVYZmaW/8JNgmZmVgACqKjyKEEzM8tz7sMyM7OCEU5YZmZWCDzowszM8l4UyaCLwu+FMzOzeojKqpIGPRp8RKlU0uuS/pmud5f0lKSp6d8dcra9RNI0SVMkHZ1Tvp+kt9LnrpNUZ1Z1wjIzawEi1KDHVjgfeCdn/WLg6YgYAjydriNpKHAysBdwDHCDpOrbH98InAMMSR/H1HVCNwnadpk6qROfHnJo1mHkrZIuFVmHkPcqZn+YdQhFr7HnEpTUH/gMcBXwvbT4BGBUunwrMBb4YVp+V0SsA2ZImgYcIGkm0CUiXkqPeRtwIvB4bed1wjIzK3aR9GM1UE9J43LWb46Imzfb5g/AD4DOOWW9I2IeQETMk7RjWt4PeDlnuzlpWXm6vHl5rZywzMxagK0YJVgWESNre1LSccCCiBgvaVQDjlfTiaOO8lo5YZmZFbmgUa/DOhQ4XtKxQDugi6TbgfmS+qS1qz7AgnT7OcCAnP37A3PT8v41lNfKgy7MzIqeqKxq2KM+EXFJRPSPiEEkgyn+HRFfBR4Gzkg3OwN4KF1+GDhZUltJu5AMrng1bT5cIemgdHTg6Tn71Mg1LDOzFqAZZrq4GrhH0tnALOCk5LwxWdI9wNtABXBeRFSm+3wLuAVoTzLYotYBF+CEZWZW9CKaJmFFxFiS0YBExCLgE7VsdxXJiMLNy8cBwxp6PicsM7MWoBhmunDCMjNrAbZiWHvecsIyM2sBPFu7mZnlPd8Py8zMCkMTDbpobk5YZmYtgfuwzMysEBR1DUvSH6kjJ0fE6CaJyMzMGl2xjxIcV8dzZmZWICIgtuLmjPmq1oQVEbfmrkvqGBGrmj4kMzNrbMVQw6o35Uo6WNLbpHeWlDRc0g1NHpmZmTWeaOAjjzWkjvgH4GhgEUBEvAEc1oQxmZlZoxIRDXvkswaNEoyI2cns7xtU1ratmZnloTyvPTVEQxLWbEmHACGpDTCatHnQzMwKQJFcONyQJsFzgfOAfsB/gRHpupmZFYpQwx55rN4aVkSUAac2QyxmZtZUiqBJsCGjBAdLekTSQkkLJD0kaXBzBGdmZo2khYwS/AdwD9AH6AvcC9zZlEGZmVkjCoqiSbAhCUsR8feIqEgft5P3edjMzHJFNOyRz+qaS7B7uviMpIuBu0gS1ZeBR5shNjMzayx5nowaoq5BF+NJXmJ1HfGbOc8FcGVTBWVmZo1LVfnd3NcQdc0luEtzBmJmZk2kAAZUNESDZrqQNAwYCrSrLouI25oqKDMza0z5P6CiIepNWJJ+BowiSViPAZ8GXgCcsMzMCkUR1LAaMkrwi8AngA8j4mvAcKBtk0ZlZmaNqwiuw2pIk+CaiKiSVCGpC7AA8IXD1uxat6niN/+YROs2VZS2Cl54oge3XzeQjx1TxldHz2bArmu44At7M3VSpw37fOmbczj6pAVUVcKNV+7ChBd2yPAVNI+/PvIsa1a3oqpSVFaKC047eMNznz9tBmdf8B6nfOIIli9tw+57LeW7l76dPKngHzfvxkvP9M4o8ubxvd/N4sCjVrC0rBXfPHIPAL7+k7kc9MnllK8X8z5ow28vHMiq5aUAfPk78znmlMVUVokbf9yX8c92yTL8bRNAMQ+6yDFOUjfgLyQjB1cCr9a3k6TRwLeACRHRKFM7SRoEHBIR/0jXRwKnR8Toxjh+znlmAiPTaamanKSxwEURkdldniX1Ba6LiC9mFUN9yteLi0/fi7WrSyltVcU1d01i3HM78MHUDlx53p6MvvL9TbYfuNtqDv9MGeceO4LuO67nl7dO5uuf3JeqIviPW59Lvrk/y5e22aSsZ+81jDhwEQvmbeiK5oP3O3P+aQdRVVnCDj3X8ac7X+SV53pRVVn4d6etzZi7u/Pw33ry/Wtnbyib8Fxn/vqLPlRVirMvncvJ353P/13Vl4FD1jLqhKWcc8QedO9dztV3T+fsj3UuyM+Q8rz21BD1fioj4tsRsTQi/gx8EjgjbRqsz7eBYxsrWaUGAV/JiW1cYyerQiKpQYNmGiIi5taUrBrzHNtPrF2d/Opt1Spo1SqIgNnvd+C/M9pvsfVBn1jMs4/2pHx9CfPntGPuB+3Zfe+VzR103vjG96bwt2t33+Ti0HVrSzckpzZtKvP+wtHGMOmVTqxYsunHesKznamqTJLQO+M70rNPOQAHH72MsQ91Sz5Ds9syd2Yb9thndbPH3CiKoEmw1oQlad/NH0B3oFW6XCtJfyZpNnxY0oWSLpN0Uc7zkyQNSh/vSPqLpMmSxkhqn26zm6R/SXpD0gRJuwJXAx+XNDE97ihJ/0y37y7pQUlvSnpZ0t5p+WWS/ipprKTpac2vOo4HJY1Pz31OfW+WpJWSrkpjellS77S8l6T7JL2WPg5Nyzum535N0uuSTkjL20u6K431bqD6NZdKuiV9f96SdGENMdwi6XeSngF+JWlXSU+kr+N5SXvmbPfntOw9Scel5YPSsgnp45Cc8knp8pmS7pX0CDCmvvelOZWUBH96eCJ3vvwar/+nK1Pe6Fzrtj16r2fhvI3drWUftqHnTuuaI8xMRYgrrx/Htbe/xDGfS2oRBx62gEUL2zJj6pbNWXsMW8oN97zA9Xe/yPW/HFrUtauGOPqUxbz27+R96tmnnIVzN9ZUy+a1ocdO5VmFlhcktZP0avo9OFnS5Wl5d0lPSZqa/t0hZ59LJE2TNEXS0Tnl+6XfddMkXSepzqprXb+ef1vHcwEcWeuTEedKOgY4IiLKJF1Wx7GGAKdExDck3QN8AbgduAO4OiIekNSOJLleTNJ0Vv3lOyrnOJcDr0fEiZKOJBnFOCJ9bk/gCKAzMEXSjRFRDpwVEYvTJPmapPsiYlEdsXYEXo6ISyX9GvgG8HPgWuD3EfGCpIHAk8BHgEuBf0fEWUqaVV+V9C+Si7BXR8TeaWKdkB5/BNAvIoalr69bLXHsDhwVEZWSngbOjYipkg4EbmDjv80g4HBgV5IZS3Yj6YP8ZESslTSEZF7IkTWc42Bg74hYvPkTaXI/B6CdOtbxdjW+qirxneNH0LFzBT+54V12HrKKD6bWHENNH/1iuCdQfb5/1gEsLmtH1x3W8fMbxjF7Zke+fPZ0fnzefjVuP2VSN779pY8xYNBKLrz8Lcb9pyfl60ubOer8cMro+VRWwL/v75YU1PRxyfNaSG0asUlwHXBkRKyU1Bp4QdLjwOeBpyPiaiWzI10M/FDSUOBkYC+S+Wj/JWn3iKgEbiT5LnmZZBT6McDjtZ24rguHj2ic11avGRExMV0eDwyS1Jnki/uBNJa1APUk34+RJDsi4t+Sekjqmj73aESsA9ZJWgD0BuYAoyV9Lt1mAEnyrCthrQf+mRPrJ9Plo4ChOfF1SV/Dp4DjtbF22Q4YCBwGXJfG+qakN9PnpwODJf2RZPqr2mo396bJqhNwCHBvzrlzR3DeExFVwFRJ00kS9wzgT5JGkNw5evdazvFUTckqjflm4GaArqU9M/nvu2pFK958pSsjD1taa8Iq+7ANvfpsrFH13Gk9i+a3qXHbYrK4LOmjWrakLS8905uP7reE3n3X8Kc7XwSg547ruPaOl/je6QexZNHGj8vsmZ1Yt7aUnXddybR3utZ47GJ21EmLOeCo5Vz85V2pzlRlc1vTq+/6Ddv07LOeRfNbZxThdmqkH2sRESRjGQBap48ATiC5BArgVmAs8MO0/K70O3iGpGnAAUrGCnSJiJcAJN0GnEgdCau56v4Vm52rXc5ybhtNJUkS3ZZ3tq7fQlucI62dHQUcHBHDgdc3i6sm5ek/Vm6skLy2gyNiRProFxEr0pi+kFM+MCKq79a8xRd9RCwhuWxgLMlNMv+3ljhW5Zx3ac7xR0TER2p4/bnrFwLz0/OMBGr7Bl9VS3lmunYvp2PnCgDatK1kn0OWMnv6ln1X1V5+ujuHf6aM1m2q6N1/LX0HreG9NzvVun0xaNuugvYdKjYs73vQIqZO7sKpnzyCsz57OGd99nDKFrTl/FMPZsmitvTuu5qS0ioAeu20hn47r2bBvNrf02I1ctRyvnTeAi47cxfWrdn4VfXymK6MOmFp8hkasI5+u6xnyusdMox0GwVQ1cAH9JQ0LuexRXdJ2n0xkaTF5qmIeAXoHRHzANK/O6ab9wNm5+w+Jy3rly5vXl6r5upQnwlUN+PtC9Q57VNELJc0R9KJEfGgpLZAKbCCpFmvJs+R3GjyyjQZlaXHqe00XYElEbE67fc5aOte0ibGAN8BfgMgaURaa3wS+K6k70ZESNonIl7PifUZJbOIVPe39QTWR8R9kt4HbqnrpOnrmyHppIi4N23/3Tsi3kg3OUnSrSTv92BgSvq656SXKpxB8r4WhB16reeiX0+jpCRQSfD84z159ZnuHPLJRXzrpzPo2r2cy//yDtPf6ciPzxrKrGkdeP7xntz0+OtUVogbLhtckKO7tsYOPdZz6TWvA1BaGjz7RB/Gv9Sr1u2HjljKSWdOp7KihKqAG67+yBajC4vNxTd8wN4Hr6Rr9wpuH/c2f/9tb07+zgJatw1+eXcy0vTd8R257uL+fPBeO557pBs3j51CZaX404/6FexnaCuaBMsioqZugg3S5rwRabfFA+n3WK2nrukQdZTXqrkS1n3A6WlGfg14rwH7nAbcJOkKoBw4CXgTqJD0BsmX+es5218G/C1tXlsNnFHP8Z8Azk23n0LShrqtRgPXp8dqRZKQziWZIPgPwJtpMplJkrhvzIl1IhsvE+iXllf/xLukAec+FbhR0o9JquZ3AdUJawrwLEkT6Llpv9UNwH2STgKeIQ9rUrWZOaUj3zlh+BblLz7Vgxef6lHjPnfd2J+7buzf1KHljQ//24HvnnJonduc9dnDNyw/81hfnnmsb1OHlVeu/vbOW5Q9eWfNnx+AO6/rzZ3XFcG1aU3QeB8RS5VclnMMMF9Sn4iYJ6kPSe0LkprTgJzd+gNz0/L+NZTXSlHPONb0i/ZUYHBEXJEOKtgpIuq9FsuyI+kW4J8R8f+a8jxdS3vGQR2Oa8pTFLSSLrWPYrRExbwPsw4h7/0r/t/4+mo9dWk7YED0P3+LQcc1mv79/6nzXJJ6kXSPLE0HrI0BfkUywGtRzqCL7hHxA0l7kdwI+ACSQRdPA0PSfvjXgO8Cr5AMuvhjRDxW27kbUsO6gaRl80jgCpJmufuA/Ruwr5mZZUzRqKME+wC3Siol6Ue/JyL+Kekl4B5JZwOzSFrFiIjJ6Qjwt0nGM5yXNilCMrnELSSX9jxOHQMuoGEJ68CI2FfS6+nJl0gq7kbuIhARZ2Ydg5nlkUbqe4uIN4F9aihfRDLvbE37XAVcVUP5OKCu/q9NNCRhlaeZNGBDdbCqoScwM7PstYipmUiuF3oA2FHSVSS3FvlFk0ZlZmaNqwimZqq3hhURd0gaT1LVE3BizrVEZmaW7xq3DyszDbmB40CSYeKP5JZFxKymDMzMzBpRS0hYJFMEVV/k1Y7kItQpJPNCmZlZIWgJCSsiPpq7ns5U8c0mi8jMzBpdi2gS3FxETJDka7DMzApJS0hYkr6Xs1oC7AssbLKIzMyscbWUQRdsOtlsBUmf1n1NE46ZmTWJYk9Y6QXDnSLi+80Uj5mZNYViTliSWkVERTrIwszMCpQo/ibBV0n6qyZKehi4l5xbUUTE/U0cm5mZNYYAFcGEeg3pw+pOctv4I9l4PVYATlhmZoWiyGtYO6YjBCex5d0hi+Clm5m1IEXwrV1XwioFOrENtzE2M7P8Uux9WPMi4opmi8TMzJpOkSesxrnbl5mZZasFDLqo8c6RZmZWgIq5hhURi5szEDMzazrF3odlZmbFwgnLzMzyXuCEZWZm+U8Uxyg6Jywzsxag2EcJmplZsXCToJmZFQQnLDMzy3st6I7DZmZW6JywzMysELiGZda2DQzZOeso8lblO+9nHULeW/jwHlmHkP8+u/2HaKxRgpIGALcBOwFVwM0Rca2k7sDdwCBgJvCliFiS7nMJcDZQCYyOiCfT8v2AW4D2wGPA+RFRa2otaZyXYGZmeSu24lG/CuB/IuIjwEHAeZKGAhcDT0fEEODpdJ30uZOBvYBjgBsklabHuhE4BxiSPo6p68ROWGZmLUEjJayImBcRE9LlFcA7QD/gBODWdLNbgRPT5ROAuyJiXUTMAKYBB0jqA3SJiJfSWtVtOfvUyE2CZmZFTmxVH1ZPSeNy1m+OiJtrPK40CNgHeAXoHRHzIElqknZMN+sHvJyz25y0rDxd3ry8Vk5YZmYtQcMTVllEjKxvI0mdgPuACyJiuVTr5E+13bV+q+9m74RlZlbsAlTVeMMEJbUmSVZ3RMT9afF8SX3S2lUfYEFaPgcYkLN7f2BuWt6/hvJauQ/LzKwFUDTsUe9xkqrU/wHvRMTvcp56GDgjXT4DeCin/GRJbSXtQjK44tW0+XCFpIPSY56es0+NXMMyM2sJGq+CdShwGvCWpIlp2Y+Aq4F7JJ0NzAJOAoiIyZLuAd4mGWF4XkRUpvt9i43D2h9PH7VywjIzawEa68LhiHiB2u9W8ola9rkKuKqG8nHAsIae2wnLzKwl8EwXZmaW9zz5rZmZFQLhGziamVmhqH2KvoLhhGVm1gK4SdDMzPJfwye2zWtOWGZmLYD7sMzMrDC4hmVmZnmvkecSzIoTlplZC+BBF2ZmVhicsMzMLN9t5Q0c85YTlplZsYvwhcNmZlYYPKzdzMwKgpsEzcws/wXgYe1mZlYQCj9fOWGZmbUEbhI0M7PC4FGCZmaW98KjBM3MrAAkFw67hmVmZoXANSwzMysErmGZNbMTTpjCMUe/jxQ88cSuPPjQnpx66lscc/T7LFvWFoBbbx3Oa+P6AvClL03m6E9Np6pK3Pjn/ZgwoU+W4Te5nn3W8f3fTmeHXuVElXjszl48dMtOfPX8ORxz8kKWLW4NwC2/6c9rY7tt2K9X33XcPOYtbr+2H/f9pcjeo/VVdLtkNioPqAzWHdqZ1V/pSemMtXS+YT5aW0Xljq1Z8T99iA6ltH59FR1vW4gqgmglVp3Zi/LhHWFdFV1+NZfSeeVQAusP6MSqM3pl/eoaxncctoaQ9BvgWOCxiPh+Ix1zBNA3Ih5L148HhkbE1Y1x/JzzrIyITo15zO2x885LOebo97ngwk9RXl7Cz68cy6uv9QPgwQf34L77P7LJ9gMHLOPww2Zx7rnH0r3HGn75i2f4+jc+Q1VVSQbRN4+qCvGXqwYybXJH2nes5I+PTOL1F7oC8MBfd6o1GX3zx7MY92zX5gy1+bQWS38+ANqXQEXQ7eJZrN+3I51uXsCqs3pRPqwD7Z5aRvv7l7D6qz2JLqUs/3F/qnq0ovSDdXT92RwW37IrAGtO7E753h2gPOj2k9m0Gb+S9fvlzX+ROhTHXILF+z83f3wT2LexklVqBEkSBCAiHm7sZJWPBgxYzrtTerBuXSuqqkp4a9KOHHLI7Fq3P+jgOTz73EDKK0qZP78Tc+d2YvfdFzdjxM1v8cI2TJvcEYA1q0qZPa09PXZaX+c+B39yCR/ObssH77VvjhCbn5QkK4DKgIoAQel/11O+V/Ka14/oQNuXVgBQsWs7qnokv+UrB7ZB5VVQXgVtS5JkBdBalO/alpKyimZ/OdtKVdGgRz5zwgIkDZL0jqS/SJosaYyk9ulzIyS9LOlNSQ9I2iEtHyvpV5JelfSepI/XcNyHgY7AK5K+LOkWSV/MeX5l+ndUerz/J+ldSXdIUvrc/pJelPRGeq6uwBXAlyVNTI97pqQ/pdvvLOnpNN6nJQ1My2+RdF16rOnVcUjqlG43QdJbkk5oyvd6e3zwQVeGDVtI587raNu2gv1HzqVXz9UAfPazU7nh+se48IKX6dQp+YLu0WMNCxd22LB/WVkHevZYnUnsWejdbx27Dl3NlIlJDeD40+dz4+NvceGvptOpS/JF27Z9JV86dy63X9svy1CbXmWww/kz6XnaNMpHdKRij/ZU7tyGNq+sBKDtf1ZQUla+xW5tXlxJxeB20HrTr0qtrKTtq6tYP7zDFvvkpXRYe0Me+cwJa6MhwPURsRewFPhCWn4b8MOI2Bt4C/hZzj6tIuIA4ILNygGIiOOBNRExIiLuruf8+6THGQoMBg6V1Aa4Gzg/IoYDRwGrgJ8Cd9dy3D8Bt6Xx3gFcl/NcH+BjwHFAdY1sLfC5iNgXOAL4bXWyzDezZ3fl3ns/wi+ueoYrrxzL9Bk7UFlZwqOP7sZZZx/Hed/5NIsXt+cbX58AJD+sNxfk5UtrdO06VPLjG6dy05UDWb2ylH/e0ZuvHT6cbx87jMULW/ONS2cBcNqF/+X+v+7E2tWlGUfcxErFkmsHseivu9Jq6hpKP1jHitE70f6xpXS7cCZaUwWtNv1slM5aR6dbF7Li2703PVZl0OWaeaw5rhtVO7VpxhexnapvMVLfI4+5D2ujGRExMV0eDwxKazPdIuLZtPxW4N6cfe7P3X47z/9qRMwBkDQxPd4yYF5EvAYQEcvT5+s6zsHA59PlvwO/znnuwYioAt6WVP2/UMAvJB1GMvC1H9Ab+LC2E0g6BzgHoF3r5u33GDNmV8aMSfoTzjjjDcrKOrB06camrMef2JXLL3sOgLKy9vTqtbFG1bPnahYtKtJmrxylrar4yY1TeeahHvznye4ALC1rveH5J+7ckcv/7z0A9hyxko9/ejFfv3g2HbtUElWwfl0Jj9zWu8ZjF7roVEr5sA60mbCKNZ/rzrIrBgBJ82Cbcas2bFdSVk6XX/yX5RfsRFWfTZNSpz99SEXf1qw5oXuzxr7dGikXSforyY/eBRExLC3rTvLjehAwE/hSRCxJn7sEOBuoBEZHxJNp+X7ALUB74DGSH+Z1Ruka1kbrcpYraVgyr96nodtXkL7naS0m939CTecX2/8xy90/9xzVWe9UoBewX0SMAOYD7eo8YMTNETEyIka2adW8TSJdu64FoFevVRx6yGyefXZndthhzYbnDzlkDh98kCTRl1/uz+GHzaJ1q0p6915J374reO+9AvuS2WrBhb+awaxp7bn//zYOsOjea2M/1iFHL2Fm2l910ZeGcsbHR3DGx0fw4F97c9cNfYsuWWlZBVpZmaysq6LNG6up7N8GLU37n6qCDvcsYu0x3ZLtV1bS9Yr/sur0XlQM3fTz3eH2hZSsrmLV13dsxlfQOBTRoEcD3AIcs1nZxcDTETEEeDpdR9JQ4GRgr3SfGyRVV+dvJPnhOyR9bH7MLbiGVYeIWCZpiaSPR8TzwGnAs/XtV4eZwH7APcAJQOs6t4Z3gb6S9o+I1yR1BtYAK4DOtezzIskH5O8kyeiFes7RleSXUrmkI4CdG/JCsvLjS1+gS5d1VFSUcMMNI1m5sg0XXfQSgwcvgYD58ztx3R/3B2DWrK48//xAbrrpMSorxQ03jizqEYIAe41cyVGfX8SMd9tz/aOTgGQI+6jjFzH4I0ltc/6ctlz3o0EZRtm8ShZX0PkPHyYDCgLWfawz6/fvRPuHl9DusSUArD+4M2uP6gJA+0eXUjpvPR3vXkTHuxcBsPTy/qgi6HjPYir6t2GHCz8AYM1nurH2U90yeV1bJUgGnDTGoSKekzRos+ITgFHp8q3AWOCHafldEbEOmCFpGnCApJlAl4h4CUDSbcCJwON1ndsJq35nAH+W1AGYDnxtO471F+AhSa+S/ApZVdfGEbFe0peBP6aDQNaQ9GM9A1ycNh3+crPdRgN/lfR9YGED4r0DeETSOGAiSZLMW9//wVFblF1zzcG1bn/X3Xtx1917NWVIeWXyuM4cs8sBW5TnXnNVm9uv7d8EEWWvcpd2LL120Bbla47fgTXH77BF+eov92D1l3tsUR7Awof3aIIIm55ocO0JoGf6fVDt5oi4uZ59ekfEPICImCepugraD3g5Z7s5aVl5urx5eZ2csICImAkMy1m/Jmd5InBQDfuMylkuo5Y+rNzrmCJi/mbHuiQtH0vyi6R6u+/kLL9W0/mB/TdbvyXntRxZQxxn1hRXGnuN3/j5dA2WmW2nhiessogY2UhnranDPeoor1Nxt4+YmVmiaUcJzpfUByD9uyAtnwMMyNmuPzA3Le9fQ3mdnLDMzIpdkIwBbshj2zxM0n1C+vehnPKTJbWVtAvJ4IpX0+bDFZIOSgegnZ6zT63cJGhm1gI01uS3ku4kGWDRU9IckmtQrwbukXQ2MAs4CSAiJku6B3ibZJT0eRGRDtnkW2wc1v449Qy4ACcsM7MWIKCqcaaxiIhTannqE7VsfxVwVQ3l48gZO9AQTlhmZsUuyPtZLBrCCcvMrCXI83kCG8IJy8ysBfANHM3MrDA4YZmZWd6LgMrCbxN0wjIzawlcwzIzs4LghGVmZnkvgConLDMzy3sB4T4sMzMrBG4SNDOzvBd4lKCZmRUI17DMzCz/bde9rvKGE5aZWbELGm229iw5YZmZtQSuYZmZWUFwwjIzs7wXQVRW1r9dnnPCMjNrCTzThZmZFQQ3CZqZWd6L8ChBMzMrEK5hmZlZ/vOgCzMzKwS+vYiZmRUM317EzMzyXQDhGpaZmeW98A0czcysQBRDDUtRBEMdLTuSFgIfZB1Hjp5AWdZB5Dm/R3XLx/dn54jota07S3qC5HU1RFlEHLOt52pKTlhWVCSNi4iRWceRz/we1c3vT/4qyToAMzOzhnDCMjOzguCEZcXm5qwDKAB+j+rm9ydPuQ/LzMwKgmtYZmZWEJywzMysIDhhmZlZQXDCMitikkol/SvrOMwag6dmsoIlqXtdz0fE4uaKJV9FRKWk1ZK6RsSyrOPJJ5JWkMwLu8VTQEREl2YOyerhhGWFbDzJF45qeC6Awc0bTt5aC7wl6SlgVXVhRIzOLqTsRUTnrGOwreOEZQUrInbJOoYC8Wj6sDpI2hFoV70eEbMyDMdq4OuwrChI2gEYwqZfOM9lF5EVCknHA78F+gILgJ2BdyJir0wDsy24hmUFT9LXgfOB/sBE4CDgJeDIDMPKnKR7IuJLkt6ihr6aiNg7g7Dy0ZUkn5l/RcQ+ko4ATsk4JquBE5YVg/OB/YGXI+IISXsCl2ccUz44P/17XKZR5L/yiFgkqURSSUQ8I+lXWQdlW3LCsmKwNiLWSkJS24h4V9IeWQeVtYiYl/7Np/uV5aOlkjoBzwF3SFoAVGQck9XA12FZMZgjqRvwIPCUpIeAuZlGlEckHSTpNUkrJa2XVClpedZx5ZETgDXAhcATwPvAZzONyGrkQRdWVCQdDnQFnoiI9VnHkw8kjQNOBu4FRgKnA7tFxKWZBma2lVzDsqKQzujQF5hBMvBip2wjyi8RMQ0ojYjKiPgbcETWMeULSZ+XNFXSMknLJa1wDTQ/uQ/LCp6k7wI/A+YDVWlxAB4Fl1gtqQ0wUdKvgXlAx4xjyie/Bj4bEe9kHYjVzU2CVvAkTQMOjIhFWceSjyTtTJLM25D003QFbkhrXS2epP9ExKFZx2H1c8KygifpGeCTEeGRXbVIa1h7ktQ8p7h/byNJ15I0IT8IrKsuj4j7s4rJauYmQSsG04Gxkh5l0y+c32UXUv6Q9BngzySj3wTsIumbEfF4tpHljS7AauBTOWUBOGHlGdewrOBJ+llN5RHhi4cBSe8Cx1U3AUraFXg0IvbMNjKzreMalhW86sQkqXOyGiszDinfLNisv2o6yZx5BkjqD/wROJSkZvUCcH5EzMk0MNuCh7VbwZM0TNLrwCRgsqTxkjxx6UaTJT0m6UxJZwCPAK+lw7k/n3VweeBvwMMkk9/2I3l//pZpRFYjNwlawZP0InBpRDyTro8CfhERh2QZV76QVNeXb0TEWc0WTB6SNDEiRtRXZtlzk6AVg47VyQogIsZK8nVGqYj4WtYx5LkySV8F7kzXTwF8iUQecpOgFYPpkn4iaVD6+DHJjBcGSNpd0tOSJqXre6fvkSXOAr4EfEhyUfUX0zLLM24StIKX3rzxcuBjJMO2nwMui4glmQaWJyQ9C3wfuCki9knLJkXEsGwjM9s6bhK0gpcmptFZx5HHOkTEq5Jyy1r8RdaSfhARv5b0R2q+waU/U3nGCcsKlqQ/RMQFkh6h5i+c4zMIKx+VpddeBYCkL5I0fbV01XMHjss0CmswJywrZH9P/16TaRT57zzgZmBPSf8l6d87NduQshcRj6SLqyPi3tznJJ2UQUhWD/dhWcGTdH5EXFtfWUskqRS4OiK+n46cLImIFVnHlU8kTYiIfesrs+w5YVnBq+UL5/XqAQYtnaR/R8SRWceRbyR9GjiWZITg3TlPdQGGRsQBmQRmtXKToBUsSacAXyGZzPXhnKc64+tocr2evj/3AquqCz0bOXNJ+q+OB8bnlK8guQ2L5RnXsKxgpfd52gX4JXBxzlMrgDd9u5FELTNdtPgZLqpJ6gKsiojKdL0UaBsRq7ONzDbnhGUFT9JgYG5ErE3X2wO9I2JmpoFZQZD0MnBU9aTJkjoBYzy1V/7xTBdWDO4BqnLWK0mav8waol3uDP/pcocM47FaOGFZMWiVewfddLlNhvFYYVklacOgHUn7AWsyjMdq4UEXVgwWSjo+Ih4GkHQCUJZxTFY4LgDulTQ3Xe8DfDm7cKw27sOygpfO4nAHyf2MBMwGTt/spoUtlqTzSe7vtAL4X2Af4OKIGJNpYHlEUmtgD5LPz7sRUZ5xSFYDJywrGmlnuXxh7KYkvRERwyUdTTLrxU+Av/nC2I0kHQIMIqfVKSJuyywgq5GbBK3gSWoLfIH0C6d6kteIuCLDsPJJ9ay3x5Ikqje02Uy4LZmkvwO7AhNJBuxAMu+iE1aeccKyYvAQsIzk4s91GceSj8ZLGkNyzdolkjqz6ajKlm4kycwWbm7Kc05YVgz6R8QxWQeRx84GRgDTI2K1pB6A70K80SRgJzyDfd5zwrJi8KKkj0bEW1kHkk9yh2qnBrslsEY9gbclvUpODd23p8k/HnRhBU/S28BuJLfNWEfSZxMRsXemgWVM0jPpYjtgP+BNkvdmb+CViPhYVrHlE0mH11QeEc82dyxWNycsK3jpnIJbiIgPmjuWfCTpLuCq6hqopGHARRFxZqaBmW0lNwlaMfCvrrrtmdtcGhGTJI3IMJ68ImkFGz9DbYDWJJPhdskuKquJE5YVg0dJvnBE0vy1CzAF2CvLoPLIO5L+F7id5H36KhtvD9/iRUTn3HVJJwK+F1YecpOgFZ10sME3I+KbWceSDyS1A74FHJYWPQfcWD27vW1J0ssRcVDWcdimnLCsKPkW55tKb7kyMCKmZB1LvpH0+ZzVEpLrsg6PiIMzCslq4SZBK3iSvpezWkIyIm5hRuHkHUnHA78h6Z/ZJe2/usLDtjf4bM5yBTATOCGbUKwurmFZwZL094g4TdJS4PdpcfUXzn1u8kpIGg8cCYyNiH3Ssjc97F+/iogfSvpSRNyTdTxWP9ewrJDtlw5pnwX8cbPnOgBOWImKiFjmi4a3cKykHwMXk9wE1PKcE5YVsj8DT5CMChyXUy6S0XCDswgqD02S9BWgVNIQYDTwYsYx5YMnSO6b1lHS8pzy6gvPPaw9z7hJ0AqepBsj4ltZx5GvJHUALgU+lRY9CfzcTaYJSQ9FhPusCoATllkLIaljRKzKOg6zbVWSdQBm1rQkHZLOt/hOuj5c0g0Zh2W21ZywzIrf74GjgUUAEfEGGy8iNisYTlhmLUBEzN6sqLLGDc3ymEcJmhW/2ZIOAUJSG5JRgp5LMCXpUOAyYGeS78TqUYIeZZpnPOjCrMhJ6glcCxxF8mU8Bjg/IhZlGliekPQucCEwnpyap9+f/OOEZWYtmqRXIuLArOOw+jlhmRU5Sb2AbwCDyOkGiIizsoopn0i6GigF7ie5YzUAETEhs6CsRu7DMit+DwHPA//Cgy1qUl27GplTFiTzL1oecQ3LrMhJmhgRI7KOw2x7eVi7WfH7p6Rjsw4iX0nqKul3ksalj99K6pp1XLYl17DMipykFUBHkv6Zcjy56yYk3QdMAm5Ni04DhkfE52vfy7LghGVmLVpNTaZuRs1PbhI0s5ZujaSPVa+kFxKvyTAeq4VrWGbWokkaDtwGdCVpLl0MnJnOuWh5xAnLzAyQ1AUgIpbXt61lwwnLrEhJ6l7X8xGxuLliyWeS2gJfYMsLq6/IKiarmS8cNite40kugFUNzwXgyV0TDwHLSN6vdfVsaxlyDcvMWjRJkyJiWNZxWP1cwzJrASTtAAwB2lWXRcRz2UWUV16U9NGIeCvrQKxurmGZFTlJXwfOB/oDE4GDgJciwnPlAZLeBnYDZpA0CVZfWL13poHZFlzDMit+5wP7Ay9HxBGS9gQuzzimfPLprAOwhnHCMit+ayNirSQktY2IdyXtkXVQ+SIiPsg6BmsYJyyz4jdHUjfgQeApSUuAuZlGZLYN3Idl1oJIOpxkRocnImJ91vGYbQ0nLLMWQFIp0JtNL4ydlV1EZlvPTYJmRU7Sd4GfAfOBqrQ4AI+Cs4LiGpZZkZM0DTgwIhZlHYvZ9vDtRcyK32ySqYfMCpqbBM2K33RgrKRHyZkrLyJ+l11IZlvPCcus+M1KH23Sh1lBch+WWQshqTPJlEMrs47FbFu4D8usyEkaJul1YBIwWdJ4SXtlHZfZ1nLCMit+NwPfi4idI2Jn4H+Av2Qck9lWc8IyK34dI+KZ6pWIGAt0zC4cs23jQRdmxW+6pJ8Af0/Xv0pyKw2zguIallnxOwvoBdwPPJAufy3TiMy2gUcJmplZQXCToFmRkvSHiLhA0iMkcwduIiKOzyAss23mhGVWvKr7rK7JNAqzRuKEZVakImJ8ujgiIq7NfU7S+cCzzR+V2bbzoAuz4ndGDWVnNncQZtvLNSyzIiXpFOArwC6SHs55qjPgW41YwXHCMiteLwLzgJ7Ab3PKVwBvZhKR2XbwsHazIidpMDA3Itam6+2B3hExM9PAzLaS+7DMit89QFXOeiVwb0axmG0zJyyz4tcqItZXr6TLvi+WFRwnLLPit1DShouEJZ0AlGUYj9k2cR+WWZGTtCtwB9AXEDAbOD0ipmUamNlWcsIyayEkdSL5P78i61jMtoUTllmRk9QW+AIwiJxLWSLiiqxiMtsWvg7LrPg9BCwDxgPrMo7FbJu5hmVW5CRNiohhWcdhtr08StCs+L0o6aNZB2G2vVzDMitykt4GdgNmkDQJCoiI2DvTwMy2khOWWZGTtHNN5RHxQXPHYrY9POjCrPj5V6kVBdewzIqcpLdIkpaAdsAuwJSI2CvTwMy2kmtYZkUuIjYZcCFpX+CbGYVjts08StCshYmICcD+WcdhtrVcwzIrcpK+l7NaAuwLLMwoHLNt5oRlVvw65yxXAI8C92UUi9k2c8IyK1KS/h4RpwFLI+LarOMx214eJWhWpNILhj8NPAyMIhkluEFELM4gLLNt5hqWWfH6M/AEMJhk4tvchBVpuVnBcA3LrMhJujEivpV1HGbbywnLzMwKgq/DMjOzguCEZWZmBcEJy6yJSaqUNFHSJEn3SuqwHce6RdIX0+X/lTS0jm1HSTpkG84xU1LPhpZvts3KrTzXZZIu2toYrWVywjJremsiYkR619/1wLm5T0oq3ZaDRsTXI+LtOjYZBWx1wjLLV05YZs3reWC3tPbzjKR/AG9JKpX0G0mvSXpT0jcBlPiTpLclPQrsWH0gSWMljUyXj5E0QdIbkp6WNIgkMV6Y1u4+LqmXpPvSc7wm6dB03x6Sxkh6XdJNbHa9Vk0kPShpvKTJks7Z7LnfprE8LalXWrarpCfSfZ6XtGejvJvWovg6LLNmIqkVyYW8T6RFBwDDImJG+qW/LCL2l9QW+I+kMcA+wB7AR4HewNvAXzc7bi/gL8Bh6bG6R8RiSX8GVkbENel2/wB+HxEvSBoIPAl8BPgZ8EJEXCHpM8AmCagWZ6XnaA+8Jum+iFgEdAQmRMT/SPppeuzvADcD50bEVEkHAjcAR27D22gtmBOWWdNrL2liuvw88H8kTXWvRsSMtPxTwN7V/VNAV2AIcBhwZ0RUAnMl/buG4x8EPFd9rDpmsDgKGCptqEB1kdQ5Pcfn030flbSkAa9ptKTPpcsD0lgXAVXA3Wn57cD9kjqlr/fenHO3bcA5zDbhhGXW9NZExIjcgvSLe1VuEfDdiHhys+2Opf47BqsB20DSBXBwRKypIZYGX5ApaRRJ8js4IlZLGktyY8iaRHrepZu/B2Zby31YZvnhSeBbkloDSNpdUkfgOeDktI+rD3BEDfu+BBwuaZd03+5p+Qo2nal9DEnzHOl2I9LF54BT07JPAzvUE2tXYEmarPYkqeFVKwGqa4lfIWlqXA7MkHRSeg5JGl7POcy24IRllh/+l6R/aoKkScBNJC0gDwBTgbeAG4FnN98xIhaS9DvdL+kNNjbJPQJ8rnrQBTAaGJkO6nibjaMVLwcOkzSBpGlyVj2xPgG0kvQmcCXwcs5zq4C9JI0n6aO6Ii0/FTg7jW8ycEID3hOzTXhqJjMzKwiuYZmZWUFwwjIzs4LghGVmZgXBCcvMzAqCE5aZmRUEJywzMysITlhmZlYQ/j8pdrBIMlithgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(model_pipe_4, X_test, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.1s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 82.34% of the funtional wells.\n",
      "The model correctly predicts 55.81% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 76.51% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(model_pipe_4, X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:   51.6s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.5541534980632348"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_4 = cross_val_score(model_pipe_4, X_train, y_train, scoring='neg_log_loss', n_jobs = -2, verbose = 1, cv = 2)\n",
    "-cv_4.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:   11.0s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.6147478068023249"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_4 = cross_val_score(model_pipe_4, X_test, y_test, scoring='neg_log_loss', n_jobs = -2, verbose = 1, cv = 2)\n",
    "-cv_4.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:   51.9s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8755684174549365"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_5 = cross_val_score(model_pipe_4, X_train, y_train, scoring='roc_auc_ovo', n_jobs = -2, verbose = 1, cv = 2)\n",
    "cv_5.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend LokyBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done   2 out of   2 | elapsed:   10.8s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8397927932165815"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_5 = cross_val_score(model_pipe_4, X_test, y_test, scoring='roc_auc_ovo', n_jobs = -2, verbose = 1, cv = 2)\n",
    "cv_5.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# feature importance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* here I will be checking to see the 20 most important features in our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['installer_AMREF',\n",
       " 'installer_CES',\n",
       " 'installer_Central government',\n",
       " 'installer_Commu',\n",
       " 'installer_Community',\n",
       " 'installer_DANID',\n",
       " 'installer_DANIDA',\n",
       " 'installer_DWE',\n",
       " 'installer_District Council',\n",
       " 'installer_Government',\n",
       " 'installer_HESAWA',\n",
       " 'installer_Hesawa',\n",
       " 'installer_KKKT',\n",
       " 'installer_LGA',\n",
       " 'installer_RWE',\n",
       " 'installer_TASAF',\n",
       " 'installer_TCRS',\n",
       " 'installer_TWESA',\n",
       " 'installer_WEDECO',\n",
       " 'installer_World vision',\n",
       " 'installer_other',\n",
       " 'basin_Internal',\n",
       " 'basin_Lake Nyasa',\n",
       " 'basin_Lake Rukwa',\n",
       " 'basin_Lake Tanganyika',\n",
       " 'basin_Lake Victoria',\n",
       " 'basin_Pangani',\n",
       " 'basin_Rufiji',\n",
       " 'basin_Ruvuma / Southern Coast',\n",
       " 'basin_Wami / Ruvu',\n",
       " 'region_Arusha',\n",
       " 'region_Dar es Salaam',\n",
       " 'region_Dodoma',\n",
       " 'region_Iringa',\n",
       " 'region_Kagera',\n",
       " 'region_Kigoma',\n",
       " 'region_Kilimanjaro',\n",
       " 'region_Lindi',\n",
       " 'region_Manyara',\n",
       " 'region_Mara',\n",
       " 'region_Mbeya',\n",
       " 'region_Morogoro',\n",
       " 'region_Mtwara',\n",
       " 'region_Mwanza',\n",
       " 'region_Pwani',\n",
       " 'region_Rukwa',\n",
       " 'region_Ruvuma',\n",
       " 'region_Shinyanga',\n",
       " 'region_Singida',\n",
       " 'region_Tabora',\n",
       " 'region_Tanga',\n",
       " 'public_meeting_False',\n",
       " 'public_meeting_True',\n",
       " 'public_meeting_missing',\n",
       " 'scheme_management_Company',\n",
       " 'scheme_management_Other',\n",
       " 'scheme_management_Parastatal',\n",
       " 'scheme_management_Private operator',\n",
       " 'scheme_management_SWC',\n",
       " 'scheme_management_Trust',\n",
       " 'scheme_management_VWC',\n",
       " 'scheme_management_WUA',\n",
       " 'scheme_management_WUG',\n",
       " 'scheme_management_Water Board',\n",
       " 'scheme_management_Water authority',\n",
       " 'scheme_management_missing',\n",
       " 'permit_False',\n",
       " 'permit_True',\n",
       " 'permit_missing',\n",
       " 'extraction_type_afridev',\n",
       " 'extraction_type_cemo',\n",
       " 'extraction_type_climax',\n",
       " 'extraction_type_gravity',\n",
       " 'extraction_type_india mark ii',\n",
       " 'extraction_type_india mark iii',\n",
       " 'extraction_type_ksb',\n",
       " 'extraction_type_mono',\n",
       " 'extraction_type_nira/tanira',\n",
       " 'extraction_type_other',\n",
       " 'extraction_type_other - mkulima/shinyanga',\n",
       " 'extraction_type_other - play pump',\n",
       " 'extraction_type_other - rope pump',\n",
       " 'extraction_type_other - swn 81',\n",
       " 'extraction_type_submersible',\n",
       " 'extraction_type_swn 80',\n",
       " 'extraction_type_walimi',\n",
       " 'extraction_type_windmill',\n",
       " 'management_company',\n",
       " 'management_other',\n",
       " 'management_other - school',\n",
       " 'management_parastatal',\n",
       " 'management_private operator',\n",
       " 'management_trust',\n",
       " 'management_unknown',\n",
       " 'management_vwc',\n",
       " 'management_water authority',\n",
       " 'management_water board',\n",
       " 'management_wua',\n",
       " 'management_wug',\n",
       " 'payment_never pay',\n",
       " 'payment_other',\n",
       " 'payment_pay annually',\n",
       " 'payment_pay monthly',\n",
       " 'payment_pay per bucket',\n",
       " 'payment_pay when scheme fails',\n",
       " 'payment_unknown',\n",
       " 'water_quality_coloured',\n",
       " 'water_quality_fluoride',\n",
       " 'water_quality_fluoride abandoned',\n",
       " 'water_quality_milky',\n",
       " 'water_quality_salty',\n",
       " 'water_quality_salty abandoned',\n",
       " 'water_quality_soft',\n",
       " 'water_quality_unknown',\n",
       " 'quantity_dry',\n",
       " 'quantity_enough',\n",
       " 'quantity_insufficient',\n",
       " 'quantity_seasonal',\n",
       " 'quantity_unknown',\n",
       " 'source_dam',\n",
       " 'source_hand dtw',\n",
       " 'source_lake',\n",
       " 'source_machine dbh',\n",
       " 'source_other',\n",
       " 'source_rainwater harvesting',\n",
       " 'source_river',\n",
       " 'source_shallow well',\n",
       " 'source_spring',\n",
       " 'source_unknown',\n",
       " 'waterpoint_type_cattle trough',\n",
       " 'waterpoint_type_communal standpipe',\n",
       " 'waterpoint_type_communal standpipe multiple',\n",
       " 'waterpoint_type_dam',\n",
       " 'waterpoint_type_hand pump',\n",
       " 'waterpoint_type_improved spring',\n",
       " 'waterpoint_type_other']"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cat_ohe_cols = model_pipe_4.named_steps['trans'].named_transformers_[\n",
    "    'categorical'].named_steps['ohe'].get_feature_names(X_train_cat.columns).tolist()\n",
    "cat_ohe_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['gps_height',\n",
       " 'longitude',\n",
       " 'latitude',\n",
       " 'num_private',\n",
       " 'region_code',\n",
       " 'district_code',\n",
       " 'population',\n",
       " 'construction_year']"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_cols = X_train_nums.columns.tolist()\n",
    "num_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "feat_cols = cat_ohe_cols + num_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "important_feats = pd.Series(model_pipe_4.named_steps['rfc'].feature_importances_, \n",
    "                           index=feat_cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "installer_CES                   0.095271\n",
       "installer_Central government    0.086360\n",
       "source_machine dbh              0.066775\n",
       "installer_DWE                   0.047928\n",
       "installer_AMREF                 0.047747\n",
       "installer_DANIDA                0.035922\n",
       "source_other                    0.031833\n",
       "installer_DANID                 0.029768\n",
       "extraction_type_windmill        0.023705\n",
       "installer_Community             0.022088\n",
       "dtype: float64"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "important_feats.sort_values(ascending=False)[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "top_feats = important_feats.sort_values(ascending=False).head(20)\n",
    "plt.figure(figsize=(15, 15))\n",
    "top_feats.sort_values().plot(kind='barh')\n",
    "plt.xlabel('Level of importance')\n",
    "plt.ylabel('Features')\n",
    "plt.title('Random Forest Feature Importance');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  using the last model, and doing some manual tuning we are able to get a train score of $0.903$, a test score of $0.781$. this model is able to correctly able to predict $82.33$% of the functional wells, $55.81$% of the functional needs repair wells, and $76.41$% of the non-functional wells. the log loss on the training data was $0.55$ and the log loss on the test data was $0.61$. the auc for the training data was $0.88$ and for the test data it was $0.84$. \n",
    "\n",
    "*  the total accuracy score of non-functional and functional needs repairs is $132.22$, which is the highest of all the random forest classifer models. this is the random forest model that will move foward and be compared to other models that have been made.\n",
    "\n",
    "*  looking at the graph of feature importance we see that of the first 10 most important features 7 of them are the installer of the well. this tell us that who installed the well and how good of a job they did is very determinate of the water well status."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (learn-env)",
   "language": "python",
   "name": "learn-env"
  },
  "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.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}