vanilla_model_cleaned.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vanilla Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook will run our baseline models to understand better our dataset and how the features and target variables behave when running different models. Our focus is to find baseline models that can improve the Precision without affecting Recall. To evaluate the models, we will use the metrics Precision, Accuracy, Recall, F1 Score, and Confusion Matrix."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read In Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Packages\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Sklearn Packages\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import mean_squared_error, precision_score, confusion_matrix, accuracy_score\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn import set_config\n",
    "set_config(print_changed_only=False)\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.utils.testing import ignore_warnings\n",
    "from sklearn.exceptions import ConvergenceWarning\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n",
    "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n",
    "warnings.filterwarnings(\"ignore\", category=ConvergenceWarning)\n",
    "\n",
    "pd.set_option('display.max_columns', 300)\n",
    "% matplotlib inline\n",
    "\n",
    "plt.style.use('seaborn')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \n",
    "df = pd.read_csv('../Phase_3_Project/data.csv/fetal_health.csv')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Cleaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.fetal_health = np.where(df.fetal_health > 1.0, 2.0, df.fetal_health)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train Test Split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Objectives: </b>\n",
    "\n",
    "- Assign our feature variables and target variable into the X and y variables. \n",
    "- Split our dataset using Sklearn Train Test Split. We will use the Sklearn default option and assign 75% to our train set and 25% to our test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assigning features variables (X) and target variable (y)\n",
    "X = df.drop('fetal_health', axis=1)\n",
    "y = df.fetal_health\n",
    "\n",
    "# Train test split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.75\n",
      "0.25\n"
     ]
    }
   ],
   "source": [
    "# Checking if train test split ran correclty\n",
    "for dataset in [y_train, y_test]:\n",
    "    print(round(len(dataset)/len(y), 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our train and test set were split correctly. 75% of the dataset was assigned to our train set, and 25% was assigned to our test set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Baseline Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To better understand our dataset and how our features variables affect our target variable, we decided to run baseline models and find what approach we should take when tuning our models. None of the baseline models will have any kinds of hyperparameters tuning. We will use the default hyperparameters.\n",
    "\n",
    "<b>Objectives:</b>\n",
    "- Run a Logistic Regression, KNN, Decision Tree, and Random Forest model.\n",
    "- Create a function to simplify our model evaluation.\n",
    "- Evaluate each model using the Accuracy, Recall, F1 Score, and Precision metrics.\n",
    "- Create confusion matrices for each model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluation function\n",
    "\n",
    "def evaluation(y_true, y_pred):\n",
    "    \n",
    "# Print Accuracy, Recall, F1 Score, and Precision metrics.\n",
    "    print('Evaluation Metrics:')\n",
    "    print('Accuracy: ' + str(metrics.accuracy_score(y_test, y_pred)))\n",
    "    print('Recall: ' + str(metrics.recall_score(y_test, y_pred)))\n",
    "    print('F1 Score: ' + str(metrics.f1_score(y_test, y_pred)))\n",
    "    print('Precision: ' + str(metrics.precision_score(y_test, y_pred)))\n",
    "    \n",
    "# Print Confusion Matrix\n",
    "    print('\\nConfusion Matrix:')\n",
    "    print(' TN,  FP, FN, TP')\n",
    "    print(confusion_matrix(y_true, y_pred).ravel())\n",
    "    \n",
    "# Function Prints best parameters for GridSearchCV\n",
    "def print_results(results):\n",
    "    print('Best Parameters: {}\\n'.format(results.best_params_))    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistic Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When trying to classify structured data, logistic regression models usually give a quick and reliable result. Thus, it will be our first baseline model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.8834586466165414\n",
      "Recall: 0.9535452322738386\n",
      "F1 Score: 0.9263657957244655\n",
      "Precision: 0.9006928406466512\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[390  19  43  80]\n"
     ]
    }
   ],
   "source": [
    "# Baseline Logistic Regression Model\n",
    "\n",
    "lr_baseline = LogisticRegression()\n",
    "\n",
    "# Fitting and predicting\n",
    "lr_baseline.fit(X_train, y_train)\n",
    "y_pred_lr_baseline = lr_baseline.predict(X_test)\n",
    "\n",
    "# Evaluation Metrics\n",
    "evaluation(y_test, y_pred_lr_baseline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Findings:</b>\n",
    "\n",
    "As we can see, our baseline Logistic Regression model performed reasonably well, even without tuning. Our feature variables can train the model with fairly precision.\n",
    "\n",
    "We will now test the same features and target variables using K-nearest neighbors, which classifies data points based on similarity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### KNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will run a K-Nearest Neighbors model. KNN is a simples model that stores and classifies all data points based on similarity measures (i.e., distance functions). Since it's an easy model to set up, we will run it and read the results to understand what the data tells us. We will have to scale our dataset for KNN before running it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call and fit scaler \n",
    "scaler = StandardScaler()\n",
    "scaler.fit(X_train)\n",
    "\n",
    "# Scaling our dataset\n",
    "X_train_scaled = scaler.transform(X_train)\n",
    "X_test_scaled = scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.9398496240601504\n",
      "Recall: 0.9877750611246944\n",
      "F1 Score: 0.961904761904762\n",
      "Precision: 0.9373549883990719\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[404   5  27  96]\n"
     ]
    }
   ],
   "source": [
    "# Baseline KNN Model\n",
    "knn_baseline = KNeighborsClassifier()\n",
    "\n",
    "# Fitting and predicting\n",
    "knn_baseline.fit(X_train_scaled, y_train)\n",
    "y_pred_knn_baseline = knn_baseline.predict(X_test_scaled)\n",
    "\n",
    "# Evaluation metrics\n",
    "evaluation(y_test, y_pred_knn_baseline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Findings:</b>\n",
    "\n",
    "Our baseline KNN model performed better than our baseline Logistic Regression model in all the metrics that we are analyzing the model. Interestingly, the Recall metric had a performance of .99. This is very high. It means that our baseline model is capable of predicting true positives with high precision. For now, we will keep running baseline models to find what the dataset has to tell us."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decision Tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of our project's key questions is to find what metrics can predict which features have the highest coefficient in our model predictions. For this reason, we will run Decision Tree as well, since it has a better division of features to predict an outcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.9266917293233082\n",
      "Recall: 0.9388753056234719\n",
      "F1 Score: 0.9516728624535316\n",
      "Precision: 0.964824120603015\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[384  25  14 109]\n"
     ]
    }
   ],
   "source": [
    "# Baseline Decision Tree Model\n",
    "dt_baseline = DecisionTreeClassifier()\n",
    "\n",
    "# Fitting and predicting\n",
    "dt_baseline = dt_baseline.fit(X_train, y_train)\n",
    "y_pred_dt_baseline = dt_baseline.predict(X_test)\n",
    "\n",
    "# Evaluation metrics\n",
    "evaluation(y_test, y_pred_dt_baseline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Findings:</b>\n",
    "\n",
    "Decision Tree did not perform better than KNN for most of the metrics that we are using. However, it performed better for the precision metric, which is the metric that we are most concerned about. Thus, we will run a Random Forest model, which works as a collection of decision trees."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Forest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After running a Decision Tree model, it makes sense to run a Random Forest model, an ensemble model that operates by constructing a multitude of decision trees at training time and outputting the class that is the average prediction for the individual trees."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.9492481203007519\n",
      "Recall: 0.9877750611246944\n",
      "F1 Score: 0.9676646706586827\n",
      "Precision: 0.9483568075117371\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[404   5  22 101]\n"
     ]
    }
   ],
   "source": [
    "# Baseline Random Forest Model\n",
    "rfc_baseline = RandomForestClassifier()\n",
    "\n",
    "# Fitting and predicting\n",
    "rfc_baseline.fit(X_train, y_train)\n",
    "y_pred_rfr_baseline = rfc_baseline.predict(X_test)\n",
    "\n",
    "# Evaluation metrics\n",
    "evaluation(y_test, y_pred_rfr_baseline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Findings:</b>\n",
    "\n",
    "Our baseline random forest model had an exciting performance. It outperformed the Decision Tree baseline model in almost every metric, except Precision, which slightly decreased. Compared to KNN, our best performing model so far, if we compare every metric, performs better for the metrics Accuracy, F1 Score, and Precision. It performed the same for the Recall metric."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Baseline Models Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accuracy, Recall, and F1 Score. Decision Tree had the best performance for the Precision metric. All of our models performed reasonably well. However, we have space for improvement in all of them. We will start improving some hyperparameters and check how they performed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a class imbalance problem in our dataset. Thus, we will use Synthetic Minority Oversampling Technique (SMOTE), where the minority class is oversampled by producing synthetic examples to fix the class imbalance. We will then compare the results to our baseline models to check if the target variable is even."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0    0.781681\n",
      "2.0    0.218319\n",
      "Name: fetal_health, dtype: float64\n",
      "2.0    0.5\n",
      "1.0    0.5\n",
      "Name: fetal_health, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# SMOTE\n",
    "smote = SMOTE()\n",
    "X_train_smote, y_train_smote = smote.fit_sample(X_train, y_train)\n",
    "\n",
    "# Checking if SMOTE was correctly fitted\n",
    "for dataset in (y_train, y_train_smote):\n",
    "    print (dataset.value_counts(normalize=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vanilla Models Tuning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now start improving our model using hyperparameters tuning without any feature engineering. We will tune all the baseline models changing some hyperparameters. Then, we will use GridSearchCV and XGBoost to find the best hyperparameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistic Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will start with the first baseline model that we ran: Logistic Regression using SMOTE. We want to see if SMOTE can help our model best predict our target variable. We will not tune any hyperparameter for the first model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.8364661654135338\n",
      "Recall: 0.8386308068459658\n",
      "F1 Score: 0.88745148771022\n",
      "Precision: 0.9423076923076923\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[343  66  21 102]\n"
     ]
    }
   ],
   "source": [
    "# Logistic Regression Model\n",
    "lr = LogisticRegression()\n",
    "\n",
    "# Fitting and predicting\n",
    "lr.fit(X_train_smote, y_train_smote)\n",
    "y_pred_lr_smote = lr.predict(X_test)\n",
    "\n",
    "# Evaluation Metrics\n",
    "evaluation(y_test, y_pred_lr_smote)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compared to our model using SMOTE underperformed in almost every metric using SMOTE. However, the Precision metric did perform better. It's the primary metric that we are interested in. We can see that there the number of False Negatives was reduced.\n",
    "\n",
    "Next, we will add a few hyperparameters individually and see if we can improve our model. Here, our approach will be trying random hyperparameters and check the results compared to the model without any parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.8383458646616542\n",
      "Recall: 0.8410757946210269\n",
      "F1 Score: 0.8888888888888888\n",
      "Precision: 0.9424657534246575\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[344  65  21 102]\n"
     ]
    }
   ],
   "source": [
    "# Logistic Regression Model\n",
    "lr = LogisticRegression(C=100, max_iter=200, class_weight='balanced')\n",
    "\n",
    "# Fitting and predicting\n",
    "lr.fit(X_train_smote, y_train_smote)\n",
    "y_pred_lr_tuned = lr.predict(X_test)\n",
    "\n",
    "# Evaluation Metrics\n",
    "evaluation(y_test, y_pred_lr_tuned)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`C=100` improved the Precision metric. All the other metrics remained the same.\n",
    "\n",
    "`fit_intercept=False` reduced all the metrics.\n",
    "\n",
    "`max_inter=200` improved the Precision metric compared to the default `max_inter=100`\n",
    "\n",
    "`class_weight='balanced'` improved all the metrics.\n",
    "\n",
    "<b>Findings:</b>\n",
    "\n",
    "Compared to our baseline model, the Logistic Regression model did not perform better. We were able to improve the model slightly using some random tuning. However, we don't think that Logistic Regression has the power that we need. Thus, we will use some more advanced algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### KNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following our order of baseline models, we will know use KNN models. We will first compare the result of our baseline model to a model after applying SMOTE. Then, we will use GridSearchCV to find the best hyperparameter tuning. For this model, we will scale the train set using SMOTE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.793233082706767\n",
      "Recall: 0.9975550122249389\n",
      "F1 Score: 0.8812095032397408\n",
      "Precision: 0.7891682785299806\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[408   1 109  14]\n"
     ]
    }
   ],
   "source": [
    "# KNN model using SMOTE\n",
    "knn = KNeighborsClassifier()\n",
    "\n",
    "# Fitting and predicting\n",
    "knn.fit(X_train_smote, y_train_smote)\n",
    "y_pred_knn_smote = knn.predict(X_test_scaled)\n",
    "\n",
    "# Evaluation metrics\n",
    "evaluation(y_test, y_pred_knn_smote)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our KNN model performed better than our baseline model in almost every metric, except Recall that had a small drop. We will now run a GridSearchCV to find the most relevant hyperparameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid_params_knn = {\n",
    "    'n_neighbors':list(range(1,10)),\n",
    "    'weights':['uniform','distance'],\n",
    "    'metric':['eucliean','manhattan','minkowski'],\n",
    "    'leaf_size':list(range(1,101))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 5400 candidates, totalling 27000 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  34 tasks      | elapsed:    2.1s\n",
      "[Parallel(n_jobs=-1)]: Done 976 tasks      | elapsed:    7.0s\n",
      "[Parallel(n_jobs=-1)]: Done 2976 tasks      | elapsed:   16.7s\n",
      "[Parallel(n_jobs=-1)]: Done 5776 tasks      | elapsed:   29.1s\n",
      "[Parallel(n_jobs=-1)]: Done 9376 tasks      | elapsed:   46.8s\n",
      "[Parallel(n_jobs=-1)]: Done 13776 tasks      | elapsed:  1.1min\n",
      "[Parallel(n_jobs=-1)]: Done 18976 tasks      | elapsed:  1.5min\n",
      "[Parallel(n_jobs=-1)]: Done 24976 tasks      | elapsed:  2.0min\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.768796992481203\n",
      "Recall: 1.0\n",
      "F1 Score: 0.869287991498406\n",
      "Precision: 0.768796992481203\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[409   0 123   0]\n",
      "Best Parameters: {'leaf_size': 8, 'metric': 'manhattan', 'n_neighbors': 1, 'weights': 'uniform'}\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done 27000 out of 27000 | elapsed:  2.2min finished\n"
     ]
    }
   ],
   "source": [
    "# Using GridSearchCV for a KNN model\n",
    "gs_knn = GridSearchCV(knn,grid_params_knn,verbose=1,n_jobs=-1)\n",
    "\n",
    "# Fitting and predicting\n",
    "gs_knn.fit(X_train_smote, y_train_smote)\n",
    "y_pred_gs_knn = gs_knn.predict(X_test_scaled)\n",
    "\n",
    "# Evaluation metrics\n",
    "evaluation(y_test, y_pred_gs_knn)\n",
    "print_results(gs_knn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "KNN using GridSearchCV did not perform better than our baseline model using only SMOTE. The Recall metric increased to 1.0, which might be a sign of overfitting. The model is not capable of identify False Positives or True Positives."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decision Tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following our order of models, we will now try a Decision Tree model. On the baseline model, Decision Tree did not perform better in most of the metrics. However, it did perform better with the Precision metric, the focus of our project. We will run a model using only SMOTE and see the performance. We believe that Random Forest, since it's an ensemble model, will perform better than KNN. However, we want to know how the model performs without the imbalance classification problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.9285714285714286\n",
      "Recall: 0.9584352078239609\n",
      "F1 Score: 0.9537712895377128\n",
      "Precision: 0.9491525423728814\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[392  17  21 102]\n"
     ]
    }
   ],
   "source": [
    "# Decision Tree Model\n",
    "tree = DecisionTreeClassifier()\n",
    "\n",
    "# Fitting and predicting\n",
    "tree.fit(X_train_smote, y_train_smote)\n",
    "y_pred_tree = tree.predict(X_test)\n",
    "\n",
    "# Evaluation metrics\n",
    "evaluation(y_test, y_pred_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Findings:</b>\n",
    "\n",
    "Our Decision Tree model had a good performance. So far, it was our best performing model for precision metric. We expect to improve this result using Random Forest models.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Forest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Random Forest was our best performing baseline model. We will see if we can improve even more the results using hyperparameter tuning. However, let's first see how the model performs using only SMOTE first. Then we will use GridSearchCV to find the best hyperparameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.9586466165413534\n",
      "Recall: 0.9877750611246944\n",
      "F1 Score: 0.9734939759036144\n",
      "Precision: 0.9596199524940617\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[404   5  17 106]\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Model\n",
    "rfc = RandomForestClassifier()\n",
    "\n",
    "# Fitting and predicting\n",
    "rfc.fit(X_train_smote, y_train_smote)\n",
    "y_preds_rfr = rfc.predict(X_test)\n",
    "\n",
    "# Evaluation Metrics\n",
    "evaluation(y_test, y_preds_rfr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Findings: </b>\n",
    "\n",
    "Compared to our baseline model, we can see improvements already in all the metrics. We can also see that our model reduced the number of False Positives, which is our focus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Forest with Grid Search"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it's time to find the best hyperparameters for Random Forest, the model that interests us the most for now. First, we will set up a dictionary of hyperparameters that we want to try and then run a GridSearchCV to find the best fit for our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GridSearch Parameters\n",
    "parameters = {\n",
    "    'n_estimators': [5, 50, 100, 150, 200],\n",
    "    'max_depth': list(range(1, 11)),\n",
    "    'criterion':['gini','entropy'],\n",
    "    'max_features': list(range(20)),\n",
    "    'oob_score':[False,True],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 4000 candidates, totalling 20000 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  56 tasks      | elapsed:    0.9s\n",
      "[Parallel(n_jobs=-1)]: Done 296 tasks      | elapsed:   12.6s\n",
      "[Parallel(n_jobs=-1)]: Done 546 tasks      | elapsed:   27.1s\n",
      "[Parallel(n_jobs=-1)]: Done 896 tasks      | elapsed:   48.9s\n",
      "[Parallel(n_jobs=-1)]: Done 1346 tasks      | elapsed:  1.3min\n",
      "[Parallel(n_jobs=-1)]: Done 1896 tasks      | elapsed:  2.0min\n",
      "[Parallel(n_jobs=-1)]: Done 2546 tasks      | elapsed:  2.7min\n",
      "[Parallel(n_jobs=-1)]: Done 3296 tasks      | elapsed:  3.8min\n",
      "[Parallel(n_jobs=-1)]: Done 4146 tasks      | elapsed:  5.1min\n",
      "[Parallel(n_jobs=-1)]: Done 5096 tasks      | elapsed:  6.7min\n",
      "[Parallel(n_jobs=-1)]: Done 6146 tasks      | elapsed:  8.6min\n",
      "[Parallel(n_jobs=-1)]: Done 7296 tasks      | elapsed: 10.7min\n",
      "[Parallel(n_jobs=-1)]: Done 8546 tasks      | elapsed: 13.1min\n",
      "[Parallel(n_jobs=-1)]: Done 9896 tasks      | elapsed: 16.1min\n",
      "[Parallel(n_jobs=-1)]: Done 11346 tasks      | elapsed: 17.7min\n",
      "[Parallel(n_jobs=-1)]: Done 12896 tasks      | elapsed: 19.8min\n",
      "[Parallel(n_jobs=-1)]: Done 14546 tasks      | elapsed: 22.5min\n",
      "[Parallel(n_jobs=-1)]: Done 16296 tasks      | elapsed: 25.8min\n",
      "[Parallel(n_jobs=-1)]: Done 18146 tasks      | elapsed: 29.6min\n",
      "[Parallel(n_jobs=-1)]: Done 20000 out of 20000 | elapsed: 33.6min finished\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'y_preds_rfr_rfc_gs' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-21-0ce6792381b6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0my_preds_rfr_cv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrfc_gs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mevaluation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_preds_rfr_rfc_gs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mprint_results\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrfc_gs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'y_preds_rfr_rfc_gs' is not defined"
     ]
    }
   ],
   "source": [
    "# # GridSearch (----------remove hyphen from GridSearchCV----------)\n",
    "rfc_gs = GridSearchCV(rfc, parameters, cv=5, verbose=1, n_jobs=-1)\n",
    "\n",
    "rfc_gs.fit(X_train_smote, y_train_smote)\n",
    "y_preds_rfr_cv = rfc_gs.predict((X_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.9548872180451128\n",
      "Recall: 0.9755501222493888\n",
      "F1 Score: 0.9708029197080292\n",
      "Precision: 0.9661016949152542\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[399  10  14 109]\n",
      "Best Parameters: {'criterion': 'entropy', 'max_depth': 10, 'max_features': 10, 'n_estimators': 50, 'oob_score': False}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "evaluation(y_test, y_preds_rfr_cv)\n",
    "print_results(rfc_gs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a great improvement from our baseline model. All the metrics improved and this is the best performing so far before feature engineering.\n",
    "\n",
    "To confirm that this is the best performing model, we would like to play a little bit with the `max_feature` hyperparameter since we noticed that sometimes GridSearchCV might not choose the best one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.9605263157894737\n",
      "Recall: 0.9755501222493888\n",
      "F1 Score: 0.9743589743589743\n",
      "Precision: 0.973170731707317\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[399  10  11 112]\n"
     ]
    }
   ],
   "source": [
    "# Baseline Random Forest Model\n",
    "rfc = RandomForestClassifier(criterion='entropy',\n",
    "                             n_estimators= 150, \n",
    "                             max_depth=9, \n",
    "                             max_features=10,\n",
    "                             oob_score=True\n",
    "                            )\n",
    "\n",
    "# Fitting and predicting\n",
    "rfc.fit(X_train_smote, y_train_smote)\n",
    "y_preds_rfr_tuned = rfc.predict(X_test)\n",
    "\n",
    "# Evaluation Metrics\n",
    "evaluation(y_test, y_preds_rfr_tuned)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Feature Importance')"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtUAAAFXCAYAAABtI7IlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzde1iUdf7/8efggKKgKCKRSgrmqSKP6xpaHti2UCvdytRAzDJNJUXFI0okrqfSwpUMJDyUookHUPdrqJvllqmVmuEJMzwhGKCiAg4zvz+6ml+u4GlQEF+P6+q6nHvu+/N5v+9hrl7zmXtmDBaLxYKIiIiIiNw2u7IuQERERETkXqdQLSIiIiJiI4VqEREREREbKVSLiIiIiNhIoVpERERExEYK1SIiIiIiNjKWdQEiIiJ3Q5MmTWjcuDF2dv9/PenRRx8lMjLytsbbu3cvn3/+OREREaVV4jWaNGnCN998Q61ate7YHMVZuXIlhYWF9OvX767OK3IvU6gWEZH7xqJFi0otoB45coQzZ86Uyljlze7du3n44YfLugyRe4pCtYiI3PfS0tKIjIwkNzeXoqIiAgICePHFFzGbzUybNo09e/Zw8eJFLBYLU6dO5cEHH+TDDz/kwoULjB8/nhdeeIF3332X5ORkAHbs2GG9HRUVxY8//khmZiZNmjRh9uzZREdHs2nTJsxmM3Xr1mXKlCm4u7uXWN+JEyfo378/vr6+/PTTTxQVFREcHExCQgJHjx7l0Ucf5f333+fUqVMEBATQsWNH9uzZg8ViYfLkybRp04YrV64wffp0vvnmGypVqoSPjw/jx4/HycmJLl264OPjw8GDBwkJCWHLli1s376dKlWq8Pe//53Jkyfz22+/kZWVRd26dZk7dy6urq506dKFnj178s0333D69Gmef/55RowYAcDnn3/OJ598gp2dHTVr1mTGjBl4eHiwZcsWoqOjuXLlClWqVGHs2LG0bNnyrjzOIneURURE5D7QuHFjS/fu3S3PPfec9b+zZ89arly5YvH397f89NNPFovFYjl//rzl2Weftfzwww+W77//3jJ8+HBLUVGRxWKxWBYsWGB58803LRaLxbJq1SrLoEGDLBaLxfLtt99aunXrZp3rz7c//PBDy9///nfLlStXLBaLxbJ69WrLiBEjrLeXL19uef3110us+bfffrMcP37c0rhxY0tKSorFYrFYJk+ebOncubPlwoULlvz8fIuvr69l9+7d1v3WrVtnsVgslv/85z8WX19fS2FhoeWDDz6wDBs2zFJYWGgpKiqyjBs3zhIWFmaxWCyWzp07W+bNm2edd+zYsZbY2FiLxWKxxMfHWxYsWGCxWCwWs9lsef311y0LFy60Hjd9+nSLxWKxZGRkWB577DFLenq6JTU11dKuXTvLqVOnLBaLxfLJJ59YwsLCLL/88oule/fuluzsbIvFYrEcOnTI4uvra7l48eItP54i5Y1WqkVE5L5R3OUfR44cIT09nQkTJli35efn8/PPP9O3b19q1KjB8uXLOX78ODt27KBatWq3PG+LFi0wGn//X+7WrVvZt28f//jHPwAwm81cvnz5hmPY29vTpUsXADw9PWnZsiVOTk4A1KlTh3PnzlGnTh1q1KhBjx49AHjqqaeoVKkSBw8eZNu2bYwcORJ7e3sAAgICGDp0qHX8Nm3aFDtv//792bVrF5988gnHjh3j8OHDPP7449b7u3btCoC7uzuurq6cO3eOnTt30qFDBzw8PAAICgoC4NNPPyUzM9N6G8BgMJCenk7Tpk1veA5EyjOFahERua8VFRXh7OzM2rVrrdvOnj2Ls7Mz//nPf4iMjGTAgAF07doVLy8v1q1bd80YBoMBi8VivX3lypWr7q9atar132azmddff52+ffsCUFhYyLlz525Yp729PQaD4arbxalUqdJVt81mM5UqVcJsNl91vNlsvqrOP9f4Z7NmzWLv3r384x//oF27dphMpqt6rVy5svXff5yHSpUqXTVXfn4+J0+exGw20759e+bOnWu97/Tp09SpU+dG7YuUe/pKPRERua81bNiQKlWqWEP16dOn6d69Oz/99BPbt2+nc+fO9O3bl0cffZSUlBSKioqA38OryWQCoFatWpw6dYrffvsNi8XC+vXrS5yvQ4cOfP755+Tl5QHwwQcfEBoaWmr9ZGdns23bNgC2bNmCvb09jRs3pmPHjixbtowrV65gNpv59NNP8fX1LXaMP/f29ddf079/f1544QVcXV3573//az0HJWnXrh3ffPMNmZmZACxfvpxZs2bRvn17tm/fTlpaGgBffvklzz33HPn5+aXVvkiZ0Uq1iIjc1xwcHJg/fz6RkZHExsZiMpl4++23ad26NS4uLowaNYoePXpgMpnw9fW1fsCwRYsW/Otf/2LYsGHMmzePV155hX/84x+4ubnRqVMn9u3bV+x8L730EmfOnOHll1/GYDDg4eHB9OnTS62fypUrs3btWmbPnk2VKlX417/+RaVKlRgyZAgzZszghRdewGQy4ePjQ1hYWLFjPPnkk9aahg4dysyZM/nggw+wt7enVatWpKenX7eGJk2aMGbMGF5//XUA3NzcmDZtGu7u7kRERBASEoLFYsFoNBIdHX1bl9SIlDcGy5/fwxEREZF71okTJ+jRowc//PBDWZcict/R5R8iIiIiIjbSSrWIiIiIiI20Ui0iIiIiYiOFahERERERGylUi4iIiIjYSF+pJyK3zWQqIifnUlmXUWpq1qyqfsqpitQLqJ/yriL1U5F6gfLRj5ubc7HbtVItIrfNaKx0453uIeqn/KpIvYD6Ke8qUj8VqRco3/0oVIuIiIiI2EihWkRERETERgrVIiIiIiI2UqgWEREREbGRQrWIiIiIiI30lXoictt6jFpb1iWUC3HjupR1CSIiUsa0Ui0iIiIiYiOFahERERERGylUi4iIiIjYSKFaRERERMRGCtUi/yMxMZHZs2dftW3kyJEUFhYWu39ubi5JSUl3ozQREREppxSqRW7CnDlzcHBwKPa+gwcPsmXLlrtckYiIiJQn+ko9kWLs2bOH1157jezsbPr06cOCBQvYuHEjX375JTExMRiNRurWrcvMmTP56KOPOHDgAAkJCfj6+jJx4kRMJhMGg4FJkybRtGlTVq5cyaeffkqNGjWwt7fH398fgFWrVmE2mwkODiYtLY1NmzZhMplwdnYmKiqK5ORktm7dSn5+PllZWQQGBrJ582YOHz5MaGgofn5+xdafmJh4w+OWLl16zXwrV67k+++/57333mPs2LH4+PjQr1+/u3nqRURE7kkK1SLFMBqNLFy4kJMnTzJo0CDr9uTkZIKCgujWrRtr1qwhLy+PwYMHs3z5cnr37k1wcDABAQH4+fmRmprKhAkTiI2NJTY2ljVr1uDg4EBgYKB1vOrVqxMdHY3ZbGb37t3Ex8djZ2fHwIED2bdvHwAXL14kLi6O9evXEx8fz4oVK9ixYweLFy8uMVTf6LguXbqQm5t7zXz9+vVj+/btjBs3jitXrihQ3yQ3N+eyLqFE5bm2W1WRegH1U95VpH4qUi9QfvtRqBYpRvPmzTEYDLi5uZGfn2/dPn78eBYsWMCyZcvw8vK6JtSmpaXRtm1bAJo1a0ZGRgbp6el4e3vj6OgIQMuWLa37N2zYEAA7Ozvs7e0JCQmhatWqZGRkYDKZrOMAODs74+3tjcFgoEaNGhQUFFy3h+sdd735Bg0aRO/evUlMTLzt83e/ycq6UNYlFMvNzbnc1narKlIvoH7Ku4rUT0XqBcpHPyWFel1TLVIMg8FQ7PaEhASGDx/O0qVLAfjiiy+ws7PDbDYD4O3tza5duwBITU2ldu3aeHp6cvToUfLz8zGbzezdu9c6np3d70/BAwcOkJKSwty5cwkLC8NsNmOxWK5by+32cL35CgsLmTZtGhEREYSHh5f44UwRERG5mlaqRW6Bj48PAwYMwMXFhWrVqtGpUycKCws5dOgQ8fHxhIaGEhYWRlxcHCaTicjISGrVqsUbb7xB3759cXFxoaCgAKPRaF0ZBnjooYdwdHSkV69eODg44ObmRmZm5h3ro6T5Zs+eTadOnejduzeZmZm89957jB8//o7VISIiUlEYLH8sh4nIHWEymYiJiWHIkCEA9OvXjxEjRlgvE7mX9Ri1tqxLKBfixnUp6xKKVR7eJi0tFakXUD/lXUXqpyL1AuWjn5Iu/9BKtcgdZjQauXz5Mj179sTe3h4fHx/atGlTKmOHh4eTlpZ2zfaYmBiqVKlSKnOIiIjIjSlUi9wFISEhhISElPq44eHhpT6miIiI3DqFahG5bUnvPV/mb8OVpvLwtqKIiNyb9O0fIiIiIiI2UqgWEREREbGRQrWIiIiIiI0UqkVEREREbKRQLSIiIiJiI4VqEREREREbKVSLiIiIiNhIoVpERERExEYK1SIiIiIiNlKoFhERERGxkUK1iIiIiIiNFKpFRERERGykUC0iIiIiYiOFahERERERGxnLugARuXf1GLW2rEu4p8SN61LWJYiIyB2ilWoRERERERspVIuIiIiI2EihWkRERETERgrVIiIiIiI2UqiWCuXgwYPs3LnzpvcfNmzYHazm1txq7cXZuXMnBw4cAMpXbyIiIhWdQrVUKJs2beLIkSM3vf+8efPuYDW35lZrL86qVavIzMwEyldvIiIiFZ2+Uk/uWYmJiRw9epTRo0dTUFBAq1atcHd3x97enkceeYT8/HzmzJlDpUqVqF+/PhERESQlJbFq1SrMZjPBwcGMHj2a7du3ExAQQNOmTTl8+DB5eXl88MEH1K1blyVLlpCcnIzBYMDf35/AwMAS61m5ciXLli3DbDbTtWtXhg8fzrp161i0aBEODg40aNDAWsOXX35Jfn4+6enpvPHGG/j6+rJ69Wpr7RMmTKBBgwY4ODgQGhpKeHg4BQUF5ObmMnToUPz8/Ni6das1ODdv3pzevXvz1VdfsX//fho1asRLL73E9u3b+fnnn3n33XepVKkSlStX5t1338VsNjNq1CgeeOABjh8/zmOPPcY777zD7t27mTFjBkajkerVqzN79mycnJzu1kMqIiJyz1KolgrD3d2dnj17Urt2bR577DGeeeYZPvvsM1xdXZk7dy6rV6+2hsXo6Ohrjvfx8WHixInMmTOH9evX06VLFzZs2MBnn32GwWAgKCiIDh064OXldc2xv/32GzExMaxbtw4HBwemT5/OyZMniYqKYvXq1Tg5OTFt2jQSEhKoWrUqeXl5LFy4kGPHjjF48GB69eplrd3Hx4dLly7x1ltv0bx5c/773/8yYMAA2rVrx/fff09UVBSdOnXi3XffZeXKlbi6ujJv3jxq1apFx44d8ff358EHH7TWNmnSJCIjI2nWrBkpKSlMnz6d0NBQjh07xsKFC3F0dMTPz4+srCxSUlL429/+xsCBA9myZQvnz59XqC5Fbm7O98Wcd0pF6gXUT3lXkfqpSL1A+e1HoVoqBIvFctXt7OxsMjMzGTFiBAD5+fn4+vri6elJw4YNix2jefPmADzwwAOcPXuWQ4cOcerUKYKCggA4d+4c6enpxYbq48eP8/DDD1OlShUAJkyYwN69e2nUqJE1lLZt25avv/6axx9/nKZNmwLg4eFBYWFhsfX8UaebmxvR0dF8/vnnGAwGTCYTOTk5VK9eHVdXV+D6109nZmbSrFkzaw3vvfceAJ6entba3NzcKCgoYPDgwXz00Uf0798fd3d3fHx8ShxXbl1W1oW7Op+bm/Ndn/NOqUi9gPop7ypSPxWpFygf/ZQU6nVNtdyzKleuTFZWFgD79+8HwGAwYDabqVmzJg888ADz589nyZIlDB48mHbt2gFgZ3dzf/ZeXl40atSIxYsXs2TJEnr16kXjxo2L3dfT05OjR49aA3JwcDCurq6kpaVx6dIlAL777jtrUDYYDNeM8Uftf/ijzg8++IDnn3+eWbNm0a5dOywWC66urpw/f57c3FwApk6dyt69ezEYDNe8wKhTp471w4s7d+6kQYMGJdaQlJREz549WbJkCQ8//DArVqy4qXMlIiJyv9NKtdyzOnbsyLJly+jTpw+PPPII1apV49FHH2XmzJl4e3szceJEBg0ahMVioVq1asycOZPTp0/f9PhNmzalffv29OnTh8LCQnx8fHB3dy9231q1avHGG2/w6quvYjAY6Ny5M3Xr1mX48OEEBgZiZ2eHp6cno0ePZv369cWO8efa/+yZZ54hMjKSBQsW4OHhQU5ODnZ2dkyZMoU333wTOzs7mjdvzmOPPcbPP//M7NmzqVevnvX4qVOn8u6772KxWKhUqRLTpk0rsefHHnuMcePGUbVqVezt7YmIiLjp8yUiInI/M1j+d1lLROQm9Ri1tqxLuKfEjetyV+crD2+TlpaK1Auon/KuIvVTkXqB8tFPSZd/aKVa5BZs3ryZ+Pj4a7YHBgbyt7/97e4XJCIiIuWCQrXILejatStdu3Yt6zJERESknFGoFpHblvTe82X+NlxpKg9vK4qIyL1J3/4hIiIiImIjhWoRERERERspVIuIiIiI2EihWkRERETERgrVIiIiIiI2UqgWEREREbGRQrWIiIiIiI0UqkVEREREbKRQLSIiIiJiI4VqEREREREbKVSLiIiIiNhIoVpERERExEYK1SIiIiIiNlKoFhERERGxkbGsCxCRe1ePUWvLuoQKI25cl7IuQUREbKCVahERERERGylUi4iIiIjYSKFaRERERMRGCtVy30pMTGT27NlXbRs5ciSFhYXF7p+bm0tSUtLdKO2uKigooEsXXc8rIiJiC4VqkT+ZM2cODg4Oxd538OBBtmzZcpcrEhERkXuBvv1D7mt79uzhtddeIzs7mz59+rBgwQI2btzIl19+SUxMDEajkbp16zJz5kw++ugjDhw4QEJCAr6+vkycOBGTyYTBYGDSpEk0bdqUlStX8umnn1KjRg3s7e3x9/cHYNWqVZjNZoKDg0lLS2PTpk2YTCacnZ2JiooiOTmZrVu3kp+fT1ZWFoGBgWzevJnDhw8TGhqKn59fsfUnJibe8Lh169axaNEiHBwcaNCgARERERQWFjJ69GjOnz+Pp6endbyDBw8ydepUAFxcXJg2bRrOzs53/oEQERG5xylUy33NaDSycOFCTp48yaBBg6zbk5OTCQoKolu3bqxZs4a8vDwGDx7M8uXL6d27N8HBwQQEBODn50dqaioTJkwgNjaW2NhY1qxZg4ODA4GBgdbxqlevTnR0NGazmd27dxMfH4+dnR0DBw5k3759AFy8eJG4uDjWr19PfHw8K1asYMeOHSxevLjEUH2j41q3bk1UVBSrV6/GycmJadOmkZCQAEDjxo0ZOXIke/bsYceOHQCEhYUxbdo0GjVqxMqVK4mNjWXkyJF34tSLiIhUKArVcl9r3rw5BoMBNzc38vPzrdvHjx/PggULWLZsGV5eXteE2rS0NNq2bQtAs2bNyMjIID09HW9vbxwdHQFo2bKldf+GDRsCYGdnh729PSEhIVStWpWMjAxMJpN1HABnZ2e8vb0xGAzUqFGDgoKC6/ZwveOOHz9Oo0aNcHJyAqBt27Z8/fXXAHTs2BGAxx9/HKPRaO3rnXfeAeDKlSvWuuXOc3O7M+8I3Klxy0JF6gXUT3lXkfqpSL1A+e1HoVruawaDodjtCQkJDB8+HFdXVyZPnswXX3xBvXr1MJvNAHh7e7Nr1y66du1KamoqtWvXxtPTk6NHj5Kfn4+DgwN79+7Fy8sL+D1MAxw4cICUlBRWrlzJ5cuX6dWrFxaL5bq13G4PAPXq1SMtLY1Lly5RtWpVvvvuOxo2bIjBYODHH3/Ez8+Pn3/+2RrsGzZsyIwZM3jwwQfZvXs3WVlZt1WT3LqsrAulPqabm/MdGbcsVKReQP2UdxWpn4rUC5SPfkoK9QrVIsXw8fFhwIABuLi4UK1aNTp16kRhYSGHDh0iPj6e0NBQwsLCiIuLw2QyERkZSa1atXjjjTfo27cvLi4uFBQUYDQarYEV4KGHHsLR0ZFevXrh4OCAm5sbmZmZd6yPWrVqMXz4cAIDA7Gzs8PT05PRo0dTqVIlxo8fT58+ffDy8sLe3h6A8PBwxo4dS1FREQCRkZF3rDYREZGKxGD5Y5lMRGxiMpmIiYlhyJAhAPTr148RI0ZYLxOpiPQz5aXnTvxMeXlY0SktFakXUD/lXUXqpyL1AuWjH61Ui9xhRqORy5cv07NnT+zt7fHx8aFNmzalMnZ4eDhpaWnXbI+JiaFKlSqlMoeIiIjcPoVqkVIUEhJCSEhIqY8bHh5e6mOKiIhI6dGPv4iIiIiI2Egr1SJy25Lee77Mr20rTeXhWj0REbk3aaVaRERERMRGCtUiIiIiIjZSqBYRERERsZFCtYiIiIiIjRSqRURERERspFAtIiIiImIjhWoRERERERspVIuIiIiI2EihWkRERETERgrVIiIiIiI2UqgWEREREbGRQrWIiIiIiI0UqkVEREREbKRQLSIiIiJiI2NZFyAi964eo9aWdQn3jbhxXcq6BBERuQ6tVIuIiIiI2EihWkRERETERgrVIiIiIiI2UqiWCisxMZHZs2dftW3kyJEUFhYWu39ubi5JSUl3o7S7Ki0tjYCAAOD6/YuIiMjtU6iW+8qcOXNwcHAo9r6DBw+yZcuWu1zR3XW9/kVEROT26ds/pELbs2cPr732GtnZ2fTp04cFCxawceNGvvzyS2JiYjAajdStW5eZM2fy0UcfceDAARISEvD19WXixImYTCYMBgOTJk2iadOmrFy5kk8//ZQaNWpgb2+Pv78/AKtWrcJsNhMcHExaWhqbNm3CZDLh7OxMVFQUycnJbN26lfz8fLKysggMDGTz5s0cPnyY0NBQ/Pz8iq0/MTHxhsdt3LiR+Ph47OzsaN26NaNHjyYzM5PRo0djsVhwc3OzjtelSxc2btzIr7/+yvTp0zGbzZw/f55JkybRqlUrnn76aVq1asUvv/yCq6srUVFRVKpU6a48ViIiIvcyhWqp0IxGIwsXLuTkyZMMGjTIuj05OZmgoCC6devGmjVryMvLY/DgwSxfvpzevXsTHBxMQEAAfn5+pKamMmHCBGJjY4mNjWXNmjU4ODgQGBhoHa969epER0djNpvZvXu3NeQOHDiQffv2AXDx4kXi4uJYv3498fHxrFixgh07drB48eISQ/WNjmvTpg1RUVGsWrUKR0dHxowZw/bt2/n666/p3r07L7/8Mhs2bGDZsmVXjXnkyBHGjh1LkyZNSEpKIjExkVatWnH8+HEWLVqEh4cHr7zyCvv27aNFixal/KjI7XBzc76rx5VHFakXUD/lXUXqpyL1AuW3H4VqqdCaN2+OwWDAzc2N/Px86/bx48ezYMECli1bhpeX1zWhNi0tjbZt2wLQrFkzMjIySE9Px9vbG0dHRwBatmxp3b9hw4YA2NnZYW9vT0hICFWrViUjIwOTyWQdB8DZ2Rlvb28MBgM1atSgoKDguj1c77j09HSys7OtLxguXrzI8ePHOXz4MM8//zwArVq1uiZU16lTh/nz51OlShUuXryIk5MTADVr1sTDwwMADw+PG9Ymd09W1oVbPsbNzfm2jiuPKlIvoH7Ku4rUT0XqBcpHPyWFel1TLRWawWAodntCQgLDhw9n6dKlAHzxxRfY2dlhNpsB8Pb2ZteuXQCkpqZSu3ZtPD09OXr0KPn5+ZjNZvbu3Wsdz87u96fSgQMHSElJYe7cuYSFhWE2m7FYLNet5XZ7AKhXrx4eHh7ExcWxZMkSXn31VR5//HG8vLz44YcfAKwr5X8WGRlJcHAwM2bMoHHjxjbXKCIicr/TSrXcl3x8fBgwYAAuLi5Uq1aNTp06UVhYyKFDh4iPjyc0NJSwsDDi4uIwmUxERkZSq1Yt3njjDfr27YuLiwsFBQUYjUbrSjTAQw89hKOjI7169cLBwQE3NzcyMzPvWB+1atUiKCiIgIAAioqKqFu3Ls8++yxvv/02I0eOZMOGDdSrV++a45577jneeustXF1deeCBB8jJybljNYqIiNwPDJY/lqhE5LpMJhMxMTEMGTIEgH79+jFixAjrZSL3I/1M+d1zOz9TXh7eJi0tFakXUD/lXUXqpyL1AuWjn5Iu/9BKtchNMhqNXL58mZ49e2Jvb4+Pjw9t2rQplbHDw8NJS0u7ZntMTAxVqlQplTlERETkzlGoFrkFISEhhISElPq44eHhpT6miIiI3D36oKKIiIiIiI20Ui0ity3pvefL/Nq20lQertUTEZF7k1aqRURERERspFAtIiIiImIjhWoRERERERspVIuIiIiI2EihWkRERETERgrVIiIiIiI2UqgWEREREbGRQrWIiIiIiI0UqkVEREREbKRQLSIiIiJiI4VqEREREREbKVSLiIiIiNhIoVpERERExEYK1SIiIiIiNjKWdQEicu/qMWptWZcgNyluXJeyLkFEpELTSrWIiIiIiI0UqkVEREREbKRQLSIiIiJio3Ibqnfu3MmBAwfKZO5PP/2U559/ng0bNhR7f25uLklJSQB8/PHH7N27926WZ52zoKCAlStXAhAVFcWyZctsGjcgIIC0tLTSKNEm48aNY9u2bSXefzfq/OKLLzhz5swdneN2paamMm/evBLvT0xMZPbs2ddsHzlyJIWFhdbzu23bNhISEgBISEjgypUrd6xmERGRiq7chupVq1aRmZlZJnN/8cUXzJw5E39//2LvP3jwIFu2bAFg0KBB+Pj43M3yrHNmZWVZQ7WUrsWLF5OXl1fWZRSrWbNmDBs27JaPmzNnDg4ODtbbTz75JL179wZgwYIFmM3mUqtRRETkfnPDb/9ITExk8+bN5OXlkZOTw9ChQ6lZsyZz5syhUqVK1K9fn4iICJKSkli1ahVms5ng4GBOnDjBsmXLMJvNdO3aleHDh7Nx40bi4+Oxs7OjdevWjB49mqioKE6cOMFvv/3GqVOnGD9+PDVr1uSrr75i//79NGrUiC1btrBp0yZMJhPOzs5ERUVhNpsJDQ0lMzMTDw8Pdu7cyddff83BgweZOnUqAC4uLkybNg1nZ+dieyQu9VwAACAASURBVDtx4gQTJ07EZDJhMBiYNGkSe/bs4aeffmLixInMmTOH+vXrX3PcRx99xIEDB0hISOCHH37A39+fs2fPsnXrVvLz88nKyiIwMJDNmzdz+PBhQkND8fPzK7b/4qSkpPDf//6XyZMns2DBAn788Ueio6NZu3Ytp0+f5tixY/j7+7Np0yaOHDliXbXcvHkz//73v8nNzeXtt9+mS5fiP+2fl5fHxIkTuXDhAjk5Obz00kv07dsXgA8//JCcnBwcHByYOXMmhw8fJiYmBnt7e06cOIG/vz9Dhgwp9tw1bdqUzp074+XlhZeXFxcuXMBoNHLq1CkKCwvx9/dn69atnD59mvnz51O3bl0mT55MRkYGOTk5PPnkk4wYMeJGf5JW58+fZ8yYMeTl5VFUVMTbb79N+/bt6dGjB3/5y184ePAgBoOB+fPn4+TkxDvvvMNPP/1E7dq1OXnyJNHR0dSrV++acf/zn/+QmprK2LFj+eyzz0hISCA5ORmDwYC/vz+BgYGMGzeO3NxccnNzGThwIMuXL8fe3p6MjAxeeeUVvv32Ww4cOEBgYKD13P6vf/7znzRt2pSePXuSlZXFm2++ycqVK4s9J/8734YNG5gzZw5Lly695rkB8OOPP9K/f3/y8vIYPnw4nTp1okuXLmzcuNE6f2JiIkePHuWhhx4iKyuLkSNH0qhRI9zd3enXrx/nzp1jwIABJCYm3vRjIiIicr+6qa/Uu3TpEp988gnZ2dm89NJL2NnZsWLFClxdXZk7dy6rV6/GaDRSvXp1oqOj+e2335gyZQrr1q3DwcGB6dOnc+rUKaKioli1ahWOjo6MGTOG7du3A+Dg4EBsbCzbt28nLi6OhQsX0rFjR/z9/XnggQfIzc21htGBAweyb98+fvrpJ+rVq8eHH35IWloa3bt3ByAsLIxp06bRqFEjVq5cSWxsLCNHjiy2r5kzZxIQEICfnx+pqalMmDCBxMREkpOTCQ8PLzZQAwwePJjly5fTu3dvfvjhB+v2ixcvEhcXx/r164mPj2fFihXs2LGDxYsX06ZNm2L79/X1vWb8Dh068MEHHwCwa9cuzp49i8lkYuvWrQwfPpyYmBhrHYcOHWLYsGFERUXh7u5OZGQkO3bsIDY2tsRQ/euvv9KtWzeefvppzpw5Q0BAgDX4Pf3003Tr1o1PP/2UBQsW0KVLF06dOsW6desoLCykY8eODBkypMRzd/r0aRITE6lZsybjxo2jbt26TJ06lcmTJ3PixAliYmL48MMP2bJlC35+frRo0YKXXnqJgoKCWw7V0dHRPPHEE/Tv358zZ87Qp08fUlJSuHjxIt26dSMsLIxRo0axbds2KleuTG5uLp9//jnZ2dk8/fTTJY7bqVMnmjVrRnh4OOnp6WzYsIHPPvsMg8FAUFAQHTp0AOCvf/0rQUFB7Nixg4yMDNasWcP+/ft5++23rZePDBs2rMRQ/fLLL/POO+/Qs2dP1q5dS69evTh9+nSJ5+TP8wGYzeZinxsAjo6OfPzxx9bn7JNPPllivy+99BLR0dHMmTOHzMxMQkJC6NevH8nJyfTo0eOmHw8p39zcil9cuJdUhB7+TP2UbxWpn4rUC5Tffm4qVLdt2xY7Oztq166No6Mjv/76q/V/9Pn5+fj6+uLp6UnDhg0BOH78OA8//DBVqlQBYMKECezdu5fs7GwGDRoE/B5Ajx8/Dvz+djbAAw88QGFh4VVz29nZYW9vT0hICFWrViUjIwOTyURaWpo1KHh7e1OrVi0A0tLSeOeddwC4cuWKtabipKWl0bZtW2sNGRkZN3M6SvRHH87Oznh7e2MwGKhRowYFBQWkp6eX2P//qlKlCg0bNmTv3r0YjUZatGjBzp07OX36NN7e3iXO/8gjjwBQu3Zt8vPzS9yvdu3aLFq0iE2bNuHk5ITJZLLe16ZNGwBatWrFl19+CUDjxo0xGo0YjUbrY1rSuatZsyY1a9a0jte8eXMAqlevjpeXl/XfhYWFuLi4sG/fPr799lucnJyueexvJC0tzRr63N3dcXJyIjs7+6p5PTw8KCgo4OTJk7Ro0QKAWrVqWWu5kUOHDnHq1CmCgoIAOHfuHOnp6QBX/W09/PDD2Nvb4+zsjKenJw4ODtbHviTe3t4UFRVx8uRJNmzYYA3HJZ2T//1bLum5AdC6dWsMBgOurq44OzuTm5t7U/3Wr1+fatWqceTIEZKSkpg/f/5NHSflX1bWhbIuwSZubs73fA9/pn7Kt4rUT0XqBcpHPyWF+psK1fv37wfg7NmzFBQU4Onpyfz583F2dmbz5s1UrVqV06dPY2f3+yXanp6eHD16lMLCQhwcHAgODmbs2LF4eHgQFxeHvb09iYmJNGvWjJSUFAwGwzVzGgwGLBYLBw4cICUlhZUrV3L58mV69eqFxWKhcePG/PDDD/j5+ZGenk5OTg7we/CYMWMGDz74ILt37yYrK6vEvry9vdm1axddu3YlNTWV2rVr38zpwM7OrtjrT4vr4w/16tUrtv+S+Pn5MWvWLLp27Ur9+vWZM2cOTzzxxHXruN78fxYXF0eLFi3o27cv3377rTU8A+zbtw93d3d27drFww8/XOK4JZ27P/4GbqamxMREnJ2diYiI4Ndff2XFihVYLJab6uHPNTRv3pwzZ85w/vx5XFxcip334YcfZu3a33+o5Ny5cxw7duy6Y//x9+fl5UWjRo2IjY3FYDAQHx9P48aN+fe//33VHDd77v/Xiy++yKxZs2jUqBHVq1dn8eLFJZ6T/52jpOcGYF2xzsrK4tKlS1e90Cmp3z/+ll5++WWio6Nxd3e3vlgVERGR67upUH327Fn69+/PhQsXmDJlCnZ2dgwaNAiLxUK1atWYOXMmp0+ftu5fq1Yt3njjDV599VUMBgOdO3embt26BAUFERAQQFFREXXr1uXZZ58tcc7HH3+c2bNn8/777+Po6EivXr1wcHDAzc2NzMxMXnzxRcaNG0e/fv148MEHqVy5MgDh4eGMHTuWoqIiACIjI0ucIzQ0lLCwMOLi4jCZTNfd9888PT05dOgQ8fHxN7X/H+fkVvrv3LkzEyZMYMqUKTzwwAO8/fbbhIeHX7WPq6srV65cYdasWdYV5JvRuXNnwsPDSUpKwsXFhUqVKllXRFNSUli0aBHVqlVjxowZJX4Dy+2euz9r3749ISEh7N69G0dHRx566KFb+nDqm2++yYQJE/i///s/8vPziYiIwGgs/k+6U6dObNu2jVdeeYXatWtTpUoV7O3tSxy7ZcuWhIaGEhcXR/v27enTpw+FhYX4+Pjg7u5+y72W5JlnniEyMpLo6Gjg1s7JQw89VOxzA35/BykwMJBLly4RERFxw9Dfpk0bBg0axOLFi/Hz8yMiIoJZs2aVWp8iIiIVncFyg6XBPz7MVNKH6srK999/z6VLl+jQoQPHjh3j9ddfJyUlpazLknIqLS2NAwcO0K1bN3JycujevTtbt2696tsw5HeXL1/m1VdfZeXKlde88/C/9DPl9457/WfKy8NbvqVJ/ZRvFamfitQLlI9+bLr8ozyqX78+ISEhzJs3D5PJxOTJk4vdr7CwkIEDB16zvWHDhkRERFx3jmHDhnHu3Lmrtjk5OVlXFW21d+/eYlcDn3322RI/3HYrwsPDi/0+55iYmFta2S4Lp06dYuzYsddsb9u2LcHBwbc8noeHB7Nnz2bRokUUFRUxevRovvrqq2LfbQgMDORvf/vb7ZRdrHnz5lk/XPhn06ZNK/HDsGXl+++/Z8qUKYwYMeKGgVpERET+vxuuVIuIlEQr1fcOrVSXL+qnfKtI/VSkXqB89FPSSrWWokREREREbHTPXv4hImUv6b3ny3zFoDSVhxWQ0lTR+hERKc+0Ui0iIiIiYiOFahERERERGylUi4iIiIjYSKFaRERERMRGCtUiIiIiIjZSqBYRERERsZFCtYiIiIiIjRSqRURERERspFAtIiIiImIjhWoRERERERspVIuIiIiI2EihWkRERETERgrVIiIiIiI2UqgWEREREbGRsawLEJF7V49Ra8u6BKkA4sZ1KesSRERsppVqEREREREbKVSLiIiIiNhIoVpERERExEYK1VKudOnShYKCgjKtYdu2bYwbN+6m9i0oKKBLl9K5HjQgIIC0tDSbxvjiiy84c+YMWVlZhIeHl0pdIiIicmMK1SIVyOLFi8nLy8PNzU2hWkRE5C7St3/IHZGYmMjmzZvJy8sjJyeHoUOHEhUVRYMGDXBwcCA8PJwxY8aQl5dHUVERb7/9Nu3bt7cef+LECSZOnIjJZMJgMDBp0iSaNm3K008/TatWrfjll19wdXUlKiqKK1euEBoaSmZmJh4eHuzcuZOvv/6agIAAwsPD8fb2ZtmyZZw9e5bhw4ezZMkSkpOTMRgM+Pv7ExgYSFpaGhMmTMDR0RFHR0dq1KhRYm8XL15k9OjRnD9/Hk9PT+v2gwcPMnXqVABcXFyYNm0a1apVY+rUqezdu5crV64wfPhw/Pz8eO+999i5cycWi4WgoCCeffZZ6zgXLlxg4sSJ5OTkADBp0iSaNGlC586d8fLywsvLi5deeonp06djNps5f/48kyZN4vz586SmpjJ27FhmzZrF2LFjWbFiBdu3b2fu3LlUrlzZWldqaioxMTHY29tz4sQJ/P39GTJkCJs2bSImJgaj0UjdunWZOXMmdnZ67S0iInIjCtVyx1y6dIlPPvmE7OxsXnrpJYqKinjrrbdo3rw5M2bM4IknnqB///6cOXOGPn36kJKSYj125syZBAQE4OfnR2pqKhMmTCAxMZHjx4+zaNEiPDw8eOWVV9i3bx979uyhXr16fPjhh6SlpdG9e/cSazpy5AgbNmzgs88+w2AwEBQURIcOHfjggw8IDg7G19eXjz/+mKNHj5Y4xurVq2ncuDEjR45kz5497NixA4CwsDCmTZtGo0aNWLlyJbGxsTz66KPk5OTw+eefk5WVxdKlS61Bdvny5RQUFPDyyy/j6+trHf+jjz7ir3/9K3379uXYsWOMHz+eZcuWcfr0aRITE6lZsyYbNmxg7NixNGnShKSkJBITE5k6dSrNmjUjPDwce3t7ACwWC2FhYSxbtgx3d3cWLVpEdHQ0nTp14tSpU6xbt47CwkI6duzIkCFDSE5OJigoiG7durFmzRry8vKoXr26rX8KItfl5uZcqvvdK9RP+VaR+qlIvUD57UehWu6Ytm3bYmdnR+3atalevTppaWk0bNgQgLS0NHr06AGAu7s7Tk5OZGdnW49NS0ujbdu2ADRr1oyMjAwAatasiYeHBwAeHh4UFBSQlpbGk08+CYC3tze1atW6phaLxQLAoUOHOHXqFEFBQQCcO3eO9PR0Dh8+jI+PDwCtWrW6bqg+fPgwHTt2BODxxx/HaDRaa37nnXcAuHLlCg0bNuSXX36hRYsWALi5uTFy5EhiYmLYv38/AQEBAJhMJk6dOmUd/9ChQ3z77bds3LgRgPPnz1t7r1mzJgB16tRh/vz5VKlShYsXL+Lk5FRsrTk5OTg5OeHu7m59TN5//306depE48aNMRqNGI1GqlSpAsD48eNZsGABy5Ytw8vLCz8/vxLPg0hpycq6cMN93Nycb2q/e4X6Kd8qUj8VqRcoH/2UFOr1vq7cMfv37wfg7Nmz5OXl4erqar2UwNvbm127dgFw5swZzp8/j4uLi/XYP9+fmppK7dq1ATAYDNfM07hxY3744QcA0tPTrZdNODg4kJWVBcDPP/8MgJeXF40aNWLx4sUsWbKEXr160bhxY7y8vKxj/PTTT9fty8vLix9//NE6rslkAqBhw4bMmDGDJUuWMGbMGJ566im8vLzYt28f8PtlHQMHDsTLy4t27dqxZMkSFi1axLPPPku9evWuGj8oKIglS5Ywd+5c64uPP1+GERkZSXBwMDNmzKBx48bWFw0Gg8H6b/g9iOfl5ZGZmQnAd999R4MGDUo8lwkJCQwfPpylS5cCv3/wUURERG5MK9Vyx5w9e5b+/ftz4cIFpkyZctUH5958800mTJjA//3f/5Gfn09ERIR1xRcgNDSUsLAw4uLiMJlMREZGljjPiy++yLhx4+jXrx8PPvgglStXBiAwMJCIiAg8PDyoU6cOAE2bNqV9+/b06dOHwsJCfHx8cHd3Z8qUKYwcOZKFCxdSq1Yt6xjF6devH+PHj6dPnz54eXlZL7UIDw9n7NixFBUVAb8H3wYNGvDNN9/Qp08fioqKGDp0KE8++STfffcdffv25dKlS/j5+V210jx48GAmTpzIihUryMvLY9iwYdfU8Nxzz/HWW2/h6urKAw88YH0h0bJlS0JDQ3n33XeB34Pz1KlTGT58OAaDgRo1avDPf/6Tw4cPF9ubj48PAwYMwMXFhWrVqtGpU6cSz4OIiIj8fwbLn5e1REpJYmIiR48eZfTo0Xd8ru+//55Lly7RoUMHjh07xuuvv37V9dly5+hnyqU03MzPlJeHt3xLk/op3ypSPxWpFygf/ZR0+YdWquWeV79+fUJCQpg3bx4mk4nJkyeXyrjh4eHFfm90TEyM9RpkEREREVColjukV69ed20uNzc3lixZUurj6nueRURE5Gbpg4oiIiIiIjbSSrWI3Lak954v82vbSlN5uFavNFW0fkREyjOtVIuIiIiI2EihWkRERETERgrVIiIiIiI2UqgWEREREbGRQrWIiIiIiI0UqkVEREREbKRQLSIiIiJiI4VqEREREREbKVSLiIiIiNhIoVpERERExEYK1SIiIiIiNlKoFhERERGxkUK1iIiIiIiNFKpFRERERGxkLOsCROTe1WPU2rIuQaTCihvXpaxLEJFboJVqEREREREbKVSLiIiIiNhIoVpERERExEYK1XLfSkxMZPbs2VdtGzlyJIWFhcXun5ubS1JS0t0oTURERO4xCtUifzJnzhwcHByKve/gwYNs2bLlLlckIiIi9wJ9+4fc1/bs2cNrr71GdnY2ffr0YcGCBWzcuJEvv/ySmJgYjEYjdevWZebMmXz00UccOHCAhIQEfH19mThxIiaTCYPBwKRJk2jatCkrV67k008/pUaNGtjb2+Pv7w/AqlWrMJvNBAcHk5aWxqZNmzCZTDg7OxMVFUVycjJbt24lPz+frKwsAgMD2bx5M4cPHyY0NBQ/P79i609MTLzhcRs3biQ+Ph47Oztat27N6NGjycjIIDw8nIKCAnJzcxk6dCh+fn706NGDv/zlLxw8eBCDwcD8+fNxdna+mw+JiIjIPUmhWu5rRqORhQsXcvLkSQYNGmTdnpycTFBQEN26dWPNmjXk5eUxePBgli9fTu/evQkODiYgIAA/Pz9SU1OZMGECsbGxxMbGsmbNGhwcHAgMDLSOV716daKjozGbzezevdsacgcOHMi+ffsAuHjxInFxcaxfv574+HhWrFjBjh07WLx4cYmh+kbHtWnThqioKFatWoWjoyNjxoxh+/btGAwGBgwYQLt27fj++++JiorCz8+Pixcv0q1bN8LCwhg1ahTbtm2jW7dud+4BEJESubndWy9o77V6b6Qi9VOReoHy249CtdzXmjdvjsFgwM3Njfz8fOv28ePHs2DBApYtW4aXl9c1oTYtLY22bdsC0KxZMzIyMkhPT8fb2xtHR0cAWrZsad2/YcOGANjZ2WFvb09ISAhVq1YlIyMDk8lkHQfA2dkZb29vDAYDNWrUoKCg4Lo9XO+49PR0srOzrS8YLl68yPHjx2ndujXR0dF8/vnnGAwGaw1/nBMADw+PG84tIndOVtaFsi7hprm5Od9T9d5IReqnIvUC5aOfkkK9rqmW+5rBYCh2e0JCAsOHD2fp0qUAfPHFF9jZ2WE2mwHw9vZm165dAKSmplK7dm08PT05evQo+fn5mM1m9u7dax3Pzu73p9qBAwdISUlh7ty5hIWFYTabsVgs163ldnsAqFevHh4eHsTFxbFkyRJeffVVHn/8cT744AOef/55Zs2aRbt27aw12FKHiIjI/Uwr1SLF8PHxYcCAAbi4uFCtWjU6depEYWEhhw4dIj4+ntDQUMLCwoiLi8NkMhEZGUmtWrV444036Nu3Ly4uLhQUFGA0Gq9aBX7ooYdwdHSkV69eODg44ObmRmZm5h3ro1atWgQFBREQEEBRURF169bl2Wef5ZlnniEyMpIFCxbg4eFBTk7OHatBRETkfmCw/HmJSkRum8lkIiYmhiFDhgDQr18/RowYYb1MpCLSz5SL3Dn30s+Ul4e35EtTReqnIvUC5aOfki7/0Eq1SCkxGo1cvnyZnj17Ym9vj4+PD23atCmVscPDw0lLS7tme0xMDFWqVCmVOUREROT2aaVaRG6bVqpF7hytVJeditRPReoFykc/+qCiiIiIiMgdoss/ROS2Jb33fJmvGJSm8rACUpoqUj8VqReoeP2IiFaqRURERERsplAtIiIiImIjhWoRERERERspVIuIiIiI2EihWkRERETERgrVIiIiIiI2UqgWEREREbGRQrWIiIiIiI0UqkVEREREbKRQLSIiIiJiI4VqEREREREbKVSLiIiIiNhIoVpERERExEYK1SIiIiIiNjKWdQEicu/qMWptWZcgcl+JG9elrEsQkRJopVpERERExEYK1SIiIiIiNlKoFhERERGxkUK13JCvr+8dHb+oqIiBAwfSp08fzp07d9PHBQQEkJaWdltzLl269Lr3Hzx4kJ07d97W2HfDsGHDSrzvxIkTvPzyy9ds//jjj9m7dy+JiYnMnj2brKwswsPDAdi5cycHDhy4U+WKiIhUeArVUuaysrLIyclh2bJl1KhR467MGR0dfd37N23axJEjR+5KLbdj3rx5t3zMoEGD8PHxsd52c3OzhupVq1aRmZlZWuWJiIjcd/TtH2UsMTGRrVu3kp+fT1ZWFoGBgWzevJnDhw8TGhrKlStXiI+Px87OjtatWzN69GgyMjIIDw+noKCA3Nxchg4dip+fHz169OAvf/kLBw8exGAwMH/+fJydna+Z88qVK/j7+7N27VqqVq1KbGwsRqORJ554gunTp2M2mzl//jyTJk2iVatW1uMCAgIIDw/H29ubZcuWcfbsWYYPH86SJUtITk7GYDDg7+9PYGBgif2uW7eORYsW4eDgQIMGDYiIiCAsLIxjx44xefJkIiIiij1uzpw5fPvtt5jNZrp160ZQUBAA//rXvzh79iyXL1/m/fffp379+kyfPp3du3cD0L17d/r378+4cePIzc0lNzeXp556inPnzhEeHm4NlX925swZVq9ejb29PY888gj5+fnMmTOHSpUqUb9+fSIiIkhKSmLVqlWYzWaCg4OZPHkyLVu25Ndff+Wvf/0rFy5cYO/evTRs2JBZs2YV29PmzZtJSUnhn//8JwAvvPACCxcuZOPGjWzatAmTyYSzszNRUVEkJydfNd/o0aPZvn073333nTVg5+fnM2PGDOzt7cnOzmbw4MFkZ2fz1FNPMXToUMaNG4e/v791/hMnThASEsLkyZP56quv2L9/P9nZ2WzZsoUPP/wQgFdeeYUPP/yQOnXqlPiYioiIiEJ1uXDx4kXi4uJYv3498fHxrFixgh07dhAfH096ejqrVq3C0dGRMWPGsH37dgwGAwMGDKBdu3Z8//33REVF4efnx8WLF+nWrRthYWGMGjWKbdu20a1bt2vms7e35+mnn2bTpk288MILbNiwgYULF/LNN98wduxYmjRpQlJSEomJiVeF6uIcOXKEDRs28Nlnn2EwGAgKCqJDhw54eXlds29OTg5RUVGsXr0aJycnpk2bRkJCAlOmTCEkJKTEQA2wZs0ali5diru7O/+vvXuPqrLK/zj+Pty8gAgJIkoqHCVvISKWl2VmWCGmjBd01HCZrmXWlIqjYSoOFlBeytSkNGU0s2XpHJ2spWNm5coZS4sGyytYpqKCgSUQHJDn90c/z2QczDgmB/y8/pLnPM/e+/s8bteHffY5WiwW2/F+/foRGxvL8uXL2bFjB+3ateP06dO8/fbbVFRUMGbMGHr27AlAz549bWH8jTfesBuoAQICAhg6dCh+fn7ceeedREdH8+abb9KsWTNeeukltmzZgpubG97e3rYV7zNnzrBu3Tr8/f2566672LRpE0lJSURFRfHjjz/i7e1dpZ97772XRYsWUVJSQnZ2Nq1bt8bX15eLFy/afpGaOHEiBw8eBLiqvyuOHz/OokWLCAgI4NVXX2XHjh0MHjyYkpISFi1aROPGjRk7dixRUVHV3tsuXbrQt29fYmJi6Nu3L6+++io//PAD+fn5+Pr6KlCLOBF//6oLJc7CmcdWE/WpnvpUCzhvPQrVTqBjx44ANGnSBLPZjMlkomnTppSUlFBQUMCkSZOAn8P3qVOn6N69O6+88gqbN2/GZDJRUVFha6tTp04ABAYGUlZWVm2fcXFxJCcnExISQtu2bW3hKT09nYYNG1JcXIyXl1e11xuGAcCxY8fIzc21hdUffviB7777zm6oPnXqFO3atbO126NHDz755BPuvffe37xHL774Ii+++CIXLlygb9++tuNdunQBwM/PjwsXLpCTk0NkZCQmkwl3d3e6du1q23cdHBz8m/38WkFBAXl5eUybNg34eTW4T58+tG7d+qr2fHx8aNmyJQCNGzemXbt2wM/PtLrn4OrqyoMPPsjOnTv58ssviYuLw8XFBXd3d6ZPn07jxo05d+6c7fnaG39AQACpqak0btyY8+fP234J6tChg+1dijvvvJNvvvnmuuo1mUwMGTKEd999l9OnTzNixIjruk5Ebo78/Eu1PQS7/P2bOO3YaqI+1VOfagHnqKe6UK891U7AZDJVezwwMJCMjAzWr1/Pww8/TNeuXVm6dCmxsbEsWrSIu+++2xZwr9XWr7Vt2xbDMFi9ejVxcXEApKamMmXKFBYsWEBoaOhV7QJ4eHiQn58PkjTKyAAAFmFJREFUwKFDhwAICQmhXbt2vP7666xfv55hw4YRGhpqt8+goCBycnIoKSkB4LPPPruuoGu1WtmxYwcvvvgi69atY8uWLZw5c8buuWaz2bb1o7y8nMzMTNq0aQNcfW9+XduvmUwmKisr8fX1pUWLFqSnp7N+/XomT57M3XffDYCLi8tV59fEiBEjeOedd/jvf/9Lnz59OHLkCLt27eKll14iKSmJyspK21h/2d8Vc+fOJS0tjeeff57mzZvbzs3JyaG4uJiKigqysrJo3779b9Z75drhw4ezY8cO9u/fT79+/WpUl4iIyK1GK9VOzM3NjfHjxxMfH8/ly5dp1aoVAwcOJDo6mtTUVFauXElgYCCFhYU1an/EiBEsXbrUtj1iyJAhPP744zRr1owWLVpUaXfcuHE888wzBAYG2rYEdOjQgV69ejF69GisVithYWEEBATY7e+2227jySefZNy4cbi4uNC6dWtmzJhhC+rV8fDwoGnTpsTGxtK0aVP69OljWxX+tf79+/PZZ58xatQoysvLiY6OpnPnzlXOM5vNzJgxg8WLF9ttp0uXLixcuBCz2cycOXOYNGkShmHg6enJwoULOXv27DXHfL1uv/12AKKionBxcaFNmzY0atSIYcOG4eHhgb+//zU/QBgbG8vIkSPx9vbGz8/Pdm7Tpk1JSEigoKCAmJgY28p5dbp27crixYsJCgrCbDbj6elJeHg4bm76J0JEROR6mIzfWrITkVvOo48+yuzZs22r/NXRf1MucnM5639T7gxvyd9I9ame+lQLOEc91W3/0DJUPWa1Wpk4cWKV48HBwdf8UKCjPvjgA9auXVvl+Lhx47j//vurvS4rK8vuN2UMHDiQMWPG3MghApCbm0tiYmKV4z169GDKlCk3rJ+a3o/aUFpaypgxY+jbt+9vBmoRERH5H61Ui0iNaaVa5ObSSvXNUZ/qqU+1gHPUow8qioiIiIj8QbT9Q0RqbNsLsbW+YnAjOcMKyI1Un+qpT7VA/atHRLRSLSIiIiLiMIVqEREREREHKVSLiIiIiDhIoVpERERExEEK1SIiIiIiDlKoFhERERFxkEK1iIiIiIiDFKpFRERERBykUC0iIiIi4iCFahERERERBylUi4iIiIg4SKFaRERERMRBCtUiIiIiIg5yq+0BiEjdNfiv/6ztIYiIOI2MWffV9hCkFmmlWkRERETEQQrVIiIiIiIOUqgWEREREXGQQrWIiIiIiIMUqkWcwKeffkpCQoJDbVy8eJFt27YBsGrVKrKysm7E0EREROQ6KFSL1BNHjx5l9+7dAEyaNImwsLBaHpGIiMitQ1+pJ1IDRUVFzJkzh0uXLlFYWEhcXBydO3cmNTUVwzAICAhg8eLFHD16tMqxkydPkpKSAoCPjw9paWlXtb19+3bWrl2Li4sL3bt3Z8aMGSxfvpzMzExKSkpITU1l69atfPXVVxQXF2M2m3nuued49dVXOXLkCG+99RaZmZnExMTQq1cvZs+ezalTp7h8+TKPPPIIMTExxMfH06FDB44fP05RURFLly7Fz8+PqVOnUlRURGlpKTNnzuTuu++ujdsrIiJS5yhUi9TAyZMnGTRoEA888ADnz58nPj6ehg0bsmTJEsxmMxs2bCAnJ4ekpKQqx+bPn09aWhrt2rVj06ZNrF69mt69ewM/b+FYvnw5//jHP2jUqBEzZ85k7969AISEhDB37lyKiorw9vbm73//O5WVlQwaNIjz588zefJkNm7cyKhRo8jMzATgrbfewtfXl0WLFlFUVMSwYcPo2bMnAGFhYcyZM4clS5bw3nvv0b9/fy5cuMDatWv5/vvv+fbbb2vl3oqI1FX+/k1qewh2Oeu4aspZ61GoFqkBPz8/1q1bx86dO/Hy8qKiooLvv/8es9kMwNixYwHsHrsSrAHKy8sJDg62tfvdd99RUFDApEmTACguLubUqVMAtvMaNGhAQUEB06dPp3HjxpSUlFBeXm53nDk5ObbA7uXlhdlstrXXqVMnAFq0aMGFCxdo3749Y8eOZfr06VRUVBAfH3+D7paIyK0hP/9SbQ+hCn//Jk45rppyhnqqC/UK1SI1kJGRQXh4OGPGjGHfvn18/PHHNG/enG+//Za2bduyatUqgoOD7R4LDg5mwYIFtGzZks8//5z8/Hxbu0FBQQQGBpKRkYG7uzsWi4WOHTuya9cuXFx+/gjEnj17OHv2LC+99BIFBQW8//77GIaBi4sLlZWVV43TbDZz4MAB7r//foqKijh27BhBQUF2azp69CjFxcWsWrWKvLw8/vznP9O/f/8/7iaKiIjUIwrVIjXQv39/kpOT2bZtGz4+Pri6upKcnMzs2bNxcXHB39+f8ePHExAQUOVYYGAgiYmJXL58GYDU1FTy8vIAuO222xg/fjzx8fFcvnyZVq1aMXDgwKv6DgsLIz09nZEjR+Lh4cHtt99OXl4erVu35tixY6xdu9Z27siRI0lKSmL06NGUlZXxxBNP0KxZM7s1tW3blhUrVrB161bc3d2ZMmXKH3PzRERE6iGTYRhGbQ9CROqmwX/9Z20PQUTEaWTMuq+2h1CFM2yXuJGcoZ7qtn/oK/VERERERBykUC0iIiIi4iDtqRaRGtv2Qmytvw13IznD24o3Un2qpz7VAqrH2dW3euTm0Eq1iIiIiIiDFKpFRERERBykUC0iIiIi4iCFahERERERBylUi4iIiIg4SKFaRERERMRBCtUiIiIiIg5SqBYRERERcZBCtYiIiIiIgxSqRUREREQcpFAtIiIiIuIghWoREREREQcpVIuIiIiIOEihWkRERETEQW61PQARqbsG//WftT0EERERuzJm3XdT+9NKtYiIiIiIgxSqRUREREQcpFAtIiIiIuIghWoREREREQcpVN/C4uPjycnJqe1hMGvWLPbs2fOHX3PFW2+9RXl5ebWv5+bmsnv37hq1fTMkJCRgtVqrfb1Pnz5VjlksFj744AM+/fRTEhISAHjiiScAOHr0KPv37/9jBisiInKLUKiWW87KlSuprKys9vV9+/bxxRdf3MQR/T5LlizBw8Pjd10zbNgwoqKirjr28ssvA7Bz506ys7Nv2PhERERuRfpKvVtEUVERc+bM4dKlSxQWFhIXFwfAsmXLKCwsxMPDg4ULF3L8+HFee+013N3dOX36NDExMTz22GOcPn2aOXPmUFFRgclkYu7cuXTo0IH+/fsTEhJCSEgIly5dws3NjdzcXKxWKzExMXz44YecPXuW9PR0WrVqxbx58zh37hyFhYXcc889TJs27TfHvmHDBrZu3YqLiwsREREkJiYCP684r169mqKiIpKTkwkLCyMjI4P33nsPNzc3IiMjmTlzJsuXLyczM5OSkhIGDx5Mfn4+CQkJpKenV+nr8uXLrFq1itLSUrp160ZQUBApKSkA+Pj4kJaWxqFDh1i8eDHu7u6MHDmSNWvWEBkZybFjxwgODqZZs2YcOHAADw8PVq1ahbu7e5V+jhw5QlpaGq+//joAjz76KFOnTuW7775jw4YNtvOWLl3K8ePHr+pv2bJlbN++nZMnT/L8889TWVnJjz/+yNy5c4mIiMBqtZKQkMDZs2e54447SE5O5uWXX8bPz4+QkBBb23369MFisbBlyxbc3d3p3LkzzzzzDJs3bwZg2rRpTJgwgbCwsOv9ayYiInLLUqi+RZw8eZJBgwbxwAMPcP78eeLj4wkICOCBBx5g0KBBbNiwgZUrV3LfffeRm5vLO++8g9VqpW/fvjz22GMsXLiQ+Ph4BgwYwOHDh5k9ezYWi4WzZ89isVjw9fVl1qxZtGrVipSUFObNm8fp06d57bXXWLZsGbt372bAgAGEh4cTFxdHWVnZdYdqi8VCUlIS4eHhvPnmm1RUVADQuXNnHn/8cSwWCxaLhQYNGrB9+3Y2btyIm5sbTz75JB9++CEAISEhzJ07F4A1a9awZMkSu325uroyadIkTpw4QVRUFCNHjiQtLY127dqxadMmVq9eTe/evSkrK2PTpk3Az7+YPPTQQ3Tv3p3o6GiefvppEhISePjhh8nOzqZjx45V+unQoQNlZWWcOXMGd3d3CgsL6dSpE3v27GHVqlU0atSIefPm8cknnxAQEFClP4Ds7GwSExO544472LZtGxaLhYiICEpLS5kxYwatWrVi6tSp19zKEhAQwNChQ/Hz8yMsLIyGDRuSnZ2Nn58fp0+fVqAWEZE6y9+/yU3tT6H6FuHn58e6devYuXMnXl5etmAaGRkJQEREBB9//DEAoaGhuLm54ebmRsOGDQHIycmhR48eAHTs2JFz584B4Ovri6+vr62fTp06AeDt7W1bFfX29sZqteLj48PBgwfZt28fXl5e19wX/EvPPfccGRkZLF68mPDwcAzDAH4O1VdqKy0t5cSJE3Tt2tW2MhwZGcnx48cBCA4OrsltIycnh/nz5wNQXl5ua+fX7V0Zi7e3N2az2fbnsrKyatseMWIEW7duxcPDg2HDhgHQrFkzEhMT8fT05MSJE4SHh1c7/ubNm5Oenk7Dhg0pLi7Gy8sLgJYtW9KqVSsAunXrxjfffHPd9cbFxWGxWGjZsiVDhgy57utEREScTX7+pT+k3erCuvZU3yIyMjIIDw9n8eLFREdH24LpwYMHAThw4ADt27cHwGQyVbnebDZz4MABAA4fPoyfnx8ALi5X/xWyd+0VFouFJk2a8MILLzBhwgRKS0tt47iWt99+m/nz5/PGG29w+PBhMjMz7fYVEhJCVlYWFRUVGIbB/v37bWH0l+M0mUzX3FPt4uJiez04OJgFCxawfv16Zs6cSb9+/X533dWJiYnho48+4v333+ehhx7i0qVLLFu2jCVLlpCSkkKDBg1s9+fX/QGkpqYyZcoUFixYQGhoqO3cc+fOkZeXB8AXX3xhe67V+eX9iI6OZu/evbz//vsK1SIiIr+DVqpvEf379yc5OZlt27bh4+ODq6srVquVXbt2sW7dOjw9PVmwYAFHjhyxe/1TTz1FUlISGRkZVFRUkJqa+rvH0KtXL6ZPn87nn39Oo0aNaNOmjS38Xcsdd9zBiBEj8PX1JSAggK5du2KxWOyeN3DgQEaPHk1lZSXdu3dnwIABVWqKjIxk0qRJvP7663bDcGhoKK+88gqdO3cmOTmZxMRELl++DPwcZK9nzNfD09OTDh06UFFRgZeXF4ZhEBERwdChQ2ncuDHe3t7k5eURFBRk9/ohQ4bw+OOP06xZM1q0aEFhYSHw897vlJQUzp8/T7du3ejXrx9ZWVnVjqNLly4sXLgQs9lMz5496dGjBwUFBfj4+NyQOkVERG4FJuN6lgpF5JaRnJzMgw8+SK9evX7z3MF//edNGJGIiMjvlzHrvj+k3eq2f2ilWpxCbm6u7Vs9fqlHjx5MmTLlhvdntVqZOHFilePBwcE888wzN6yfrKwsFi1aVOX4wIEDGTNmzA3r50aZMGECzZs3v65ALSIiIv+jlWoRqTGtVIuIiLO62SvVCtUi4pA/6tPVtcHfv4nqcVL1qRZQPc6uPtVTn2oB56hH3/4hIiIiIvIHUagWEREREXGQQrWIiIiIiIMUqkVEREREHKRQLSIiIiLiIIVqEREREREHKVSLiIiIiDhI31MtIiIiIuIgrVSLiIiIiDhIoVpERERExEEK1SIiIiIiDlKoFhERERFxkEK1iIiIiIiDFKpFRERERBzkVtsDEBHnUVlZSXJyMkePHsXDw4OUlBTatGlje3337t2sWLECNzc3hg8fzsiRI6u95uTJk8yaNQuTyUT79u3529/+hovLzf09vib1lJeXM3v2bM6cOYPVauWxxx4jKiqKr7/+msmTJ9O2bVsARo8eTUxMjFPXAvCnP/2JJk2aABAUFMRzzz1XZ5+NxWJhy5YtAJSVlXH48GH27t3LqVOnavXZXE89AD/99BOPPPIIqampmM3mOj137NVTV+eOvVqg7s4de/XU5bnz7rvvsm7dOlxdXQkNDSU5ORnAOeeOISLy//71r38ZiYmJhmEYRmZmpjF58mTba1ar1RgwYIBx8eJFo6yszBg2bJiRl5dX7TWPPvqosW/fPsMwDCMpKcnYuXPnTa6mZvVs3rzZSElJMQzDMAoKCox+/foZhmEYb7/9trFmzZqbXsMVNamltLTUiI2NrdJWXX02v5ScnGxs3LjRMIzafzaGce16DMMwsrKyjKFDhxq9e/c2srOzr3mNsz8fw7BfT12cO4Zhv5a6OncMw349v1SX5s5PP/1kREVFGSUlJYZhGEZCQoKxa9cup5072v4hIjaff/45ffv2BSA8PJyvvvrK9lpOTg6tW7emadOmeHh40L17dw4cOFDtNV9//TV33XUXAPfccw///ve/b3I1NasnOjqaqVOn2s5zdXUF4KuvvuKjjz5i7NixzJ49m6KiIqev5ciRI/z0009MmDCBcePG8eWXXwJ199lccfDgQbKzsxk1ahRQ+88Grl0PgNVqZcWKFYSEhPzmNc7+fMB+PXVx7oD9Wurq3AH79VxR1+aOh4cHGzdupFGjRgBUVFTQoEEDp507CtUiYlNUVISXl5ftZ1dXVyoqKmyvXXkrFMDT05OioqJqrzEMA5PJZDv30qVLN6mK/6lJPZ6ennh5eVFUVMSUKVOYNm0aAGFhYTz11FNs2LCB22+/nRUrVjh9LQ0bNmTixImsWbOG+fPnM2PGjDr9bK5YuXIlf/nLX2w/1/azgWvXA9C9e3cCAwOv6xpnfz5gv566OHfAfi11de6A/XquqGtzx8XFBT8/PwDWr19PSUkJffr0cdq5o1AtIjZeXl4UFxfbfq6srMTNzc3ua8XFxTRp0qTaa365j624uBhvb++bUMHValIPwNmzZxk3bhyxsbEMHjwYgPvvv58uXbrY/nzo0KGbVYbd8V5PLcHBwQwZMgSTyURwcDA+Pj7k5+fX6Wfz448/cuLECXr27Gl7vbafDVy7nt97jbM/n2upa3OnOnV17lxLXZ07lZWVLFiwgL1797J8+XJMJpPTzh2FahGxiYiIYM+ePQB8+eWXhIaG2l4zm82cPHmSixcvYrVaOXDgAN26dav2mk6dOvHpp58CsGfPHiIjI29yNTWr58KFC0yYMIGZM2cyYsQI2/kTJ04kKysLgP/85z907tzZ6WvZvHkzzz//PADnz5+nqKgIf3//OvtsAPbv30/v3r2vaqu2nw1cu57fe42zP5/q1MW5U526Oneupa7OnXnz5lFWVkZ6erptG4izzh2TYRjGTe1RRJzWlU9hHzt2DMMwSEtL49ChQ5SUlDBq1CjbNzIYhsHw4cMZO3as3WvMZjPffPMNSUlJlJeXExISQkpKim2PpTPXk5KSwvbt26/aj/jaa6+Rk5PDs88+i7u7O35+fjz77LNXvf3ojLVYrVaefvppcnNzMZlMzJgxg4iIiDr7bABWr16Nm5sb48ePt7X19ddf1+qzuZ56roiPjyc5Ofmqb/+oi3PHXj11de7Yq6Uuzx179UDdnDtdunRh+PDhREZG2rZ1jBs3jqioKKecOwrVIiIiIiIO0vYPEREREREHKVSLiIiIiDhIoVpERERExEEK1SIiIiIiDlKoFhERERFxkEK1iIiIiIiDFKpFRERERBykUC0iIiIi4qD/AxG4LVYgSO7IAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt = pd.Series(rfc.feature_importances_, index=X.columns).nlargest(10).plot(kind='barh')\n",
    "plt.set_title('Feature Importance')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Findings:</b>\n",
    "\n",
    "As we predicted, GridSearchCV didn't give us the best `max_features` for precision. We are not sure why this happens, so we always try changing it slightly to see what the result would look like. We changed `max_depth=10` to `max_depth=9` and the metric precision improved.\n",
    "\n",
    "However, we are trying to decrease False Positives. GridSearchCV with Random Forest gave us the lowest False Positives.\n",
    "\n",
    "Finally, we will use XGBoost to see if we can improve our Random Tree model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### XGBoost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, our last try to improve our model will be XGBoost, which uses Gradient Descent and Boosting principles. We believe there might have space for improvement. First, we will use the default hyperparameters. Then, we will use XGBoost with GridSearch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.943609022556391\n",
      "Recall: 0.9657701711491442\n",
      "F1 Score: 0.9634146341463415\n",
      "Precision: 0.9610705596107056\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[395  14  16 107]\n"
     ]
    }
   ],
   "source": [
    "# Instantiate XGBClassifier\n",
    "xgb = XGBClassifier()\n",
    "\n",
    "# Fitting and predicting\n",
    "xgb.fit(X_train_smote, y_train_smote)\n",
    "y_pred_xg = xgb.predict(X_test)\n",
    "\n",
    "# Evaluation Metrics\n",
    "evaluation(y_test, y_pred_xg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Findings:</b>\n",
    "\n",
    "XGBoost performed using only the default parameters. It did not perform better than Random Forest using Grid Search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#parameter grid for xgboost\n",
    "param_dist = {'n_estimators': [500,1000,1500],\n",
    "              'learning_rate': [0.1,0.07,0.05,0.03,0.01],\n",
    "              'max_depth': [9,10,11,12,13],\n",
    "              'colsample_bytree': [0.5,0.45,0.4],\n",
    "              'min_child_weight': [1, 2, 3]\n",
    "             }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "#gridsearch for xgboost\n",
    "grid_xg = GridSearchCV(estimator=xgb,\n",
    "                      param_grid= param_dist,\n",
    "                      scoring='f1',\n",
    "                      n_jobs=-1,\n",
    "                      verbose=1,\n",
    "                      iid=False,\n",
    "                      cv=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 10 folds for each of 675 candidates, totalling 6750 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  34 tasks      | elapsed:   21.4s\n",
      "[Parallel(n_jobs=-1)]: Done 184 tasks      | elapsed:  1.8min\n",
      "[Parallel(n_jobs=-1)]: Done 434 tasks      | elapsed:  4.3min\n",
      "[Parallel(n_jobs=-1)]: Done 784 tasks      | elapsed:  8.1min\n",
      "[Parallel(n_jobs=-1)]: Done 1234 tasks      | elapsed: 13.0min\n",
      "[Parallel(n_jobs=-1)]: Done 1784 tasks      | elapsed: 19.8min\n",
      "[Parallel(n_jobs=-1)]: Done 2434 tasks      | elapsed: 28.8min\n",
      "[Parallel(n_jobs=-1)]: Done 3184 tasks      | elapsed: 36.0min\n",
      "[Parallel(n_jobs=-1)]: Done 4034 tasks      | elapsed: 46.1min\n",
      "[Parallel(n_jobs=-1)]: Done 4984 tasks      | elapsed: 58.1min\n",
      "[Parallel(n_jobs=-1)]: Done 6034 tasks      | elapsed: 68.5min\n",
      "[Parallel(n_jobs=-1)]: Done 6750 out of 6750 | elapsed: 77.4min finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=10, error_score=nan,\n",
       "             estimator=XGBClassifier(base_score=0.5, booster='gbtree',\n",
       "                                     colsample_bylevel=1, colsample_bynode=1,\n",
       "                                     colsample_bytree=1, gamma=0,\n",
       "                                     learning_rate=0.1, max_delta_step=0,\n",
       "                                     max_depth=3, min_child_weight=1,\n",
       "                                     missing=None, n_estimators=100, n_jobs=1,\n",
       "                                     nthread=None, objective='binary:logistic',\n",
       "                                     random_state=0, reg_alpha=0, reg_lambda=1,\n",
       "                                     scale_pos_weight=1, seed=None, silent=None,\n",
       "                                     subsample=1, verbosity=1),\n",
       "             iid=False, n_jobs=-1,\n",
       "             param_grid={'colsample_bytree': [0.5, 0.45, 0.4],\n",
       "                         'learning_rate': [0.1, 0.07, 0.05, 0.03, 0.01],\n",
       "                         'max_depth': [9, 10, 11, 12, 13],\n",
       "                         'min_child_weight': [1, 2, 3],\n",
       "                         'n_estimators': [500, 1000, 1500]},\n",
       "             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,\n",
       "             scoring='f1', verbose=1)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#fit grid search xgboost to train set\n",
    "grid_xg.fit(X_train_smote,y_train_smote)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "#xgboost best estimator test set predictions\n",
    "y_pred = grid_xg.best_estimator_.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics:\n",
      "Accuracy: 0.956766917293233\n",
      "Recall: 0.9828850855745721\n",
      "F1 Score: 0.9721886336154776\n",
      "Precision: 0.9617224880382775\n",
      "\n",
      "Confusion Matrix:\n",
      " TN,  FP, FN, TP\n",
      "[402   7  16 107]\n"
     ]
    }
   ],
   "source": [
    "evaluation(y_test,y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa8040f2b38>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot feature importance of best estimator grid xgboost\n",
    "plot_importance(grid_xg.best_estimator_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa8035ff1d0>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot top ten key features\n",
    "plot_importance(grid_xg.best_estimator_,max_num_features=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vanilla modeling results\n",
    "- For the vanilla dataset, the best model overall was our grid search best parameter random forest.  This model had the best precision score of any model we ran in this analysis. Key features for the vanilla model where abnormal_short term variatability, acceleration, mean abnormal short term varitability and histogram mean.\n",
    "\n",
    "- for comparison to the experimental datset follow this link\n",
    "[experimental modeling process](.experimental_feature_Modeling.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}