02_logistic_regression_knn_svm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# logistic regression, knn, and svm models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import cross_val_score, GridSearchCV, RandomizedSearchCV\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from imblearn.pipeline import Pipeline as imbPipeline\n",
    "from sklearn.metrics import plot_confusion_matrix, confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": {
    "scrolled": 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": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 13365 entries, 33770 to 7443\n",
      "Data columns (total 21 columns):\n",
      " #   Column             Non-Null Count  Dtype  \n",
      "---  ------             --------------  -----  \n",
      " 0   gps_height         13365 non-null  int64  \n",
      " 1   installer          13365 non-null  object \n",
      " 2   longitude          13365 non-null  float64\n",
      " 3   latitude           13365 non-null  float64\n",
      " 4   num_private        13365 non-null  int64  \n",
      " 5   basin              13365 non-null  object \n",
      " 6   region             13365 non-null  object \n",
      " 7   region_code        13365 non-null  int64  \n",
      " 8   district_code      13365 non-null  int64  \n",
      " 9   population         13365 non-null  int64  \n",
      " 10  public_meeting     13365 non-null  object \n",
      " 11  scheme_management  13365 non-null  object \n",
      " 12  permit             13365 non-null  object \n",
      " 13  construction_year  13365 non-null  int64  \n",
      " 14  extraction_type    13365 non-null  object \n",
      " 15  management         13365 non-null  object \n",
      " 16  payment            13365 non-null  object \n",
      " 17  water_quality      13365 non-null  object \n",
      " 18  quantity           13365 non-null  object \n",
      " 19  source             13365 non-null  object \n",
      " 20  waterpoint_type    13365 non-null  object \n",
      "dtypes: float64(2), int64(6), object(13)\n",
      "memory usage: 2.2+ MB\n"
     ]
    }
   ],
   "source": [
    "X_test.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "status_group           \n",
       "functional                 0.543609\n",
       "non functional             0.383589\n",
       "functional needs repair    0.072802\n",
       "dtype: float64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.value_counts(normalize=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "status_group           \n",
       "functional                 0.543659\n",
       "non functional             0.383539\n",
       "functional needs repair    0.072802\n",
       "dtype: float64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test.value_counts(normalize=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  the target is imbalanced, so we will be using SMOTE in the pipeline to resample the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "y_train = y_train.status_group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test = y_test.status_group"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  create a function to calculate log-loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_loss(model, X=X_train, y=y_train, scoring='neg_log_loss', cv=3):\n",
    "    log_loss = cross_val_score(model, X, y, scoring=scoring, cv=cv)\n",
    "    log_loss = -log_loss.mean()\n",
    "    print(f'Log loss: {log_loss}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  create a function to calculate model predictions for functional, needs-repair, and non-funcitonal wells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": "markdown",
   "metadata": {},
   "source": [
    "# logistic regression\n",
    "\n",
    "*  we break up X_train into categorical and numerical variables, then use Pipelines and ColumnTransformer to OneHotEncode and scale the data. then we create an imbPipeline that takes the transformer, SMOTE, and the classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_cat = X_train.select_dtypes('object')\n",
    "X_train_num = X_train.select_dtypes(['float64', 'int64'])\n",
    "\n",
    "cat_pipe = Pipeline([('ohe', OneHotEncoder(sparse=False, handle_unknown='ignore'))])\n",
    "num_pipe = Pipeline([('ss', StandardScaler())])\n",
    "\n",
    "transformer = ColumnTransformer([('categorical', cat_pipe, X_train_cat.columns), \n",
    "                                  ('numerical', num_pipe, X_train_num.columns)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('trans',\n",
       "                 ColumnTransformer(transformers=[('categorical',\n",
       "                                                  Pipeline(steps=[('ohe',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                 sparse=False))]),\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",
       "                                                 ('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",
       "                ('smote', SMOTE(random_state=42)),\n",
       "                ('logreg', LogisticRegression(n_jobs=-1, random_state=42))])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logreg_pipe = imbPipeline([\n",
    "    ('trans', transformer), \n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('logreg', LogisticRegression(n_jobs=-1, random_state=42))\n",
    "])\n",
    "logreg_pipe.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score Train: 0.6367128070831775\n",
      "Accuracy Score Test: 0.6333707444818556\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy Score Train:', logreg_pipe.score(X_train,y_train))\n",
    "print('Accuracy Score Test:', logreg_pipe.score(X_test,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log loss: 0.8005327453806812\n"
     ]
    }
   ],
   "source": [
    "log_loss(logreg_pipe, X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAFwCAYAAADkNE/4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAA8wElEQVR4nO3dd5hdVdn+8e89k2TSE1KAVEIggBAgQOgdkS6giIK8IqJSREFFf4qN4gsqYAEREFEpgpQXgQjSTShSAim0QCQkIYEE0nubOfP8/th7wkky5SSZyT7nzP25rnPN2Wu3Z59MzjNr7bXWVkRgZmZW7CqyDsDMzKwQTlhmZlYSnLDMzKwkOGGZmVlJcMIyM7OS0CbrAKy09epRGYMGtM06jKL15ke9sw6h6LVdXJt1CEVv8bIZcyJig3+Zjjy0U8ydlyto2zGvrXwsIo7a0HO1JCcs2yiDBrRl9GMDsg6jaO3y629kHULR6/vM4qxDKHpPjL74vY3Zf+68HKMfG1jQtpV93um1MedqSU5YZmZlLoBaSr8m64RlZlb2glw4YZmZWZELoIbC7mEVMycsM7MyFwS5MpiGzwnLzKwVqMUJy8zMilwAOScsMzMrBa5hmZlZ0Qug2vewzMys2AXhJkEzMysBAbnSz1dOWGZm5S6Z6aL0OWGZmZU9kUNZB7HRnLDMzMpcALVuEjQzs2IXwKoyePyhE5aZWStQG24SNDOzIpfMdOGEZWZmRS4QOTcJmplZKXCToJmZFT03CZqZWUkIRHWU/td96V+BmZk1yTUsMzMrehEiF+50YWZmJaDWNSwzMyt2SacL17DMzKzIlUuni9JPuWZm1qRcqKBXoSRVShon6aF0uYekJyS9k/7cLG/biyRNkjRR0pF55XtIej1dd62kRgNwwjIzK3N1M10U8loPFwBv5S3/EHgqIoYAT6XLSNoROAXYCTgKuF5SZbrPDcBZwJD0dVRjJ3TCMjNrBWqjoqBXIST1B44Fbs4rPgG4NX1/K3BiXvldEbEyIqYAk4C9JPUBukbECxERwG15+9Sr9Bs1zcysUS3Q6eJ3wP8DuuSVbRERMwEiYqakzdPyfsCLedu9n5ZVp+/XLm+Qa1hmZmUuKOz+VXoPq5ekV/JeZ+UfS9JxwKyIGFPg6eu7LxWNlDfINSwrCbkcfOuo7ejZp5qf3zYFgAf/3IsRf+1FRZtg708u4ms/ncmYpzvzlyv6UlMt2rQNvv7TGQw7YAnLllRw4YlDVh9vzsy2HHbSfM697IOsLqnZXHrkSA4ePJV5yzrw2VtPAWD73nP46eFP065NjlxtBZc/dSBvfLgFQ7f8iJ996mkg+ba44YXh/HvSYNq3qebqTz/OgO6LyNWKpycP4ppn98nwqlrOZ45/i6M+NYkImPped3597X5UVdXwo+8/yxabL+WjWZ244soDWbK0ikMPnsLnTpywet+tB83nm989hslTemR4BesvgvXpJTgnIoY3sn5/4HhJxwDtga6S/gZ8JKlPWrvqA8xKt38fGJC3f39gRlrev57yBjlhtTBJ5wPnAmMj4rRmON4gYL+IuDNdHg6cHhHnb+yx1zrPVGB4RMxpzuNuqAdu7s2AIStZtiRpFBj/n848/1g3bnhqIu2qggVzkl/lbj1yXHbrZHpuWcPUt9vzoy8O5s6xE+jYuZYbnpy4+njnHbkdBxyzIItLaXYj3tieu8YN5fKjn1pd9p2DXuDGF4bz3NStOGDr9/jOQS/y1XtOYNKcHpz6t8+Riwp6dVrK/51+D0+/OwiAW18ZxsvT+9GmIsfNJ4/ggEHv8dzUrTK6qpbRs8cyTjjubc765qdZtaoNP/r+Mxxy4FQGDljI+Ne25J77hvL5k97g8ye9yV9u252RT2/NyKe3BmDQVvO5+EdPl1yySqjZBg5HxEXARQCSDgG+FxH/I+kq4MvAL9OfD6a7jADulPQboC9J54rREZGTtFjSPsBLwOnA7xs7t5sEW943gGOaI1mlBgFfrFuIiFeaO1kVm9kz2jL6qa4c/cW5q8seuq0nX/jmR7SrSloQuveqAWDbnZfTc8vk/Vbbr2DVygpWrVzzP+oHk9uxYE4bhu69dBNdQcsa80FfFq6oWqMsEJ2qqgHoUrWK2Us6ArCipu3qKXqqKnNE2o15RU1bXp6e3D6oqa3krVm92aJLeXw+a6usDNq1y1FRUUtVVY658zqw797TefLfgwF48t+D2W+f6evsd8iBUxn17KBNHG3zCCAXFQW9NsIvgU9Jegf4VLpMRLwJ3ANMAB4FzouIXLrPuSQdNyYB7wKPNHYC17BakKQbgcHACEkDgZ9HxNXpujeA49JNHwGeA/YDPgBOiIjlkrYFbgR6AzngZJJfgk9IGk/SE2ccyV84x0nqAfwlPecy4KyIeE3SJcDAtHwg8LuIuDaN4wGS6np74JqIuKnlPpENc+PF/fjaT2awbEnl6rIP3m3PGy915pZf9aFdVfD1n33A9sOWr7Hfcw93Y5udlq9OanVGPrAZBx+/gMZHfJS2K0fuz40nPcSFBz+PgNP//pnV63be8iMuPXIkfbsu5kePfHKdL6kuVSs5ePBU/jZ2l00cdcubO68j/3f/jtx+8/2sXFXJ2PF9GDu+L927rWDe/CSpz5vfkW7dVq6z70EHvMelVxyyiSNuPi0x00VEjAJGpe/nAp9sYLvLgcvrKX8FGFro+VzDakERcQ5Jm+yhwG8b2XQI8IeI2AlYAJyUlt+Rlu9KksxmkoxteDYihkXE2se8FBgXEbsAPyLpJlpnB+BIYC/gYklt0/IzI2IPYDhwvqSeG3SxLeTFJ7rSvVcNQ3ZZMxnlcrBkYSXXPPQOX/vpDC4/exCRl5emTmzPny/vywVXrvuX8tMPbsahn5nf0qFn6vO7vslVo/bjiJtO56pR+3HpkSNXr3v9wy347K2ncOodn+Ore42jXWXN6nWVquVXxz7BneN25oOFXbMIvUV17rSSffeezhlnnchpXzmJ9lU1HHbw5Cb32367Oaxc2Yb3pnVv+SBbQCBqo7BXMXPCKg5TImJ8+n4MMEhSF6BfRNwPEBErImJZE8c5ALg93f7fQE9J3dJ1D6fjIOaQ3AzdIi0/X9KrJN1OB5Akz0ZJOquuB9HsubmmNt8oE17uxIuPd+X0vXbkF+duxavPdeFX3xxIrz7V7H/MQiTYYbdlVFTAwnlJDWz2jLZc9tVBfP+aafQdtGqN4737ZntyOdZJgOXm+J0m8uQ7SRPX4//dhqFbzlpnmynzNmN5dRu27TVvddnPjnia9+Z3529jd91ksW5Ku+36IR991JmFi9qTy1XwnxcH8okd5rBgYXt6bJb89+qx2TIWLlyzifXgEm4OrNMCA4c3ueKOrrzUsObn3T7vfX77Q46kqXZD/tRprJvoOudIb5geDuyb1uLGrRVXvSLipogYHhHDe/esbGrzjXLmj2Zyx5gJ3DZ6Ahfd8B67HrCYH1w3jf2OWsj45zoD8P67VVSvEt165FiysJKfnj6Yr1w0k532WvcezKgHNuOQExa0aMzFYPaSjgzvn3S42nvgB0xbkPzd0q/rIipVC0CfLosZ1GMBMxYlQ2m+uf9LdGm3kitH7p9N0JvArDmd2GH7OVS1qwGCYbt8yPT3u/Li6P4cflhS0zr8sMm88NLHndqk4MD9pvH0s6XbASWZS7CyoFcx8z2sTWcq6T0rSbsDWze2cUQskvS+pBMj4gFJVUAlsJg1B+vlewY4Dfh5mozmpMdp6DTdgPkRsUzSDkDJ9GM+8pR5/Oa7Azjr0O1p2zb4/jXTkGDEX3sxY0o77vztltz52y0B+MVd767ulPHMP7vz89ubbgIqJb869gmG959B9w4reOKs27j++T259IlD+MGhz1GpYFWukksfPwSA3frN5My9xlFTW0GEuPypg1iwvANbdF7CWfuMZfLc7tz9pXsBuGv8UP7x+o4ZXlnzm/jfXjz7/ECu++2/yOXEu5N78MhjQ2jfIenWfuTh7zJrdicuv/LA1fvsvNNHzJnbkQ8/aui/XfELKHgWi2KmiEbHadlGquseDiwl6ea5OfAySfPd0elmD0XE0HT77wGdI+ISSUOAPwK9SEaFnwxMJ+lp0wu4hXU7XfyVJBmu3eliST0dPmYCD5CMLp9I0rnjkogYVWi39uG7to/Rjw1obJNWbZdffyPrEIpe32cWZx1C0Xti9MVjmhgb1aj+Q7vFefcUVnP+0U6PbNS5WpJrWC0sIgblLR7RwGare8nUJZX0/TvAYfVsv3ZPnFHp9vNI5u1aO4ZL1lrO75VzNPVYK24zK2ERKosalhOWmVkrsJFjrIqCE5aZWZmr63RR6pywzMzKXNLporjHWBXCCcvMrBUo9jFWhXDCMjMrc3UzXZQ6Jywzs1ag1jUsMzMrdhHUPZyxpDlhmZmVuUDU1LqXoJmZlYBcMz3AMUtOWGZmZc7d2s3MrER4aiYzMysRtW4SNDOzYhcB1e50YWZmxc4Dh83MrGS4SdDMzIqeewmamVnJcC9BMzMrfuF7WGZmVgICqHENy8zMip3vYZmZWclwwjIzs6LncVhmZlYyPA7LzMyKX7hJ0MzMSkAANbXuJWhmZkXO97DMzKxkhBOWmZmVAne6MDOzohfudGFmZqVB5NzpwszMSoHvYVmr984bnTl62/2yDqNo9R80J+sQil5uwn+zDqHseS5BMzMrDZHcxyp1pd+oaWZmTapFBb2aIqm9pNGSXpX0pqRL0/Iekp6Q9E76c7O8fS6SNEnSRElH5pXvIen1dN21khoNwAnLzKzMBck9rEJeBVgJHBYRuwLDgKMk7QP8EHgqIoYAT6XLSNoROAXYCTgKuF5SZXqsG4CzgCHp66jGTuyEZWZW9kSutrBXUyKxJF1sm74COAG4NS2/FTgxfX8CcFdErIyIKcAkYC9JfYCuEfFCRARwW94+9XLCMjNrBZqxhoWkSknjgVnAExHxErBFRMxMzhUzgc3TzfsB0/N2fz8t65e+X7u8Qe50YWZW5iLWq1t7L0mv5C3fFBE3rXm8yAHDJHUH7pc0tJHj1XfiaKS8QU5YZmatwHp0a58TEcML2TAiFkgaRXLv6SNJfSJiZtrcNyvd7H1gQN5u/YEZaXn/esob5CZBM7NWIKKwV1Mk9U5rVkjqABwOvA2MAL6cbvZl4MH0/QjgFElVkrYm6VwxOm02XCxpn7R34Ol5+9TLNSwzs1agGWe66APcmvb0qwDuiYiHJL0A3CPpq8A04OTkvPGmpHuACUANcF7apAhwLnAL0AF4JH01yAnLzKzMNefzsCLiNWC3esrnAp9sYJ/LgcvrKX8FaOz+1xqcsMzMyt36dbooWk5YZmatQRlMzeSEZWbWCpR1DUvS72kkJ0fE+S0SkZmZNbtymPy2sRrWK42sMzOzEhEBUc4PcIyIW/OXJXWKiKUtH5KZmTW3cqhhNZlyJe0raQLwVrq8q6TrWzwyMzNrPlHgq4gVUkf8HXAkMBcgIl4FDmrBmMzMrFkVNvFtsXfMKKiXYERMX+u5WrmGtjUzsyJU5LWnQhSSsKZL2g8ISe2A80mbB83MrASUycDhQpoEzwHOI3lOyQckT5g8rwVjMjOz5hYq7FXEmqxhRcQc4LRNEIuZmbWUMmgSLKSX4GBJ/5Q0W9IsSQ9KGrwpgjMzs2bSSnoJ3gncQzKlfF/gXuDvLRmUmZk1o6AsmgQLSViKiNsjoiZ9/Y2iz8NmZpavuR7gmKXG5hLskb4dKemHwF0kieoLwMObIDYzM2suRZ6MCtFYp4sxJJdYV0c8O29dAD9vqaDMzKx5qba4m/sK0dhcgltvykDMzKyFlECHikIUNNOFpKHAjkD7urKIuK2lgjIzs+ZU/B0qCtFkwpJ0MXAIScL6F3A08BzghGVmVirKoIZVSC/BzwGfBD6MiK8AuwJVLRqVmZk1rzIYh1VIk+DyiKiVVCOpKzAL8MBhy0SvPiv53lWT2KxXNRHwyF1b8OCtffjqD6ay92HzqamuYOa0Kn7zg21ZurgNhx4/m5O+NmP1/lvvsIxvnbALk9/qlOFVtKxOnVZxwYWvsNWgRUTA767ekz32/JAjj5nMwgXJ35q3/mVnXhndB4DPn/oWRxw1hdpaceMfdmPsK1tmGf4md+JXZ3P0afOQgkfu6Mn9N/cG4PgzZ3P8V+ZSWwMvPdWVP/9v34wj3QgBlHOnizyvSOoO/Imk5+ASYHRTO0k6HzgXGBsRzTK1k6RBwH4RcWe6PBw4PSLOb47j551nKjA8nZaqxUkaBXwvIjJ7yrOkvsC1EfG5rGIoRK5G/OkXW/Hum53p0CnHtQ+8xrj/dGPcf7rz16u3ojYnzvz+e3zhnA/4y1VbMXJEb0aOSL6ABm23lJ/dOLGskxXA2eeNZ8zLW3LFZfvRpk0tVVU17LHnhzxw33b8497t19h2wMBFHHTIdM752pH07LmCK658mq+fcTS1ZfDlVoittl/O0afN4/xjh1C9Slxx52ReeqorvftUs9+Rizj3k9tRvaqCbj2rsw51o6nIa0+FKGQuwW+kb2+U9CjQNSJeK+DY3wCOjogpGxPgWgYBXySZfYP0Cz6zL/msSWoTETXNcayImEHS/Nti52gO82e3Y/7sdgAsX1rJ9Hc70HOLVYx9rvvqbd4e35kDjpq3zr4Hf3ouTz/Ua1OFmokOHasZuvNsfnPlngDU1FRQU9Ouwe333f8Dnhk1gJrqSj76sBMzZnRmu+3n8fZbPTdVyJkaOGQlb43tyMrlyd2R117ozP5HL2S7XZZx93WbU70qKV84t22WYTaPMkhYDd7DkrT72i+gB9Amfd8gSTeSNBuOkPQdSZdI+l7e+jckDUpfb0n6k6Q3JT0uqUO6zbaSnpT0qqSxkrYBfgkcKGl8etxDJD2Ubt9D0gOSXpP0oqRd0vJLJP1F0ihJk9OaX10cD0gak577rKY+LElLJF2exvSipC3S8t6S7pP0cvraPy3vlJ77ZUnjJJ2QlneQdFca691A3TVXSrol/Xxel/SdemK4RdJvJI0EfiVpG0mPptfxrKQd8ra7MS37r6Tj0vJBadnY9LVfXvkb6fszJN0r6Z/A4019LlnZvN8KttlxKRNf7bxG+REnz+blZ7qvs/3Bx85h1D/LO2H16bOUhQur+M73X+b3Nz7BBd99har2yd8bnz5hEn+46XG+/b2X6dx5FQA9ey5n9qyOq/efM7sDPXstzyT2LEx9uz07772ELpvVUNWhlj0PW0Tvvqvot81Khu69lGseeoer7pvEdrsuyzpUo/Ea1q8bWRfAYQ2ujDhH0lHAoRExR9IljRxrCHBqRHxd0j3AScDfgDuAX0bE/ZLakyTXH5I0ndV9+R6Sd5xLgXERcaKkw0h6MQ5L1+0AHAp0ASZKuiEiqoEzI2JemiRflnRfRMxtJNZOwIsR8WNJVwJfB/4XuAb4bUQ8J2kg8BjwCeDHwL8j4sy0WXW0pCdJBmEvi4hd0sQ6Nj3+MKBfRAxNr697A3FsBxweETlJTwHnRMQ7kvYGrufjf5tBwMHANiQzlmxLcg/yUxGxQtIQknkhh9dzjn2BXSJinapKmtzPAmivbJrX2nfM8ZM//Jc//u8gli35+Nf4lHPfJ1cDIx9cMzFtv+tiViyv4L13Oq59qLJSWVnLtkMWcON1uzHx7Z6c/Y1xfP6Ut/nnA9vy97/tSAR86Yw3+No5r/K7q/dEraPlr0HTJ7Xnnus35xd3TWbF0gqmTOhArkZUVkLnbjkuOG5bth+2nB//8T2+vM8OfDyPQukp6ybBiDh0E8UwJSLGp+/HAIMkdSH54r4/jWUFgBr/33UASbIjIv4tqaekbum6hyNiJbBS0ixgC+B94HxJn0m3GUCSPBtLWKuAh/Ji/VT6/nBgx7z4uqbXcARwfF7tsj0wEDgIuDaN9TVJdU2sk4HBkn5PMv1VQ7Wbe9Nk1RnYD7g379z5PTjviYha4B1Jk0kS9xTgOknDSJ4cvV0D53iivmSVxnwTcBNAt8pem/y/QWWbWn7yh4mMHNGL5x//uOnq8M/MYq/D5nPRl3Zk7S+Wg48r/+ZAgDmzOzJndgcmvp18Ls8905+TT32bBQtWD6Hk0X8N5pL/fS7Zfk4Hem/+ce2hV+/lzJ3TYdMGnbHH/t6Tx/6efF5f+eFMZs9sy8AhK/nPv7oBYuL4jtTWQrceORbOK2joanEqg3FYhXRrbw41a52rfd77lXnvcyRJdEM+2fr2qfsyXeccae3scGDfiNgVGLdWXPWpjlg9PWRdrJBc274RMSx99YuIxWlMJ+WVD4yIuqc1r/NFHxHzSYYNjCJ5SObNDcSxNO+8C/KOPywiPlHP9ecvfwf4KD3PcKChGxxLGyjPWPDtX7zL9EkduP8vH/fa2uOg+Zx89gwuPXsHVq6oXGMPKTjw6NaRsObPb8/s2R3p138xAMN2n8W097qyWY+Pm/n2O+AD3pua/C334vN9OeiQ6bRpm2OLLZfSt98S/juxR73HLld1HSp691vF/scsZNQD3Xn+0a4MO2AJAP0Gr6Rtu2DhvMrGDlPcAqgt8FXENtWfC1OBuma83YFGp32KiEWS3pd0YkQ8IKkKqAQWkzTr1ecZkgdN/jxNRnPS4zR0mm7A/IhYlt732Wf9LmkNjwPfBK4CkDQsrTU+BnxL0rciIiTtFhHj8mIdqWQWkbr7bb2AVRFxn6R3gVsaO2l6fVMknRwR9yq52F0i4tV0k5Ml3UryeQ8GJqbX/X46VOHLJJ9rydhpj8Uc/pk5THm7I9eNSC7z1l8P5JyfTaFtu+DyWyYA8Pb4Llz3s2T0xdC9FjHnw3Z8OL2pv0fKw43X7cb/u+gl2rSt5cOZnfjtVXtyznnjGLztAiLERx925Pe/2wOAae9149mnB/DHPz9GLiduuHa3VtNDsM7Pbn6PLpvVkKsW1/2oH0sWtuGxu3rw3d9M54//nkh1tbjqggGUcnMglHmTYDO7Dzhd0njgZeC/BezzJeCPki4DqoGTgdeAGkmvknyZj8vb/hLgr2nz2jLgy00c/1HgnHT7icCLhV5MPc4H/pAeqw1JQjqHZILg3wGvpclkKkniviEv1vF8PEygX1peVxu9qIBznwbcIOknQFuSWfXrEtZE4GmSJtBz0vtW1wP3SToZGEnR1qTq9+aYrhy97b7rlL/8yc0a3Of1l7rxnc/t3JJhFZXJ73bngvMOX6Ps6l/t3eD2d9/5Ce6+8xMNri93F35m23XKaqoruPJbW2UQTQsqg4SlaOIBKOkX7WnA4Ii4LO1UsGVENDkWy7Ij6RbgoYj4v5Y8T7fKXrFPh2Nb8hQlTYP6Zx1C0ctNKOTv19btyfi/MRFRX+eoglQNGBD9L1in03G9Jn//wo06V0sq5B7W9SQ9xk5NlxcDf2ixiMzMrFkpCn8Vs0KaBPeOiN0ljYOkY4CkhkciWlGIiDOyjsHMikgZ3JssJGFVS6okbQGV1Jui70tiZmb5ir32VIhCmgSvBe4HNpd0OcmjRa5o0ajMzKx5tYbZ2iPiDkljSB4xIuDEvLFEZmZW7Erg/lQhCnmA40CSbuL/zC+LiGktGZiZmTWj1pCwSKYICpLaVXuSQagTgZ1aMC4zM2tOrSFhRcQaIy7TmSrObrGIzMys2ZVDk+B6zyUYEWOBPVsgFjMzaynN1OlC0gBJI5U8GupNSRek5T0kPSHpnfTnZnn7XCRpkqSJko7MK98jfZTSJEnXqokZzgu5h/XdvMUKYHdgdtOXZWZmRaF5O13UABdGxNj0qRRjJD0BnAE8FRG/lPRDksdB/UDSjsApJLeR+gJPStouInIk09SdRTI13r+Ao4BHGjpxITWsLnmvKpJ7Wids0GWamVk2mqmGFREz05Y20qdSvEUyD+oJwK3pZrcCJ6bvTwDuioiV6RPoJwF7SepD8gT7F9KnYNyWt0+9Gq1hpQOGO0fE95u+DDMzK1otcA9L0iBgN+AlYIuImAlJUpO0ebpZP9acXPz9tKw6fb92eYMaTFiS2kRETdrJwszMSpRYrybBXpJeyVu+KX1o65rHTB4gex/w7SYe5dTQswobe4ZhvRqrYY0muV81XtII4F7yHkUREf9o7MBmZlYkAlT4hHpzmpqtXVJbkmR1R14u+EhSn7R21QeYlZa/T/JE9zr9gRlpef96yhtUyD2sHiSPjT+M5FlOn05/mplZqWi+XoIC/gy8FRG/yVs1go+fQ/hl4MG88lMkVUnaGhgCjE6bDxdL2ic95ul5+9SrsRrW5mkPwTdYt/pWBj36zcxakeb71t6f5AG7r6cP5QX4EfBL4B5JXwWmkTx0l4h4U9I9wASSHobnpT0EAc4leRhvB5LegQ32EITGE1Yl0JkNaGc0M7Pi0lzd2iPiOerPC5DMOVvfPpcDl9dT/gowtNBzN5awZkbEZYUeyMzMilgZVDMaS1il/7QvMzNb304XRauxhFVv1c7MzEpQOdewImLepgzEzMxaTjlMflvI40XMzKzUOWGZmVnRK3CMVbFzwjIzK3OiPHrROWGZmbUC5d5L0MzMyoWbBM3MrCQ4YZmZWdFr3icOZ8YJy8ysNXDCMjOzUuAalrV6tZ3bs3LfHbMOo2i1WVyddQhFb8VjW2cdQvE7YuMP4V6CZmZW/Dxw2MzMSoYTlpmZFTvhe1hmZlYqnLDMzKzoBai29DOWE5aZWSvgJkEzMysNTlhmZlYKXMMyM7PS4IRlZmZFz5PfmplZKRCemsnMzEpFlH4VywnLzKwVcJOgmZkVP09+a2ZmpcL3sMzMrDS4hmVmZkXPcwmamVmpcKcLMzMrDU5YZmZW7PwARzMzKw0RHjhsZmalwd3azcysJLhJ0MzMil8A7tZuZmYlofTzFRVZB2BmZi1PUdiryeNIf5E0S9IbeWU9JD0h6Z3052Z56y6SNEnSRElH5pXvIen1dN21ktTUuZ2wzMxag7qegk29mnYLcNRaZT8EnoqIIcBT6TKSdgROAXZK97leUmW6zw3AWcCQ9LX2MdfhhGVmVu4i6SVYyKvJQ0U8A8xbq/gE4Nb0/a3AiXnld0XEyoiYAkwC9pLUB+gaES9ERAC35e3TIN/DMjMrc8nA4Ra9ibVFRMwEiIiZkjZPy/sBL+Zt935aVp2+X7u8UU5YZmatQeHjsHpJeiVv+aaIuGkDz1rffalopLxRTlhmZq3AetSw5kTE8PU8/EeS+qS1qz7ArLT8fWBA3nb9gRlpef96yhvlhGVF7/tnPsM+w6azYFF7vvqTkwDo0mklPz3332zZawkfzunMZdcfxpJlVQAM7j+P75zxHJ06VFNbK8697Hiqq9twyF6TOe3T46msCF58dQA33bNXlpfVYj573ASOOvwdCDFlWneuvm5/qqsrOeHotzj+6InkasXoMf25+fY9aNMmxwVnv8h228ylNsQNf9mT197cMutLaF6raqm6cGbSCJULcgd2oub0zah4Ziltb5+Pplez8tq+xHbJ7w81QdvfzqFi0krIQe7wztSc0h2AypFLaHPXAhBEjzas+kFv6FbZ0JmLR8s/cXgE8GXgl+nPB/PK75T0G6AvSeeK0RGRk7RY0j7AS8DpwO+bOokTVguTdBVwDPCviPh+Mx1zGNA3Iv6VLh8P7BgRv2yO4+edZ0lEdG7OY26Ix54bwgNP7cgPv/706rJTj32VcW/15e8P78qpx77Kqce+yp/u3YuKilouOnsUv7jpYCZP70nXTivI1VTQtdMKzv7CaM655AQWLu7AD772NLt9Ygbj3uqb4ZU1v549lnHiMW/ztW8fz6pVbfjxhU9zyAFTmDW7M/vuNZ1zvvtpqmsq6d51OQBHH/4OAGd/93i6d13O5T95im/+4FgimuxhXDraipVX9oEOFVATVH13Jrk9OxCD2rLqZ5vT9tq5a2xe+cxSqA5W/rE/rKil6qwPyB3SiejdhrY3zGXFn/pDt0ra3DyPNiMWUfOlzRo4cTFpvrkEJf0dOISk6fB94GKSRHWPpK8C04CTASLiTUn3ABOAGuC8iMilhzqXpMdhB+CR9NUo9xJseWcDuzdXskoNI0mCAETEiOZOVsXktf/2YdHSqjXK9t9tGo89NwRIEtoBu08DYM+hHzB5eg8mT+8JwKKl7amNCvpsvpj3P+zGwsUdABg7oS8HDZ+yCa9i06msrKWqXY6Kilqq2tUwb15HjjtyInffP5TqmqQ2sGBR8jls1X8h41/vs7psydJ2bLfN3AaPXZKkJFkB1ATkIqkhDWxHDGhXz/agFbXJdqsC2kB0rFhdQ9GKWohAS2uJniVQu0qpNgp6NSUiTo2IPhHRNiL6R8SfI2JuRHwyIoakP+flbX95RGwTEdtHxCN55a9ExNB03TfT3oKNcsICJA2S9JakP0l6U9Ljkjqk64ZJelHSa5LurxsQJ2mUpF9JGi3pv5IOrOe4I4BOwEuSviDpFkmfy1u/JP15SHq8/5P0tqQ76gbRSdpT0vOSXk3P1Q24DPiCpPHpcc+QdF26/VaSnkrjfUrSwLT8lnRw3vOSJtfFIalzut3YdBDfCS35WTeXzbotZ97CjgDMW9hxdY2h/5YLAfjVhY/yx0se4AtHvwbABx91ZWCfBWzRazEVFbXsv/s0Nu+5NJvgW9DceR25d8RO/O3G+7jr5ntZtqwdY17tS/8+ixj6iVlc+4t/cfVlj7HdNnMAmPzeZuy753QqKmrZcvPFDNlmLr17ld/nQi6oOvcD2n9hGrndOhA7tG940wM7Ee0raH/qNNr/z3RqPtcNulZCG7HqW72oOucD2n9xOpq2ityRXTbhRWyEZuzWniUnrI8NAf4QETsBC4CT0vLbgB9ExC7A6yTV3zptImIv4NtrlQMQEccDyyNiWETc3cT5d0uPsyMwGNhfUjvgbuCCiNgVOBxYCvwMuLuB414H3JbGewdwbd66PsABwHEkVXiAFcBnImJ34FDg14WMOC9WlRXB0CEfcfkfD+H8K47jgD2mstsnZrBkWRW/u21/fnbuSK750UN8OKczuVz5/fp37rSS/faczunf+Cynfv1k2rev4ZMHTaayMujSaRXnX3Q0f7ptD35y4TNA8OhT2zJnbkf+cOXDnPOVl5kwcXNyuZL9529YpVh5Qz9W3DGAiokr0dRVDW5aMXElVMCKOwey4rYBtLlvEZpZDTVBm4cWsfIP/Vhx5wBi63a0uXvBpruGjdV8A4cz43tYH5sSEePT92OAQWltpntE1N08uRW4N2+ff+Rvv5HnHx0R7wNIGp8ebyEwMyJeBoiIRen6xo6zL/DZ9P3twJV56x6IiFpggqQt0jIBV0g6iKTjaz9gC+DDhk4g6SySEepUte9e6PU1q/kLO9Cj2zLmLexIj27LVjdxzZ7fkVcn9mHRkuQv6JdeG8B2g+Yw7q2+vDB+IC+MHwjAsQe/TW1t+X0x77bLTD6c1ZmFi5Lrf+7Fgey4/Sxmz+3Icy8NBMTESb2oDejWdSULF7Xnxlv2XL3/by9/hA9mds0o+k2gcyW1u7an8uXl1AyqpzmQpGNF7fAO0EbQvZLaHauo+O9Kahcl1Y/o2xaA3MGdaHP3wk0W+kYr7lxUkPL7E3PDrcx7n6OwZF63T6Hb15B+5mktJv9/TH3nFxv/a5a/f/456r6tTwN6A3tExDDgI6Dh9hIgIm6KiOERMbxtu04bGd6GeX78QI48IOkwcOQB7/CfcUkievn1/mzTfx5V7WqoqKhl1+0/ZOqM7gB075I0G3buuJITPvkW/3p6+0xib0mz53Rih+1mU9WuBgh223km097vxvOjBzBs5+RvkH59FtG2TS0LF1VR1a6G9lXVAOy+ywxqa8W097tndwEtYUEOlqT3+VfWUjF2ObUD2ja4efRuQ8X4FUltY0UtFW+vpHZAO6JXJRXTqpPjARVjVzR6nGKjiIJexcw1rEZExEJJ8yUdGBHPAl8Cnm5qv0ZMBfYA7iGZsqSp3/a3gb6S9oyIlyV1AZYDi4GGGs+fJ5m763aSZPRcE+foBsyKiGpJhwJbFXIhm9JPzhnJrjvMpFvnFdz9m79zywO78/eHduFn5/2bow/8L7PmdeLSP3wSgCXLqrj3saHccPGDRCQ1rJdeTZLZN097kcEDknvBt48YxvsfdcvsmlrK2+/05tkXtuL6qx8il6tg0pQe/OuJ7Qjgwm88z02/HUF1TQVX/X5/QHTvtoIrfvokEWLOvA786toDsr6EZqd5OdpdPTt5vEYt5A7qRO0+Han4z1LaXT8XFuao+umH1G5TxaortqTm+K60+/Vsqs76AIDcEZ2JwcnfltWndafqezOTjhibt2HV93pneWmFC5JOJCVOBXTMKHuSBgEPRcTQdPl7QOeIuCTtQn4j0BGYDHwlIuZLGgV8LyJekdQLeCUiBtVz7NVdw9NmuAdJallPAd+KiM6SDkmPdVy63XXp8W6RtCfJ+IQOJMnqcJKa2WMkCe8X6brhEfHN9Fr+AvQCZqfxTpN0S3qN/5cfVxr7P9NjjQf2B46OiKmFdGvv0q1/7LHvtwr8pFufNoursw6h6K24ZFHWIRS9/xxx1ZgNGMy7WrdOfWOfHc8uaNvHX7lko87VkpywbKM4YTXOCatpTlhNa5aE9YmzCtr28TGXFm3CcpOgmVlrUAaVEycsM7NyF6zP5LdFywnLzKwVKPYegIVwwjIzK3sBtaVfxXLCMjMrd4HvYZmZWYko/QqWE5aZWWvge1hmZlYanLDMzKzoRUCu9NsEnbDMzFoD17DMzKwkOGGZmVnRC5LZ6kucE5aZWdkLCN/DMjOzUuAmQTMzK3qBewmamVmJcA3LzMyKXzhhmZlZCQg8W7uZmZUI17DMzKwkOGGZmVnRiyByuayj2GhOWGZmrYFnujAzs5LgJkEzMyt6Ee4laGZmJcI1LDMzK37udGFmZqXAjxcxM7OS4ceLmJlZsQsgXMMyM7OiF36Ao5mZlYhyqGEpyqCro2VH0mzgvazjyNMLmJN1EEXOn1HjivHz2Soiem/ozpIeJbmuQsyJiKM29FwtyQnLyoqkVyJieNZxFDN/Ro3z51O8KrIOwMzMrBBOWGZmVhKcsKzc3JR1ACXAn1Hj/PkUKd/DMjOzkuAalpmZlQQnLDMzKwlOWGZmVhKcsMzKmKRKSU9mHYdZc/DUTFayJPVobH1EzNtUsRSriMhJWiapW0QszDqeYiJpMcm8sOusAiIium7ikKwJTlhWysaQfOGonnUBDN604RStFcDrkp4AltYVRsT52YWUvYjoknUMtn6csKxkRcTWWcdQIh5OX9YISZsD7euWI2JahuFYPTwOy8qCpM2AIaz5hfNMdhFZqZB0PPBroC8wC9gKeCsidso0MFuHa1hW8iR9DbgA6A+MB/YBXgAOyzCszEm6JyI+L+l16rlXExG7ZBBWMfo5ye/MkxGxm6RDgVMzjsnq4YRl5eACYE/gxYg4VNIOwKUZx1QMLkh/HpdpFMWvOiLmSqqQVBERIyX9KuugbF1OWFYOVkTECklIqoqItyVtn3VQWYuImenPYnpeWTFaIKkz8Axwh6RZQE3GMVk9PA7LysH7kroDDwBPSHoQmJFpREVE0j6SXpa0RNIqSTlJi7KOq4icACwHvgM8CrwLfDrTiKxe7nRhZUXSwUA34NGIWJV1PMVA0ivAKcC9wHDgdGDbiPhxpoGZrSfXsKwspDM69AWmkHS82DLbiIpLREwCKiMiFxF/BQ7NOqZiIemzkt6RtFDSIkmLXQMtTr6HZSVP0reAi4GPgNq0OAD3gkssk9QOGC/pSmAm0CnjmIrJlcCnI+KtrAOxxrlJ0EqepEnA3hExN+tYipGkrUiSeTuS+zTdgOvTWlerJ+k/EbF/1nFY05ywrORJGgl8KiLcs6sBaQ1rB5Ka50Tf3/uYpGtImpAfAFbWlUfEP7KKyernJkErB5OBUZIeZs0vnN9kF1LxkHQscCNJ7zcBW0s6OyIeyTayotEVWAYckVcWgBNWkXENy0qepIvrK48IDx4GJL0NHFfXBChpG+DhiNgh28jM1o9rWFby6hKTpC7JYizJOKRiM2ut+1WTSebMM0BSf+D3wP4kNavngAsi4v1MA7N1uFu7lTxJQyWNA94A3pQ0RpInLv3Ym5L+JekMSV8G/gm8nHbn/mzWwRWBvwIjSCa/7Ufy+fw104isXm4StJIn6XngxxExMl0+BLgiIvbLMq5iIamxL9+IiDM3WTBFSNL4iBjWVJllz02CVg461SUrgIgYJcnjjFIR8ZWsYyhycyT9D/D3dPlUwEMkipCbBK0cTJb0U0mD0tdPSGa8MEDSdpKekvRGurxL+hlZ4kzg88CHJIOqP5eWWZFxk6CVvPThjZcCB5B0234GuCQi5mcaWJGQ9DTwfeCPEbFbWvZGRAzNNjKz9eMmQSt5aWI6P+s4iljHiBgtKb+s1Q+ylvT/IuJKSb+n/gdc+neqyDhhWcmS9LuI+Lakf1L/F87xGYRVjOakY68CQNLnSJq+Wru6uQNfyTQKK5gTlpWy29OfV2caRfE7D7gJ2EHSByT3907LNqTsRcQ/07fLIuLe/HWSTs4gJGuC72FZyZN0QURc01RZaySpEvhlRHw/7TlZERGLs46rmEgaGxG7N1Vm2XPCspLXwBfOuLoOBq2dpH9HxGFZx1FsJB0NHEPSQ/DuvFVdgR0jYq9MArMGuUnQSpakU4EvkkzmOiJvVRc8jibfuPTzuRdYWlfo2ciZQXL/6nhgTF75YpLHsFiRcQ3LSlb6nKetgV8AP8xbtRh4zY8bSTQw00Wrn+GijqSuwNKIyKXLlUBVRCzLNjJbmxOWlTxJg4EZEbEiXe4AbBERUzMNzEqCpBeBw+smTZbUGXjcU3sVH890YeXgHqA2bzlH0vxlVoj2+TP8p+87ZhiPNcAJy8pBm/wn6Kbv22UYj5WWpZJWd9qRtAewPMN4rAHudGHlYLak4yNiBICkE4A5GcdkpePbwL2SZqTLfYAvZBeONcT3sKzkpbM43EHyPCMB04HT13poYasl6QKS5zstBm4GdgN+GBGPZxpYEZHUFtie5Pfn7Yiozjgkq4cTlpWN9Ga5PDB2TZJejYhdJR1JMuvFT4G/emDsxyTtBwwir9UpIm7LLCCrl5sEreRJqgJOIv3CqZvkNSIuyzCsYlI36+0xJInqVa01E25rJul2YBtgPEmHHUjmXXTCKjJOWFYOHgQWkgz+XJlxLMVojKTHScasXSSpC2v2qmzthpPMbOHmpiLnhGXloH9EHJV1EEXsq8AwYHJELJPUE/BTiD/2BrAlnsG+6DlhWTl4XtLOEfF61oEUk/yu2qnBbgmsVy9ggqTR5NXQ/Xia4uNOF1byJE0AtiV5bMZKkns2ERG7ZBpYxiSNTN+2B/YAXiP5bHYBXoqIA7KKrZhIOri+8oh4elPHYo1zwrKSl84puI6IeG9Tx1KMJN0FXF5XA5U0FPheRJyRaWBm68lNglYO/FdX43bIby6NiDckDcswnqIiaTEf/w61A9qSTIbbNbuorD5OWFYOHib5whFJ89fWwERgpyyDKiJvSboZ+BvJ5/Q/fPx4+FYvIrrkL0s6EfCzsIqQmwSt7KSdDc6OiLOzjqUYSGoPnAsclBY9A9xQN7u9rUvSixGxT9Zx2JqcsKws+RHna0ofuTIwIiZmHUuxkfTZvMUKknFZB0fEvhmFZA1wk6CVPEnfzVusIOkRNzujcIqOpOOBq0juz2yd3r+6zN22V/t03vsaYCpwQjahWGNcw7KSJen2iPiSpAXAb9Piui+c+9zklZA0BjgMGBURu6Vlr7nbv34VET+Q9PmIuCfreKxprmFZKdsj7dI+Dfj9Wus6Ak5YiZqIWOhBw+s4RtJPgB+SPATUipwTlpWyG4FHSXoFvpJXLpLecIOzCKoIvSHpi0ClpCHA+cDzGcdUDB4leW5aJ0mL8srrBp67W3uRcZOglTxJN0TEuVnHUawkdQR+DByRFj0G/K+bTBOSHowI37MqAU5YZq2EpE4RsTTrOMw2VEXWAZhZy5K0Xzrf4lvp8q6Srs84LLP15oRlVv5+CxwJzAWIiFf5eBCxWclwwjJrBSJi+lpFuXo3NCti7iVoVv6mS9oPCEntSHoJei7BlKT9gUuArUi+E+t6CbqXaZFxpwuzMiepF3ANcDjJl/HjwAURMTfTwIqEpLeB7wBjyKt5+vMpPk5YZtaqSXopIvbOOg5rmhOWWZmT1Bv4OjCIvNsAEXFmVjEVE0m/BCqBf5A8sRqAiBibWVBWL9/DMit/DwLPAk/izhb1qatdDc8rC5L5F62IuIZlVuYkjY+IYVnHYbax3K3drPw9JOmYrIMoVpK6SfqNpFfS168ldcs6LluXa1hmZU7SYqATyf2Zajy56xok3Qe8AdyaFn0J2DUiPtvwXpYFJywza9XqazJ1M2pxcpOgmbV2yyUdULeQDiRenmE81gDXsMysVZO0K3Ab0I2kuXQecEY656IVEScsMzNAUleAiFjU1LaWDScsszIlqUdj6yNi3qaKpZhJqgJOYt2B1ZdlFZPVzwOHzcrXGJIBsKpnXQCe3DXxILCQ5PNa2cS2liHXsMysVZP0RkQMzToOa5prWGatgKTNgCFA+7qyiHgmu4iKyvOSdo6I17MOxBrnGpZZmZP0NeACoD8wHtgHeCEiPFceIGkCsC0whaRJsG5g9S6ZBmbrcA3LrPxdAOwJvBgRh0raAbg045iKydFZB2CFccIyK38rImKFJCRVRcTbkrbPOqhiERHvZR2DFcYJy6z8vS+pO/AA8ISk+cCMTCMy2wC+h2XWikg6mGRGh0cjYlXW8ZitDycss1ZAUiWwBWsOjJ2WXURm689NgmZlTtK3gIuBj4DatDgA94KzkuIallmZkzQJ2Dsi5mYdi9nG8ONFzMrfdJKph8xKmpsEzcrfZGCUpIfJmysvIn6TXUhm688Jy6z8TUtf7dKXWUnyPSyzVkJSF5Iph5ZkHYvZhvA9LLMyJ2mopHHAG8CbksZI2inruMzWlxOWWfm7CfhuRGwVEVsBFwJ/yjgms/XmhGVW/jpFxMi6hYgYBXTKLhyzDeNOF2blb7KknwK3p8v/Q/IoDbOS4hqWWfk7E+gN/AO4P33/lUwjMtsA7iVoZmYlwU2CZmVK0u8i4tuS/kkyd+AaIuL4DMIy22BOWGblq+6e1dWZRmHWTJywzMpURIxJ3w6LiGvy10m6AHh600dltuHc6cKs/H25nrIzNnUQZhvLNSyzMiXpVOCLwNaSRuSt6gL4USNWcpywzMrX88BMoBfw67zyxcBrmURkthHcrd2szEkaDMyIiBXpcgdgi4iYmmlgZuvJ97DMyt89QG3ecg64N6NYzDaYE5ZZ+WsTEavqFtL3fi6WlRwnLLPyN1vS6kHCkk4A5mQYj9kG8T0sszInaRvgDqAvIGA6cHpETMo0MLP15IRl1kpI6kzyf35x1rGYbQgnLLMyJ6kKOAkYRN5Qloi4LKuYzDaEx2GZlb8HgYXAGGBlxrGYbTDXsMzKnKQ3ImJo1nGYbSz3EjQrf89L2jnrIMw2lmtYZmVO0gRgW2AKSZOggIiIXTINzGw9OWGZlTlJW9VXHhHvbepYzDaGO12YlT//VWplwTUsszIn6XWSpCWgPbA1MDEidso0MLP15BqWWZmLiDU6XEjaHTg7o3DMNph7CZq1MhExFtgz6zjM1pdrWGZlTtJ38xYrgN2B2RmFY7bBnLDMyl+XvPc1wMPAfRnFYrbBnLDMypSk2yPiS8CCiLgm63jMNpZ7CZqVqXTA8NHACOAQkl6Cq0XEvAzCMttgrmGZla8bgUeBwSQT3+YnrEjLzUqGa1hmZU7SDRFxbtZxmG0sJywzMysJHodlZmYlwQnLzMxKghOWWQuTlJM0XtIbku6V1HEjjnWLpM+l72+WtGMj2x4iab8NOMdUSb0KLV9rmyXrea5LJH1vfWO01skJy6zlLY+IYelTf1cB5+SvlFS5IQeNiK9FxIRGNjkEWO+EZVasnLDMNq1ngW3T2s9ISXcCr0uqlHSVpJclvSbpbAAlrpM0QdLDwOZ1B5I0StLw9P1RksZKelXSU5IGkSTG76S1uwMl9ZZ0X3qOlyXtn+7bU9LjksZJ+iNrjdeqj6QHJI2R9Kaks9Za9+s0lqck9U7LtpH0aLrPs5J2aJZP01oVj8My20QktSEZyPtoWrQXMDQipqRf+gsjYk9JVcB/JD0O7AZsD+wMbAFMAP6y1nF7A38CDkqP1SMi5km6EVgSEVen290J/DYinpM0EHgM+ARwMfBcRFwm6VhgjQTUgDPTc3QAXpZ0X0TMBToBYyPiQkk/S4/9TeAm4JyIeEfS3sD1wGEb8DFaK+aEZdbyOkgan75/FvgzSVPd6IiYkpYfAexSd38K6AYMAQ4C/h4ROWCGpH/Xc/x9gGfqjtXIDBaHAztKqytQXSV1Sc/x2XTfhyXNL+Cazpf0mfT9gDTWuUAtcHda/jfgH5I6p9d7b965qwo4h9kanLDMWt7yiBiWX5B+cS/NLwK+FRGPrbXdMTT9xGAVsA0ktwD2jYjl9cRS8IBMSYeQJL99I2KZpFEkD4asT6TnXbD2Z2C2vnwPy6w4PAacK6ktgKTtJHUCngFOSe9x9QEOrWffF4CDJW2d7tsjLV/MmjO1P07SPEe63bD07TPAaWnZ0cBmTcTaDZifJqsdSGp4dSqAulriF0maGhcBUySdnJ5DknZt4hxm63DCMisON5Pcnxor6Q3gjyQtIPcD7wCvAzcAT6+9Y0TMJrnv9A9Jr/Jxk9w/gc/UdboAzgeGp506JvBxb8VLgYMkjSVpmpzWRKyPAm0kvQb8HHgxb91SYCdJY0juUV2Wlp8GfDWN703ghAI+E7M1eGomMzMrCa5hmZlZSXDCMjOzkuCEZWZmJcEJy8zMSoITlpmZlQQnLDMzKwlOWGZmVhL+P8Qx7dInzU3lAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(logreg_pipe, X_test, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 63.68% of the funtional wells.\n",
      "The model correctly predicts 66.8% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 62.19% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(logreg_pipe, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  the model is not overfit, but probably underfit with an overall accuracy test score of 63.3%.  It predicts needs-repair wells at 66.8% and non-functional wells at 62.19% (for a combined 'score' of 128.99)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# logistic regression with grid search\n",
    "\n",
    "*  we'll try a small grid search around the hyperparameter 'C'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=3,\n",
       "             estimator=Pipeline(steps=[('trans',\n",
       "                                        ColumnTransformer(transformers=[('categorical',\n",
       "                                                                         Pipeline(steps=[('ohe',\n",
       "                                                                                          OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                                        sparse=False))]),\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",
       "                                                                        ('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",
       "                                       ('smote', SMOTE(random_state=42)),\n",
       "                                       ('logreg',\n",
       "                                        LogisticRegression(n_jobs=-1,\n",
       "                                                           random_state=42))]),\n",
       "             param_grid={'logreg__C': [0.01, 1, 100.0]})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logreg_pipe_grid = {'logreg__C': [1e-2, 1, 1e2]}\n",
    "gs_logreg_pipe = GridSearchCV(estimator=logreg_pipe, param_grid=logreg_pipe_grid, cv=3)\n",
    "gs_logreg_pipe.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'logreg__C': 1}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_logreg_pipe.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  gridsearch suggest keeping the default regularization. let's move on to other models to check their scores.  we suspect they will perform better than logistic regression, so we'll verify that and then decide whether to do further tuning on the logistic regression model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# knn (default parameters)\n",
    "\n",
    "*  we move on to k nearest neighbors with the default hyperparameters.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('trans',\n",
       "                 ColumnTransformer(transformers=[('categorical',\n",
       "                                                  Pipeline(steps=[('ohe',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                 sparse=False))]),\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",
       "                                                 ('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",
       "                ('smote', SMOTE(random_state=42)),\n",
       "                ('knn', KNeighborsClassifier(n_jobs=-1))])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn_pipe = imbPipeline([\n",
    "    ('trans', transformer),\n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('knn', KNeighborsClassifier(n_jobs=-1))\n",
    "])\n",
    "knn_pipe.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score Train: 0.8260880409028557\n",
      "Accuracy Score Test: 0.722484100261878\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy Score Train:', knn_pipe.score(X_train,y_train))\n",
    "print('Accuracy Score Test:', knn_pipe.score(X_test,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log loss: 3.7789466887696026\n"
     ]
    }
   ],
   "source": [
    "log_loss(knn_pipe, X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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(knn_pipe, X_test, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 73.05% of the funtional wells.\n",
      "The model correctly predicts 61.77% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 73.1% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(knn_pipe, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  much better accuracy scores for the baseline knn model versus the logistic regression.  the model is overfitting, but the test accuracy score improves.  the only dowside is that it's slightly worse at predicting 'functional-needs-repair' wells.  the model predicts 61.77% of the needs-repair wells and 73.1% of the non-functional wells (for a combined 'score' of 134.87, much improved over the logistic regression model.)\n",
    "\n",
    "*  let's try a grid search with knn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# knn with gridsearch \n",
    "\n",
    "*  we'll search around the default n_neighbors=5, and search for three values of p."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=3,\n",
       "             estimator=Pipeline(steps=[('trans',\n",
       "                                        ColumnTransformer(transformers=[('categorical',\n",
       "                                                                         Pipeline(steps=[('ohe',\n",
       "                                                                                          OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                                        sparse=False))]),\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",
       "                                                                        ('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",
       "                                       ('smote', SMOTE(random_state=42)),\n",
       "                                       ('knn',\n",
       "                                        KNeighborsClassifier(n_jobs=-1))]),\n",
       "             param_grid={'knn__n_neighbors': [3, 5, 7], 'knn__p': [1, 2, 3]})"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn_pipe_grid = {'knn__n_neighbors': [3, 5, 7], 'knn__p': [1, 2, 3]}\n",
    "gs_knn_pipe = GridSearchCV(estimator=knn_pipe, param_grid=knn_pipe_grid, cv=2)\n",
    "gs_knn_pipe.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'knn__n_neighbors': 3, 'knn__p': 1}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_knn_pipe.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score Train: 0.8800349170719541\n",
      "Accuracy Score Test: 0.7503928170594837\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy Score Train:', gs_knn_pipe.score(X_train,y_train))\n",
    "print('Accuracy Score Test:', gs_knn_pipe.score(X_test,y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  the grid search suggests using n_neighbors (3), and changing the p hyperparameter from the default (2) to 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# running knn again with new hyperparameters: n_neighbors=3, p=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('trans',\n",
       "                 ColumnTransformer(transformers=[('categorical',\n",
       "                                                  Pipeline(steps=[('ohe',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                 sparse=False))]),\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",
       "                                                 ('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",
       "                ('smote', SMOTE(random_state=42)),\n",
       "                ('knn', KNeighborsClassifier(n_jobs=-1, n_neighbors=3, p=1))])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn_pipe_after_gs = imbPipeline([\n",
    "    ('trans', transformer),\n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('knn', KNeighborsClassifier(n_neighbors=3, p=1, n_jobs=-1))\n",
    "])\n",
    "knn_pipe_after_gs.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score Train: 0.8800349170719541\n",
      "Accuracy Score Test: 0.7503928170594837\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy Score Train:', knn_pipe_after_gs.score(X_train,y_train))\n",
    "print('Accuracy Score Test:', knn_pipe_after_gs.score(X_test,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log loss: 4.639916739202775\n"
     ]
    }
   ],
   "source": [
    "log_loss(knn_pipe_after_gs, X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "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(knn_pipe_after_gs, X_test, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 78.31% of the funtional wells.\n",
      "The model correctly predicts 50.67% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 75.03% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(knn_pipe_after_gs, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  the tuning improves predictions of the functional and non-funtional wells, but does worse at predicting the 'functional-needs-repair' wells.  it predicts 50.67% of the needs-repair wells and 75.03% of the non-funtional wells (for a combined 'score' of 125.7, worse than the default, even though overall accuracy improves.)\n",
    "\n",
    "*  let's move on and try support vector machines."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# support vector machines "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('trans',\n",
       "                 ColumnTransformer(transformers=[('categorical',\n",
       "                                                  Pipeline(steps=[('ohe',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                 sparse=False))]),\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",
       "                                                 ('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",
       "                ('smote', SMOTE(random_state=42)), ('svm', SVC())])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svm_pipe = imbPipeline([\n",
    "    ('trans', transformer), \n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('svm', SVC())\n",
    "])\n",
    "svm_pipe.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score Train: 0.7343309639605936\n",
      "Accuracy Score Test: 0.7045267489711934\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy Score Train:', svm_pipe.score(X_train,y_train))\n",
    "print('Accuracy Score Test:', svm_pipe.score(X_test,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAFwCAYAAADkNE/4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAA9TUlEQVR4nO3dd7hU1bnH8e/vHHoHKdIUFGIjgorG3qKxJBFLiomJJjFXY0w0pmrKjTEx0VQ1thi7iTEYG2rsisariCAooCIEFBGU3tsp7/1j74MDnDLAOeyZOb/P88xzZq/d3j3KvLPWXnstRQRmZmaFrizrAMzMzPLhhGVmZkXBCcvMzIqCE5aZmRUFJywzMysKLbIOwIpb927lMaB/y6zDKFhT3+medQgFr2xNVdYhFLxla99fEBE9tnT/Y45oHwsX5fc5j39t7WMRceyWnqspOWHZVhnQvyVjH+ufdRgF67Czz8o6hILXfurCrEMoeI9Nvfydrdl/4aIqxj62Q17blveeVrC/spywzMxKXADVVGcdxlZzwjIzK3lBVThhmZlZgQugkuK/V+iEZWZW4oKgqgSG4XPCMjNrBqpxwjIzswIXQJUTlpmZFYNSqGF5pAszsxIXQEVEXq98SHpb0iRJEyWNS8u6SXpC0rT0b9ec7S+SNF3SVEnH5JTvkx5nuqSrJKm+8zphmZmVuCCoyvO1GY6IiGERMTxdvhB4KiIGA0+ly0jaHTgV2AM4FrhWUnm6z3XAWcDg9FXvCBtOWGZmpS6gKs/XVhgB3Ja+vw04Maf8rohYGxEzgenAfpJ6A50i4sVIZhK+PWefWjlhmZmVuGSki/xeQHdJ43JetY0vFsDjksbnrO8VEXMB0r890/K+wLs5+85Oy/qm7zcur5M7XZiZlTxRRb23h3ItyGnmq8tBETFHUk/gCUlv1nvyTUU95XVyDcvMrMQFUB35vfI6XsSc9O884D5gP+CDtJmP9O+8dPPZQO4I2f2AOWl5v1rK6+SEZWZW4gJYR1ler4ZIai+pY8174BPAZGAUcEa62RnAA+n7UcCpklpLGkjSuWJs2my4XNL+ae/A03P2qZWbBM3MmoHqyLtJsCG9gPvSHugtgDsj4lFJLwMjJZ0JzAI+CxARUySNBF4HKoFzI6JmYMNzgFuBtsAj6atOTlhmZiUuGemicRJWRMwAhtZSvhD4eB37XApcWkv5OGBIvud2wjIzK3GBqCqBO0BOWGZmzUAjNglmxgnLzKzENWaTYJacsMzMSlwgKqL4v+6L/wrMzKxBrmGZmVnBixBV4U4XZmZWBKpdwzIzs0KXdLpwDcvMzAqcO12YmVnRqPJzWGZmVug80oWZmRWNavcSNDOzQudOF2ZmVhQC+R6W2bZw+n6707ZDFWVlUN4iuPrRt/jrJX0Y80QnWrYKeu+4lu/96V06dK7i6Xu7cve1PdfvO/ONNlzz2Fv0HrCW7504eH35grktOfKUxZxzyXtZXFKj+tHpz3LAR2exeHlbvnrJZwD42gnjOHjoO1QHLFnelt/cehgLl7Zn+G6zOeukl2nZooqKynKuu2c/JkztC8DH953Ol46bSIRYsLQdl950BEtXtsny0ppE+w7rOP8Hr7DjwGVEiCsu35s3X9+OT5/0Xz590n+pqhIvj9mem//yUTp2WsuPf/ESH9l1MU8+uiPXXTks6/C3SATuJWgNk3QeySRlr0TEaY1wvAHAgRFxZ7o8HDg9Is7b2mNvdJ63geERsaAxj7ulfnv3dDpvV7V+ee9Dl/O1H8+hvAXc+Kve3PXnnnz9p3M58uTFHHnyYiBJVhd/dSA7D1kNwHVPTl2//7nHfISDj1+yTa+hqTzy4ke495k9+PFXR68vu+vxPbl51HAATjliMmd88hX+eOchLF3Rhouu+QQLl7ZnYJ9F/O68R/jMhadRXlbNtz/3Imdc/FmWrmzDN05+iZOOmMKtD+2T0VU1nbO/9Rrjx/bi1z/fnxYtqmndppI9h81n/4Pn8M0zP05lRTmdu6wBYN26cu64eXcGDFzGjgOXZRz51lBJPDhc/I2ahe+bwPGNkaxSA4Av1ixExLjGTlbFYJ/Dl1Oe/tzabZ9VLJjbcpNtnrm/K4efuHiT8vdmtGLJghYM+djKpg5zm3htWm+Wr2q9QdmqNa3Wv2/TuhLSL6tp73Zn4dL2AMyc05VWLato2SL5ISBBm9YVQNCuzToWLm23TeLfltq2q2DI0AU89vAAACory1i5ohWfHDGDu+/chcqKcgCWLklqlmvXtOD1Sd1Zt648q5AbRQBVUZbXq5C5htWEJF0P7ASMkrQD8MuI+H26bjLwqXTTR4DngQOB94AREbFa0iDgeqAHUEUy5fRlwG6SJgK3AROA70fEpyR1A25Oz7kKOCsiXpN0MbBDWr4DcEVEXJXGcT/QH2gDXBkRNzTdJ7KFFPz4CzuD4JNfXsjxX1q4werH/tGNw0Ys2WS350Z14eJbZm5S/sz9XTnshCWo+H9w1uvrI17mmP2nsWJ1K77zx09usv6wvWcy7d3tqKhMvoz/eOdB3PK/97BmXQtmz+vMFf84aFuH3OR691nJ0iWtueDC8ey081Kmv9WF6/88lD79V7DHRxdwxplTWLeunBuvG8K0qd2yDrdRlUKni+K/ggIWEd8A5gBHAH+qZ9PBwDURsQewBDglLf97Wj6UJJnNBS4E/hMRwyJi42P+ApgQEXsCPwZuz1m3K3AMsB/wc0k1VZKvRcQ+wHDgPEnbbdHFNqE/PTCNax5/i0v/PoNRt3Zn0pj269fdeWUvylvE+mbAGm++0o7WbasZsOuaTY737ANdOeKkTWtepebGB/blsxd9kSfHDuLkI17fYN2A3os4++Sx/OFvhwBQXlbNiMPe4Ou/OpmTf3ga/53djdOOm5hB1E2rvDwY9JEl/PuBnfj2/3ycNatb8LkvTqW8POjQsYILvnk4N10/hIsuHktSLykNgaiO/F6FzAmrMMyMiInp+/HAAEkdgb4RcR9ARKyJiFUNHOdg4I50+6eB7SR1Ttc9HBFr03tS84Beafl5kl4FxpDUtAbTAElnSRonadz8hVUNbb7Vttu+EoAu3Ss56NilvDkhaap6YmRXxj7ZiR9d/c4mtaXRD3SptTnwv1PaUFUFg/dc3eRxF4onx+7MoXt9WNPs0WUFvzrnCX59y+HMWdAJgMH9k1prsiyeGb8TQ3aal0W4TWrB/LYsmN+WqW8ktafnn+3LzoOXsGB+G174Tx9AvPVmN6JadOq8LttgG1kVZXm9CllhR1daKtnw887tfrU2530VSVPtlvzUqW2fmp+Jm5xD0uHAUcABaS1uwkZx1SoiboiI4RExvMd2Tdu2v2ZVGatWlK1/P/7ZjgzYdQ0vP9ORkdf04uJbZ9Cm3Ya/hKur4T8PdeHwWpoJR9/ftdbyUtO359L17w8a+g6z3u8CQIe2a7nsW49xw337Mfm/26/fZv6SdgzovZjOHZJEPny393gn3aeULF7Uhvnz2tK3/3IAhu0zj1nvdGLM830Yutd8APr2W06LltUsW9qqvkMVlWQswfK8XoXM97C2nbdJ71lJ2hsYWN/GEbFM0mxJJ0bE/ZJaA+XAcqBjHbs9B5wG/DJNRgvS49R1ms7A4ohYJWlXYP/Nu6Smt3h+C35xZvJRVVXCESctYd8jlvOVA3ejYq246PODANh1n5Wcf/lsACaN6UD33hX03nHTX8jPPdiFX94xY9tdwDbwv2c+zbBd5tC5wxruvuxObnlwb/Yf8i79ey0lQnywqAN/+PvBAJx0xBT69lzG6Z98hdM/+QoA37/yeBYubc+tD+3Nn7//EJVVZXywqAO/ufWwLC+ryVx/1VB++NOXadGimvfntudPl+3DmjUt+M6PxnPtLU9SWSH++Jt9qPn9d8tdj9KuXQUtWlZzwMFz+Mn3D+bddzplexGbKSiNkS4UUTrttIWopns4sBJ4AOgJvEzSfHdcutlDETEk3f77QIeIuFjSYOAvQHeggqTTxbvAo2nZrWza6eIWkmS4caeLFbV0+JgL3A/0BaaSdO64OCJG59utffjQNjH2sf5b8QmVtsPOPivrEApe+6kLG96omXts6uXjI2L4lu7fb0jnOHdkfp1ofrzHI1t1rqbkGlYTi4gBOYufqGOzITnb/z7n/TTgyFq2//hGy6PT7RcBI2qJ4eKNlofkLB5HLTaK28yKWIRKooblhGVm1gwU+jNW+XDCMjMrcTWdLoqdE5aZWYlLOl0U9jNW+XDCMjNrBgr9Gat8OGGZmZW4mpEuip0TlplZM1DtGpaZmRW6CDyBo5mZFb5AVFa7l6CZmRWBKk/gaGZmha6mW3tjTi8iqVzSBEkPpcvdJD0haVr6t2vOthdJmi5pqqRjcsr3kTQpXXeV6hn4FJywzMyagWRopnxem+F84I2c5QuBpyJiMPBUuoyk3YFTgT2AY4FrJdW0T14HnEUyrdHgdH2dnLDMzJqBapTXKx+S+gGfBG7MKR5BMgs66d8Tc8rvSufjmwlMB/aT1BvoFBEvRjIK++05+9TK97DMzEpcBFTk3+miu6RxOcs3RMQNG21zBfBDNpzqqFdEzE3OF3Ml9UzL+5JMEFtjdlpWkb7fuLxOTlhmZiVuMx8cXlDf9CKSPgXMi4jx6bx7DalrYtn6JpytlROWmVkzkG9zXx4OAk6QdDzJDOWdJP0N+EBS77R21RuYl24/G8idNK8fMCct71dLeZ18D8vMrMQ1Zi/BiLgoIvqlc+adCjwdEV8CRgFnpJudQTJhLWn5qZJaSxpI0rlibNp8uFzS/mnvwNNz9qmVa1hmZs3ANpjA8TJgpKQzgVkkM6QTEVMkjQReByqBcyOiKt3nHJKZ09sCj6SvOjlhmZmVus18xirvw0aM5sMZzxey6WzoNdtdClxaS/k4cmZcb4gTlplZiQug0jMOm5lZofMEjmZmVjScsMzMrOB5AkczMysajfgcVmacsMzMSl24SdDMzIpAAJXV7iVoZmYFzvewzMysaIQTlpmZFQN3ujAzs4IX7nRhZmbFQVS504WZmRUD38OyZu+tSe05duDHsg6jYLXfcWHWIRS8qrf+m3UIJc9jCZqZWXGI5D5WsXPCMjNrBtxL0MzMCl7ge1hmZlYURFW1E5aZmRUB17DMzKzgRThhmZlZkXC3djMzKwru1m5mZkXBTYJmZlbwPB+WmZkVB3e6MDOzouF7WGZmVgxKuoYl6c/Uk5Mj4rwmicjMzBpdqfcSHLfNojAzsyYTAVHKEzhGxG25y5LaR8TKpg/JzMwaWynUsBpMuZIOkPQ68Ea6PFTStU0emZmZNZ7I81XA8qkjXgEcAywEiIhXgUObMCYzM2tUIiK/VyHLq5dgRLwrbXAhVU0TjpmZNYkCrz3lI58a1ruSDgRCUitJ3ydtHjQzsyKQPjjcGDUsSW0kjZX0qqQpkn6RlneT9ISkaenfrjn7XCRpuqSpko7JKd9H0qR03VXaqGa0sXwS1jeAc4G+wHvAsHTZzMyKRSi/V8PWAkdGxFCSfHCspP2BC4GnImIw8FS6jKTdgVOBPYBjgWsllafHug44Cxicvo6t78QNNglGxALgtHyuwszMClQjNQlGRAAr0sWW6SuAEcDhafltwGjgR2n5XRGxFpgpaTqwn6S3gU4R8SKApNuBE4FH6jp3Pr0Ed5L0oKT5kuZJekDSTpt7kWZmlqH8ewl2lzQu53XWxoeSVC5pIjAPeCIiXgJ6RcRcgPRvz3TzvsC7ObvPTsv6pu83Lq9TPp0u7gSuAU5Kl08F/gF8LI99zcwsa0G+zX0ACyJieL2Hi6gChknqAtwnaUg9m9d24qinvE753MNSRNwREZXp628NHdTMzApLRH6vzTtmLCFp+jsW+EBSb4D077x0s9lA/5zd+gFz0vJ+tZTXqc6Elfb46AY8I+lCSQMk7Sjph8DDm3NRZmaWsUZ6cFhSj7RmhaS2wFHAm8Ao4Ix0szOAB9L3o4BTJbWWNJCkc8XYtNlwuaT9096Bp+fsU6v6mgTHs2G17eycdQH8suFLMzOzQqDqRnsouDdwW9rTrwwYGREPSXoRGCnpTGAW8FmAiJgiaSTwOlAJnJs2KQKcA9wKtCXpbFFnhwuofyzBgVt1SWZmVhgacdiliHgN2KuW8oXAx+vY51Lg0lrKxwH13f/aQF4jXaQ31HYH2uSc6PZ8T2JmZlnK+xmrgtZgwpL0c5K+9bsD/waOA54HnLDMzIpFCXSVy6eX4GdIqnnvR8RXgaFA6yaNyszMGlcJjNaeT5Pg6oiollQpqRNJV0U/OGyZ6N57LT/4wwy69qggqsW//9GDB27dng6dK/nx1dPp1XctH7zXml+fO4gVy5L/vQfuuorzLp1Juw7VVFfDeSP2oGJd8U9mV5f2HdZx/g9eYceBy4gQV1y+Nyd+Zjp9d0gGJ+jQoYIVK1ry7a9/nMOPmsUpp05bv+/AnZZy3llHMmN6l4yi3/ZOPHM+x522CCl45O/bcd+NPejYpZIfX/8Ovfqt44PZrbj07B1ZsTSvOyiFKYDG63SRmXz+C4xLuzD+laTn4ApgbEM7STqPpAfIKxHRKEM7SRoAHBgRd6bLw4HTI+K8xjh+znneBoanw1I1OUmjge+nNyAzIakPcFVEfCarGPJRXSn+eukOTJ/Snrbtq/jzg5OZ8Hxnjv7MfCb+XydGXt+Hz31jDp87Zy43X96fsvLgh3/6L7/97s7MfKMdHbtUUFVZ/P9w63P2t15j/Nhe/Prn+9OiRTWt21Ry2SUfPuf/9XNeY+XKlgCMfnIHRj+5AwADBi7lZ5e+2KyS1Y67rOa40xZx3icHU7FO/PrOGbz0VCeOO20hE57vwMire/G5b33A5781j5su7ZN1uFtFBV57ykeDPzMj4psRsSQirgeOBs5ImwYb8k3g+MZKVqkBwBdzYhvX2MmqmEhqtJ98ETGntmTVmOdoDIvmt2L6lPYArF5ZzrvT27Ld9us44OglPHlPdwCevKc7B35iMQD7HLKUmW+2Y+Yb7QBYvqQl1SXwS7MubdtVMGToAh57eAAAlZVlrFzRKmeL4JAj3uPZp/pvsu9hH3+31vJStsPgtbzxSjvWri6jukq89mIHDjpuKQccs4wnR3YD4MmR3Tjg2GUZR9oISqBJsL4Hh/fe+AV0A1qk7+sk6XqSZsNRki6QdHE6LUnN+snpg8gDJL0h6a/pMPWPpw+iIWmQpCfTIexfkbQzcBlwiKSJ6XEPl/RQun03SfdLek3SGEl7puUXS7pZ0mhJM9KaX00c90san557k/GyarmuFZIuTWMaI6lXWt5D0j2SXk5fB6Xl7dNzvyxpgqQRaXlbSXelsf6T5BmEmvG5bk0/n0mSLqglhlsl/VHSM8DlknaW9Gh6Hf+RtGvOdtenZW9J+lRaPiAteyV9HZhTPjl9/xVJd0t6EHi8oc8lK736rmXn3VcxdWIHunSvYNH85It50fxWdN6uAoC+A9cQAZfe9iZXPziZz5w9N8uQm1zvPitZuqQ1F1w4nj//9SnO/8F4WrepXL9+yJ4LWbK4NXPe67DJvoce8R7PPt1vk/JS9vabbfjox1bQsWslrdtWs++Ry+jRZx1du1ewaF5SC100ryVdtqts4Ei2LdT36/kP9awL4Mg6V0Z8Q9KxwBERsUDSxfUcazDwhYj4n/ThslOAvwF/By6LiPsktSFJrheSNJ3VfPkennOcXwATIuJESUeS9GIclq7bFTgC6AhMlXRdRFQAX4uIRWmSfFnSPemzBHVpD4yJiJ9I+i3wP8CvgCuBP0XE85J2AB4DdgN+AjwdEV9Lm1XHSnqS5CHsVRGxZ5pYX0mPPwzoGxFD0uvrUkccHwGOiogqSU8B34iIaZI+BlzLh/9tBgCHATuTjFgyiOQe5NERsUbSYJJxIWsbN+wAYM+IWLTxijS5nwXQhnb1fFxNp027Kn563TT+8ssdWLWivM7tylsEewxfznkj9mDt6jIu+/ubTJ/UjokvdN6G0W475eXBoI8s4fqrhjL1jW6c/a1X+dwXp3LHzXsASS1qdC21qF12W8TateW8M7M0P5e6vDu9DSOv7clv7prBmpVlzHy9bck2GZdCk2B9Dw4fsY1imBkRE9P344EBkjqSfHHfl8ayBkD1z+11MEmyIyKelrSdpJp/fQ+nQ9uvlTQP6EUyjtV5kmoG9e1PkjzrS1jrgIdyYj06fX8UsHtOfJ3Sa/gEcEJO7bINsANwKHBVGutrkl5L188AdpL0Z5Lhr+qq3dydJqsOwIHA3Tnnzu3BOTIiqoFpkmaQJO6ZwNWShpHMHP2ROs7xRG3JKo35BuAGgE5l223zfwblLar52XXTeOaB7fi/x5JmmyULWtKtxzoWzW9Ftx7rWLow+XW8YG4rJr3UiWWLk+WXR3dh0JBVJZuwFsxvy4L5bZn6RvK5PP9sXz77xakAlJVXc+Ahczjv7E3/aR965GxGP9W8alc1HvvHdjz2j+0A+OqFc5k/tyWLF7SkW8+kltWtZwVLFhZUy/iWKYHnsLZVV6nKjc7VJuf92pz3VSRJdEs+2fpG/t3kHGnt7CjggHQisgkbxVWbinQumNxYIbm2AyJiWPrqGxHL05hOySnfISJqZmve5Is+IhaTPDYwmmSSzBvriGNlznmX5Bx/WETsVsv15y5fAHyQnmc40IrarayjPGPBBZfPZNb0ttx7U+/1pWOe7MJRpyR9ZI46ZQEvPtEFgPHPdWbgrqto3aaKsvLgo/stZ9a0tlkEvk0sXtSG+fPa0rf/cgCG7TOPWe90AmCvfeYxe1ZHFs7fsFYsBYccPpvnnm5e969q1DQf9+i7joOOX8ro+7sw5vFOHPW55PfaUZ9bxIuPdcoyxK0XQHWerwK2rRLW28DekNwbA+od9ikilgGzJZ2Y7tNaUjtgOUmzXm2eI51oMk1GC9Lj1KUzsDgiVqX3ffbP81pq8zjwrZqFtPYCSdPgt5VWfyTVDGeSG+sQoOZ+W3egLCLuAX5G+pnVJb2+mZI+m+4vSUNzNvmspLL0/t9OwFSS656b1ry+DNTdnlaA9hi+gqNOXsiwA5dxzcOTuebhyex7+BL+eV1v9jp4GTc9/Sp7HbyMf16X9OhasawF9960PVc98DrXPjyZ6VPaMfaZLtleRBO7/qqh/PCnL3PNTU+y06CljPzbLkBSi6rtHtWQoQtYML8t789tv61DLQj/e+M73DD6TS65dSZX/7gvK5a24J9X92TvQ1Zw8/NvsPchKxh5dc+GD1TgFPm9Ctm2qufeA5yuZMKvl4G38tjny8BfJF0CVJAMpPgaUCnpVZIBEyfkbH8xcEvavLaKD0cNrsujwDfS7acCY/K9mFqcB1yTHqsFSUL6BskAwVcAr6VJ623gUyTTQtfEOpEPHxPom5bX/JC4KI9znwZcJ+mnJDN/3gW8mq6bCjxL0gT6jfS+1bXAPWmSe4aCrUnVbsq4jhw7cL9a1130pV1rLX/6/u48fX/3pgyroMyY3oXzz970FvOfLqt9iqNJE3vw3W9uqzsAhed7Jw3apGz54hZc+PmdM4imCRV4MsqHooEJUNIv2tOAnSLikrRTwfYR0eCzWJYdSbcCD0XEv5ryPJ3Ktov9Wx/XlKcoamU7Ns/7Qpuj6q3/Zh1CwXsy/jW+oUkV69O6f//od/4mnY5rNeMH39uqczWlfJoEryXpMfaFdHk5yQzEZmZWBPJtDiyFJsGPRcTekiZA0jFAUl036q1ARMRXso7BzApICTwwn0/CqlAyUVdA8pAsBd+XxMzMchV67Skf+TQJXgXcB/SUdCnJ1CK/btKozMyscZXA0EwN1rAi4u+SxpNMMSLgxJxniczMrNAVwf2pfOQzgeMOJN3EH8wti4hZTRmYmZk1ouaQsEiGCAqS2lUbkod+pwJ7NGFcZmbWmJpDwoqIj+YupyNVnN1kEZmZWaNrFk2CG4uIVyTt2xTBmJlZE2kOCUvSd3MWy0jGt5vfZBGZmVnjai6dLthwsNlKknta9zRNOGZm1iRKPWGlDwx3iIgfbKN4zMysKZRywpLUIiIq004WZmZWpETpNwmOJblfNVHSKOBucqaiiIh7mzg2MzNrDAEqgQH18rmH1Y1k2vgj+fB5rACcsMzMikWJ17B6pj0EJ/NhoqpRApduZtaMlMC3dn0JqxzowIaJqkYJXLqZWfNR6vew5kbEJdssEjMzazolnrCKf7YvMzNrFp0uPr7NojAzs6ZVAjWsOidwjIhF2zIQMzNrOor8Xg0eR+ov6RlJb0iaIun8tLybpCckTUv/ds3Z5yJJ0yVNlXRMTvk+kial666SVG/LXj4zDpuZWbFrvBmHK4HvRcRuwP7AuZJ2By4EnoqIwcBT6TLpulNJpqQ6Frg2HUUJ4DrgLGBw+jq2vhM7YZmZlbp8k1UeCSsi5kbEK+n75cAbQF9gBHBbutltwInp+xHAXRGxNiJmAtOB/ST1BjpFxIsREcDtOfvUarOnFzEzs+IiNqsXXXdJ43KWb4iIG2o9rjQA2At4CegVEXMhSWqSeqab9QXG5Ow2Oy2rSN9vXF4nJywzs2ZgM3oJLoiI4Q0eT+pAMnPHdyJiWT23n+p6lnezn/F1k6CZWXPQePewkNSSJFn9PWdc2Q/SZj7Sv/PS8tlA/5zd+wFz0vJ+tZTXyQnLzKw5aKSElfbkuwl4IyL+mLNqFHBG+v4M4IGc8lMltZY0kKRzxdi0+XC5pP3TY56es0+t3CRoZlbqGnfG4YOALwOTJE1My34MXAaMlHQmMAv4LEBETJE0EnidpIfhuRFRle53DnAr0BZ4JH3VyQnLzKw5aKSEFRHPU3cfjloHnIiIS4FLaykfBwzJ99xOWGZmzUCpD35r1rD2bagavnvWURSs8lkeMKYh80ftknUIhe/TW3+IUh9L0MzMSsFm9AAsZE5YZmbNgROWmZkVOuF7WGZmViycsMzMrOAFqLr4M5YTlplZM+AmQTMzKw5OWGZmVgxcwzIzs+LghGVmZgWvcQe/zYwTlplZiRMemsnMzIpFFH8VywnLzKwZcJOgmZkVPg9+a2ZmxcL3sMzMrDi4hmVmZgXPYwmamVmxcKcLMzMrDk5YZmZW6DyBo5mZFYcIPzhsZmbFwd3azcysKLhJ0MzMCl8A7tZuZmZFofjzlROWmVlz4CZBMzMrDu4laGZmBS/cS9DMzIpA8uCwa1hmZlYMSqCGVZZ1AGZm1vQUkderweNIN0uaJ2lyTlk3SU9Impb+7Zqz7iJJ0yVNlXRMTvk+kial666SpIbO7RqWFbzvnf08H9trNkuWteGsH54IQMf2a/nJ+aPZvvsK3l/QgV9deTgrVrYGYOAOi/jOmS/Srl0FUQ3n/vRTVFS04LD9Z/LFk16jrCx4aUI/brxzeHYX1YRu/tcTrF7VgupqUVUlvnPmYQwctJRzf/AabdtW8sHcdvzuF3uzelVLem6/iuvvfJr3ZnUA4M0pXbnmd0MzvoJGtq6aLhe9iyoCqoK1B3Vk1Re7r1/d9r5FdLhlPgv+tjPRKflKLJ+5ho7XfoBWVUMZLP7DjhDQ6fI5lM+tgDJYt18HVp7RI6ur2jyNO+PwrcDVwO05ZRcCT0XEZZIuTJd/JGl34FRgD6AP8KSkj0REFXAdcBYwBvg3cCzwSH0ndsJqYpJ+BxwP/DsiftBIxxwG9ImIf6fLJwC7R8RljXH8nPOsiIgOjXnMLfH4s4N44LHd+OE3/7O+7PMjJjFhcm/+OWpPPn/Ca5x6wiRu/MdwysqqufDc/3D5NYcwY1Y3OnZYQ1VlGR07rOGs08bxzR9/mqXL2/CDc/7DXnvMYcKUPhleWdO56NsHsmxp6/XL5134KjddvTuTJ3bn6E/O4pTT/svf/rorAHPfa8+3v3J4RpFuAy3Fkl/1h7ZlUBl0uXAW6/ZuT+WubSmbX0GriSup6pHzVVgVdPrjXJZ9tzdVA9ugZVVQLqgMVp/YjYo920FF0OVn79Jq/ArW7ZP5P5E8NN5YghHxnKQBGxWPAA5P398GjAZ+lJbfFRFrgZmSpgP7SXob6BQRLwJIuh04kQYSlpsEm97ZwN6NlaxSw0iSIAARMaqxk1UhmfTm9ixf0WqDsgP3mcUTzw0C4InnBnHg8FkADN9zDjNmdWXGrG4ALF/Rhuooo3fPFcye24mly9sAMGFSHw7+2Dvb8Cqy1W+HFUyeuB0AE17uwUGHzck4om1ISpIVQFVAZSS9EIAON81jxVd6rF8GaDVhJZUDWlM1MPl/JTqVJwmrdVmSrABaioqdW1O2oHIbXsjWUXXk9dpCvSJiLkD6t2da3hd4N2e72WlZ3/T9xuX1csICJA2Q9Iakv0qaIulxSW3TdcMkjZH0mqT7atpmJY2WdLmksZLeknRILccdBbQHXpL0eUm3SvpMzvoV6d/D0+P9S9Kbkv5e054raV9JL0h6NT1XZ+AS4POSJqbH/Yqkq9Ptd5T0VBrvU5J2SMtvTduJX5A0oyYOSR3S7V5J25NHNOVn3Vi6dl7NoiXJl8eiJe3o0mkNAH17L4WA31z4ONf+ehSf+/QkAOZ80JH+fZbSq/tyysqqOXD4LHp0W5lZ/E0pQvzyT2O48qZnOfaEtwF4Z0ZH9j/4fQAOPmIO3XutXr/99r1XcdUto7ns6v9jj6ELswi56VUFXc9/m+5fnk7FsPZU7tKWVi+toGq7FusTU43y99aBROefv0uX77xN23s2/Uy0oorWY1eybmi7bXUFWyft1p7PC+guaVzO66ytOHNt96WinvJ6uUnwQ4OBL0TE/0gaCZwC/I2knfbbEfGspEuAnwPfSfdpERH7STo+LT8q94ARcULarDYMQNJx9Zx/L5J23jnA/wEHSRoL/BP4fES8LKkTsAr4X2B4RHwrPe5Xco5zNXB7RNwm6WvAVSRVbYDewMHArsAo4F/AGuCkiFgmqTswRtKoiOLsA1teFuyxyzy+9dNPsXZtC377k8eYNmM7Jkzpw1U3H8BPzn+WqBavT+vJ9j2XZx1uk/jBOQezaEEbOndZy6+ueJF33+nIFb8extkXTOYLX32LMc9vT2VF8lt10cLWfOXko1m+rBWDdlnCT38zlnO+dASrV7XM+CoaWblYfOUAtKKKTr95j/KZa2h390KW/qLfpttWQ8vXV7P4jzsQrcvo8tN3qRzUhoqh7ZP1VUGn389l9ae6UL19q033L1T5/5NeEBGbe4P3A0m9I2KupN7AvLR8NtA/Z7t+JN9xs9P3G5fXywnrQzMjYmL6fjwwIK3NdImIZ9Py24C7c/a5N3f7rTz/2IiYDSBpYnq8pcDciHgZICKWpevrO84BwMnp+zuA3+asuz8iqoHXJfVKywT8WtKhJB1f+wK9gPfrOkH6i+ssgNatO+d9gY1p8dK2dOuyikVL2tGtyyqWLEt+JS9Y1I5Jb/RiWdr0N3ZiPwYNXMSEKX0Y80p/xryS/Ns5/sipVFU32CmpKC1akFz70iWtefG57dll98Xc+49B/OyCAwDo038F+x74AQCVFeUsrygHYPrULsx9rz19d1jJ9De7ZBJ7U4sO5VQMaUfrl1ZQ/kEFXc9/G4CyBZV0/c47LP7DjlRv14KKIW3Xd8BYt097Wvx37fqE1eHq96ns05LVI7pldRlbpml/go4CzgAuS/8+kFN+p6Q/knS6GEzyXVclabmk/YGXgNOBPzd0EjcJfmhtzvsq8kvmNfvku30l6WeeNvnl/jyr7fxi6/83y90/9xw139anAT2AfdKa4AfAhm0kGx8w4oaIGB4Rw1u1bL+V4W2ZF8f35+hDpwNw9KHTeWH8DgCMe60vA3dYTOtWlZSVVbPnbu/zzntJUu3SKWkG69B+LScc/SaPPD04k9ibUus2lbRtV7n+/d77zeedGZ3o3CX5Ty8Fp57xFo/cPwCATl3WUlaW/C+yfZ+V9Om/kvffK5JmrjxpaSVaUZUsrK2m1aurqNy5DQvvGMSiG3dm0Y07U929BYuv2JHo2oJ1e7en/O21sLYaqoKWU1ZT1T/5p9rub/MpW1XNyq/3rOeMhakRu7X/A3gR2EXSbElnkiSqoyVNA45Ol4mIKcBI4HXgUeDctIcgwDnAjcB04L800OECXMOqV0QslbRY0iER8R/gy8CzDe1Xj7eBfUj+A44AGmp3eRPoI2nftEmwI7AaWA50rGOfF0i6kd5Bkoyeb+AcnYF5EVEh6Qhgx3wuZFv68befZc/d3qdzxzXcefVIbv/XMO4a9VF+dv6zHHf4NOYt7MAvrzgcgBUrW3PPv/fg6ksfIiKpYY2dkNSqvnnGWHbaYREAf7t3KO+9n03tsCl17baWn/z6ZQDKWwTPPt6X8S/15ITPzuBTJ88E4IVne/PEw8lnMmTYQr709alUVYrqanHN7/ZkxfIiaubKQ9miSjpe8X7SoSBg7cEdWbdv3T37okM5q0d0pet33wElNax1+3agbEEF7UcuorJfK7pekHTYWf3JLqz5RJdtdCVbIUg6nDTGoSK+UMeqj9ex/aXApbWUjwOGbM65VaS3KhpV2kXzoYgYki5/H+gQERenXcivB9oBM4CvRsRiSaOB70fEuPTez7iIGFDLsdd3DU+b4R4gqWU9RXJvrIOkw9NjfSrd7ur0eLdK2pekqtyWJFkdRVIze4wk4f0mXTc8Ir6VXsvNQHdgfhrvLEm3ptf4r9y40tgfTI81ETgIOC4i3s6nW3unjn1j3+Hn5vlJNz+tZi3KOoSCN/fKeiv0Brz66UvHb8F9pfU6t+8T++9+dl7bPj7u4q06V1NywrKt4oRVPyeshjlhNaxREtZu+XX2e3z8Lwo2YblJ0MysOSiByokTlplZqQtKYvBbJywzs2bA04uYmVkRCKgu/iqWE5aZWakLfA/LzMyKRPFXsJywzMyaA9/DMjOz4uCEZWZmBS8Cqoq/TdAJy8ysOXANy8zMioITlpmZFbwAqp2wzMys4AWE72GZmVkxcJOgmZkVvMC9BM3MrEi4hmVmZoUvnLDMzKwIBB6t3czMioRrWGZmVhScsMzMrOBFEFVVWUex1ZywzMyaA490YWZmRcFNgmZmVvAi3EvQzMyKhGtYZmZW+NzpwszMioGnFzEzs6Lh6UXMzKzQBRCuYZmZWcELT+BoZmZFohRqWIoS6Opo2ZE0H3gn6zhydAcWZB1EgfNnVL9C/Hx2jIgeW7qzpEdJrisfCyLi2C09V1NywrKSImlcRAzPOo5C5s+ofv58CldZ1gGYmZnlwwnLzMyKghOWlZobsg6gCPgzqp8/nwLle1hmZlYUXMMyM7Oi4IRlZmZFwQnLzMyKghOWWQmTVC7pyazjMGsMHprJipakbvWtj4hF2yqWQhURVZJWSeocEUuzjqeQSFpOMi7sJquAiIhO2zgka4ATlhWz8SRfOKplXQA7bdtwCtYaYJKkJ4CVNYURcV52IWUvIjpmHYNtHicsK1oRMTDrGIrEw+nL6iGpJ9CmZjkiZmUYjtXCz2FZSZDUFRjMhl84z2UXkRULSScAfwD6APOAHYE3ImKPTAOzTbiGZUVP0teB84F+wERgf+BF4MgMw8qcpJER8TlJk6jlXk1E7JlBWIXolyT/zzwZEXtJOgL4QsYxWS2csKwUnA/sC4yJiCMk7Qr8IuOYCsH56d9PZRpF4auIiIWSyiSVRcQzki7POijblBOWlYI1EbFGEpJaR8SbknbJOqisRcTc9G8hzVdWiJZI6gA8B/xd0jygMuOYrBZ+DstKwWxJXYD7gSckPQDMyTSiAiJpf0kvS1ohaZ2kKknLso6rgIwAVgMXAI8C/wU+nWlEVit3urCSIukwoDPwaESsyzqeQiBpHHAqcDcwHDgdGBQRP8k0MLPN5BqWlYR0RIc+wEySjhfbZxtRYYmI6UB5RFRFxC3AEVnHVCgknSxpmqSlkpZJWu4aaGHyPSwrepK+Dfwc+ACoTosDcC+4xCpJrYCJkn4LzAXaZxxTIfkt8OmIeCPrQKx+bhK0oidpOvCxiFiYdSyFSNKOJMm8Fcl9ms7AtWmtq9mT9H8RcVDWcVjDnLCs6El6Bjg6Ityzqw5pDWtXkprnVN/f+5CkK0makO8H1taUR8S9WcVktXOToJWCGcBoSQ+z4RfOH7MLqXBI+iRwPUnvNwEDJZ0dEY9kG1nB6ASsAj6RUxaAE1aBcQ3Lip6kn9dWHhF+eBiQ9CbwqZomQEk7Aw9HxK7ZRma2eVzDsqJXk5gkdUwWY0XGIRWaeRvdr5pBMmaeAZL6AX8GDiKpWT0PnB8RszMNzDbhbu1W9CQNkTQBmAxMkTRekgcu/dAUSf+W9BVJZwAPAi+n3blPzjq4AnALMIpk8Nu+JJ/PLZlGZLVyk6AVPUkvAD+JiGfS5cOBX0fEgVnGVSgk1fflGxHxtW0WTAGSNDEihjVUZtlzk6CVgvY1yQogIkZL8nNGqYj4atYxFLgFkr4E/CNd/gLgRyQKkJsErRTMkPQzSQPS109JRrwwQNJHJD0laXK6vGf6GVnia8DngPdJHqr+TFpmBcZNglb00skbfwEcTNJt+zng4ohYnGlgBULSs8APgL9ExF5p2eSIGJJtZGabx02CVvTSxHRe1nEUsHYRMVZSblmzf8ha0g8j4reS/kztE1z6/6kC44RlRUvSFRHxHUkPUvsXzgkZhFWIFqTPXgWApM+QNH01dzVjB47LNArLmxOWFbM70r+/zzSKwncucAOwq6T3SO7vnZZtSNmLiAfTt6si4u7cdZI+m0FI1gDfw7KiJ+n8iLiyobLmSFI5cFlE/CDtOVkWEcuzjquQSHolIvZuqMyy54RlRa+OL5wJNR0MmjtJT0fEkVnHUWgkHQccT9JD8J85qzoBu0fEfpkEZnVyk6AVLUlfAL5IMpjrqJxVHfFzNLkmpJ/P3cDKmkKPRs4ckvtXJwDjc8qXk0zDYgXGNSwrWuk8TwOB3wAX5qxaDrzm6UYSdYx00exHuKghqROwMiKq0uVyoHVErMo2MtuYE5YVPUk7AXMiYk263BboFRFvZxqYFQVJY4CjagZNltQBeNxDexUej3RhpWAkUJ2zXEXS/GWWjza5I/yn79tlGI/VwQnLSkGL3Bl00/etMozHistKSes77UjaB1idYTxWB3e6sFIwX9IJETEKQNIIYEHGMVnx+A5wt6Q56XJv4PPZhWN18T0sK3rpKA5/J5nPSMC7wOkbTVrYbEk6n2R+p+XAjcBewIUR8XimgRUQSS2BXUj+/3kzIioyDslq4YRlJSO9WS4/GLshSa9GxFBJx5CMevEz4BY/GPshSQcCA8hpdYqI2zMLyGrlJkErepJaA6eQfuHUDPIaEZdkGFYhqRn19niSRPWqNhoJtzmTdAewMzCRpMMOJOMuOmEVGCcsKwUPAEtJHv5cm3EshWi8pMdJnlm7SFJHNuxV2dwNJxnZws1NBc4Jy0pBv4g4NusgCtiZwDBgRkSskrQd4FmIPzQZ2B6PYF/wnLCsFLwg6aMRMSnrQApJblft1E5uCaxVd+B1SWPJqaF7eprC404XVvQkvQ4MIpk2Yy3JPZuIiD0zDSxjkp5J37YB9gFeI/ls9gReioiDs4qtkEg6rLbyiHh2W8di9XPCsqKXjim4iYh4Z1vHUogk3QVcWlMDlTQE+H5EfCXTwMw2k5sErRT4V1f9ds1tLo2IyZKGZRhPQZG0nA//H2oFtCQZDLdTdlFZbZywrBQ8TPKFI5Lmr4HAVGCPLIMqIG9IuhH4G8nn9CU+nB6+2YuIjrnLkk4EPBdWAXKToJWctLPB2RFxdtaxFAJJbYBzgEPToueA62pGt7dNSRoTEftnHYdtyAnLSpKnON9QOuXKDhExNetYCo2kk3MWy0ieyzosIg7IKCSrg5sErehJ+m7OYhlJj7j5GYVTcCSdAPyO5P7MwPT+1SXutr3ep3PeVwJvAyOyCcXq4xqWFS1Jd0TElyUtAf6UFtd84dzjJq+EpPHAkcDoiNgrLXvN3f51eUT8SNLnImJk1vFYw1zDsmK2T9qlfRbw543WtQOcsBKVEbHUDw1v4nhJPwUuJJkE1AqcE5YVs+uBR0l6BY7LKRdJb7idsgiqAE2W9EWgXNJg4DzghYxjKgSPksyb1l7SspzymgfP3a29wLhJ0IqepOsi4pys4yhUktoBPwE+kRY9BvzKTaYJSQ9EhO9ZFQEnLLNmQlL7iFiZdRxmW6os6wDMrGlJOjAdb/GNdHmopGszDstsszlhmZW+PwHHAAsBIuJVPnyI2KxoOGGZNQMR8e5GRVW1bmhWwNxL0Kz0vSvpQCAktSLpJeixBFOSDgIuBnYk+U6s6SXoXqYFxp0uzEqcpO7AlcBRJF/GjwPnR8TCTAMrEJLeBC4AxpNT8/TnU3icsMysWZP0UkR8LOs4rGFOWGYlTlIP4H+AAeTcBoiIr2UVUyGRdBlQDtxLMmM1ABHxSmZBWa18D8us9D0A/Ad4Ene2qE1N7Wp4TlmQjL9oBcQ1LLMSJ2liRAzLOg6zreVu7Wal7yFJx2cdRKGS1FnSHyWNS19/kNQ567hsU65hmZU4ScuB9iT3Zyrw4K4bkHQPMBm4LS36MjA0Ik6uey/LghOWmTVrtTWZuhm1MLlJ0Myau9WSDq5ZSB8kXp1hPFYH17DMrFmTNBS4HehM0ly6CPhKOuaiFRAnLDMzQFIngIhY1tC2lg0nLLMSJalbfesjYtG2iqWQSWoNnMKmD1ZfklVMVjs/OGxWusaTPACrWtYF4MFdEw8AS0k+r7UNbGsZcg3LzJo1SZMjYkjWcVjDXMMyawYkdQUGA21qyiLiuewiKigvSPpoREzKOhCrn2tYZiVO0teB84F+wERgf+DFiPBYeYCk14FBwEySJsGaB6v3zDQw24RrWGal73xgX2BMRBwhaVfgFxnHVEiOyzoAy48TllnpWxMRayQhqXVEvClpl6yDKhQR8U7WMVh+nLDMSt9sSV2A+4EnJC0G5mQakdkW8D0ss2ZE0mEkIzo8GhHrso7HbHM4YZk1A5LKgV5s+GDsrOwiMtt8bhI0K3GSvg38HPgAqE6LA3AvOCsqrmGZlThJ04GPRcTCrGMx2xqeXsSs9L1LMvSQWVFzk6BZ6ZsBjJb0MDlj5UXEH7MLyWzzOWGZlb5Z6atV+jIrSr6HZdZMSOpIMuTQiqxjMdsSvodlVuIkDZE0AZgMTJE0XtIeWcdltrmcsMxK3w3AdyNix4jYEfge8NeMYzLbbE5YZqWvfUQ8U7MQEaOB9tmFY7Zl3OnCrPTNkPQz4I50+UskU2mYFRXXsMxK39eAHsC9wH3p+69mGpHZFnAvQTMzKwpuEjQrUZKuiIjvSHqQZOzADUTECRmEZbbFnLDMSlfNPavfZxqFWSNxwjIrURExPn07LCKuzF0n6Xzg2W0fldmWc6cLs9J3Ri1lX9nWQZhtLdewzEqUpC8AXwQGShqVs6oj4KlGrOg4YZmVrheAuUB34A855cuB1zKJyGwruFu7WYmTtBMwJyLWpMttgV4R8XamgZltJt/DMit9I4HqnOUq4O6MYjHbYk5YZqWvRUSsq1lI33teLCs6TlhmpW++pPUPCUsaASzIMB6zLeJ7WGYlTtLOwN+BPoCAd4HTI2J6poGZbSYnLLNmQlIHkn/zy7OOxWxLOGGZlThJrYFTgAHkPMoSEZdkFZPZlvBzWGal7wFgKTAeWJtxLGZbzDUssxInaXJEDMk6DrOt5V6CZqXvBUkfzToIs63lGpZZiZP0OjAImEnSJCggImLPTAMz20xOWGYlTtKOtZVHxDvbOhazreFOF2alz79KrSS4hmVW4iRNIklaAtoAA4GpEbFHpoGZbSbXsMxKXERs0OFC0t7A2RmFY7bF3EvQrJmJiFeAfbOOw2xzuYZlVuIkfTdnsQzYG5ifUThmW8wJy6z0dcx5Xwk8DNyTUSxmW8wJy6xESbojIr4MLImIK7OOx2xruZegWYlKHxg+DhgFHE7SS3C9iFiUQVhmW8w1LLPSdT3wKLATycC3uQkr0nKzouEallmJk3RdRJyTdRxmW8sJy8zMioKfwzIzs6LghGVmZkXBCcusiUmqkjRR0mRJd0tqtxXHulXSZ9L3N0ravZ5tD5d04Bac421J3fMt32ibFZt5roslfX9zY7TmyQnLrOmtjohh6ay/64Bv5K6UVL4lB42Ir0fE6/Vscjiw2QnLrFA5YZltW/8BBqW1n2ck3QlMklQu6XeSXpb0mqSzAZS4WtLrkh4GetYcSNJoScPT98dKekXSq5KekjSAJDFekNbuDpHUQ9I96TlelnRQuu92kh6XNEHSX9joea3aSLpf0nhJUySdtdG6P6SxPCWpR1q2s6RH033+I2nXRvk0rVnxc1hm24ikFiQP8j6aFu0HDImImemX/tKI2FdSa+D/JD0O7AXsAnwU6AW8Dty80XF7AH8FDk2P1S0iFkm6HlgREb9Pt7sT+FNEPC9pB+AxYDfg58DzEXGJpE8CGySgOnwtPUdb4GVJ90TEQqA98EpEfE/S/6bH/hZwA/CNiJgm6WPAtcCRW/AxWjPmhGXW9NpKmpi+/w9wE0lT3diImJmWfwLYs+b+FNAZGAwcCvwjIqqAOZKeruX4+wPP1RyrnhEsjgJ2l9ZXoDpJ6pie4+R034clLc7jms6TdFL6vn8a60KgGvhnWv434F5JHdLrvTvn3K3zOIfZBpywzJre6ogYlluQfnGvzC0Cvh0Rj2203fE0PGOw8tgGklsAB0TE6lpiyfuBTEmHkyS/AyJilaTRJBND1ibS8y7Z+DMw21y+h2VWGB4DzpHUEkDSRyS1B54DTk3vcfUGjqhl3xeBwyQNTPftlpYvZ8OR2h8naZ4j3W5Y+vY54LS07DigawOxdgYWp8lqV5IaXo0yoKaW+EWSpsZlwExJn03PIUlDGziH2SacsMwKw40k96dekTQZ+AtJC8h9wDRgEnAd8OzGO0bEfJL7TvdKepUPm+QeBE6q6XQBnAcMTzt1vM6HvRV/ARwq6RWSpslZDcT6KNBC0mvAL4ExOetWAntIGk9yj+qStPw04Mw0vinAiDw+E7MNeGgmMzMrCq5hmZlZUXDCMjOzouCEZWZmRcEJy8zMioITlpmZFQUnLDMzKwpOWGZmVhT+H4Vn+EhrXAKQAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(svm_pipe, X_test, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 72.63% of the funtional wells.\n",
      "The model correctly predicts 69.58% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 67.54% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(svm_pipe, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  svm has lower overall accuracy scores, though it does do a better job at predicting 'functional-needs_repair' wells. it predicts 69.58% of the needs-repair wells and 67.54% of the non-functional wells (for a combined 'score' of 137.12, the best so far.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# svm with gridsearch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 12 candidates, totalling 24 fits\n",
      "[CV] svm__C=0.001, svm__gamma=0.001 ..................................\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[CV] ...... svm__C=0.001, svm__gamma=0.001, score=0.582, total= 9.3min\n",
      "[CV] svm__C=0.001, svm__gamma=0.001 ..................................\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:  9.3min remaining:    0.0s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[CV] ...... svm__C=0.001, svm__gamma=0.001, score=0.585, total= 9.4min\n",
      "[CV] svm__C=0.001, svm__gamma=1 ......................................\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done   2 out of   2 | elapsed: 18.7min remaining:    0.0s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[CV] .......... svm__C=0.001, svm__gamma=1, score=0.555, total=78.4min\n",
      "[CV] svm__C=0.001, svm__gamma=1 ......................................\n",
      "[CV] ......... svm__C=0.001, svm__gamma=1, score=0.574, total=297.7min\n",
      "[CV] svm__C=0.001, svm__gamma=100 ....................................\n",
      "[CV] ....... svm__C=0.001, svm__gamma=100, score=0.548, total=366.3min\n",
      "[CV] svm__C=0.001, svm__gamma=100 ....................................\n",
      "[CV] ........ svm__C=0.001, svm__gamma=100, score=0.551, total= 7.4min\n",
      "[CV] svm__C=1, svm__gamma=0.001 ......................................\n",
      "[CV] .......... svm__C=1, svm__gamma=0.001, score=0.621, total= 6.5min\n",
      "[CV] svm__C=1, svm__gamma=0.001 ......................................\n",
      "[CV] .......... svm__C=1, svm__gamma=0.001, score=0.620, total= 6.3min\n",
      "[CV] svm__C=1, svm__gamma=1 ..........................................\n",
      "[CV] .............. svm__C=1, svm__gamma=1, score=0.717, total=13.6min\n",
      "[CV] svm__C=1, svm__gamma=1 ..........................................\n",
      "[CV] .............. svm__C=1, svm__gamma=1, score=0.721, total=12.6min\n",
      "[CV] svm__C=1, svm__gamma=100 ........................................\n",
      "[CV] ............ svm__C=1, svm__gamma=100, score=0.633, total=25.9min\n",
      "[CV] svm__C=1, svm__gamma=100 ........................................\n",
      "[CV] ............ svm__C=1, svm__gamma=100, score=0.637, total=16.4min\n",
      "[CV] svm__C=100, svm__gamma=0.001 ....................................\n",
      "[CV] ........ svm__C=100, svm__gamma=0.001, score=0.645, total= 6.6min\n",
      "[CV] svm__C=100, svm__gamma=0.001 ....................................\n",
      "[CV] ........ svm__C=100, svm__gamma=0.001, score=0.659, total= 6.8min\n",
      "[CV] svm__C=100, svm__gamma=1 ........................................\n",
      "[CV] ............ svm__C=100, svm__gamma=1, score=0.722, total=17.6min\n",
      "[CV] svm__C=100, svm__gamma=1 ........................................\n",
      "[CV] ............ svm__C=100, svm__gamma=1, score=0.720, total=19.4min\n",
      "[CV] svm__C=100, svm__gamma=100 ......................................\n",
      "[CV] .......... svm__C=100, svm__gamma=100, score=0.638, total=23.7min\n",
      "[CV] svm__C=100, svm__gamma=100 ......................................\n",
      "[CV] .......... svm__C=100, svm__gamma=100, score=0.642, total=23.3min\n",
      "[CV] svm__C=1000, svm__gamma=0.001 ...................................\n",
      "[CV] ....... svm__C=1000, svm__gamma=0.001, score=0.684, total= 7.7min\n",
      "[CV] svm__C=1000, svm__gamma=0.001 ...................................\n",
      "[CV] ....... svm__C=1000, svm__gamma=0.001, score=0.699, total= 8.1min\n",
      "[CV] svm__C=1000, svm__gamma=1 .......................................\n",
      "[CV] ........... svm__C=1000, svm__gamma=1, score=0.714, total=17.8min\n",
      "[CV] svm__C=1000, svm__gamma=1 .......................................\n",
      "[CV] ........... svm__C=1000, svm__gamma=1, score=0.715, total=21.7min\n",
      "[CV] svm__C=1000, svm__gamma=100 .....................................\n",
      "[CV] ......... svm__C=1000, svm__gamma=100, score=0.652, total=22.4min\n",
      "[CV] svm__C=1000, svm__gamma=100 .....................................\n",
      "[CV] ......... svm__C=1000, svm__gamma=100, score=0.657, total=21.1min\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done  24 out of  24 | elapsed: 1046.2min finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=2,\n",
       "             estimator=Pipeline(steps=[('trans',\n",
       "                                        ColumnTransformer(transformers=[('categorical',\n",
       "                                                                         Pipeline(steps=[('ohe',\n",
       "                                                                                          OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                                        sparse=False))]),\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",
       "                                                                        ('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",
       "                                       ('smote', SMOTE(random_state=42)),\n",
       "                                       ('svm', SVC())]),\n",
       "             param_grid={'svm__C': [0.001, 1, 100, 1000],\n",
       "                         'svm__gamma': [0.001, 1, 100]},\n",
       "             verbose=3)"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svm_pipe_grid = {'svm__C': [.001, 1, 100, 1000], 'svm__gamma': [0.001, 1, 100]}\n",
    "gs_svm_pipe = GridSearchCV(estimator=svm_pipe, param_grid=svm_pipe_grid, verbose=3, cv=2)\n",
    "gs_svm_pipe.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'svm__C': 100, 'svm__gamma': 1}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_svm_pipe.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "gridsearch suggests C=100 and gamma=1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score Train: 0.8884898366379848\n",
      "Accuracy Score Test: 0.7414141414141414\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy Score Train:', gs_svm_pipe.score(X_train,y_train))\n",
    "print('Accuracy Score Test:', gs_svm_pipe.score(X_test,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "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(gs_svm_pipe, X_test, y_test, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 80.15% of the funtional wells.\n",
      "The model correctly predicts 48.82% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 70.43% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(gs_svm_pipe, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  while the overall accuracy improves on the tuned model, the predictions for needs-repair drops considerably.  this model predicts needs-repair wells 48.82% of the time, and non-functional wells 70.43% of the time (for a combined score of 119.2, considerable worse than the default svc model).  "
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}