Wildfire Prediction with Balanced Class Weight.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd, numpy as np, os\n",
    "from sklearn.svm import SVC, LinearSVC\n",
    "from sklearn.model_selection import cross_val_score, validation_curve, train_test_split, GridSearchCV \n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler\n",
    "from sklearn.experimental import enable_hist_gradient_boosting\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.ensemble import BaggingClassifier, GradientBoostingClassifier, RandomForestClassifier, ExtraTreesClassifier, AdaBoostClassifier,HistGradientBoostingClassifier\n",
    "import xgboost as xgb\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from rgf.sklearn import RGFClassifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import wildfire data set \n",
    "df = pd.read_csv(\"WildFires_DataSet.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A description of the above dataset can be found here: \n",
    "https://github.com/ouladsayadyounes/Wildfires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>NDVI</th>\n",
       "      <th>LST</th>\n",
       "      <th>BURNED_AREA</th>\n",
       "      <th>CLASS</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.506782</td>\n",
       "      <td>14584.272727</td>\n",
       "      <td>4.692308</td>\n",
       "      <td>no_fire</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.522150</td>\n",
       "      <td>14655.833333</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>no_fire</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.682284</td>\n",
       "      <td>14780.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>fire</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.120046</td>\n",
       "      <td>13298.500000</td>\n",
       "      <td>3.500000</td>\n",
       "      <td>no_fire</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.568734</td>\n",
       "      <td>14743.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>no_fire</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       NDVI           LST  BURNED_AREA    CLASS\n",
       "0  0.506782  14584.272727     4.692308  no_fire\n",
       "1  0.522150  14655.833333     5.000000  no_fire\n",
       "2  0.682284  14780.000000     5.000000     fire\n",
       "3  0.120046  13298.500000     3.500000  no_fire\n",
       "4  0.568734  14743.000000     5.000000  no_fire"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#snapshot of the data\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>NDVI</th>\n",
       "      <th>LST</th>\n",
       "      <th>BURNED_AREA</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>1713.000000</td>\n",
       "      <td>1713.000000</td>\n",
       "      <td>1713.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.555665</td>\n",
       "      <td>14622.802073</td>\n",
       "      <td>4.674973</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.092847</td>\n",
       "      <td>366.927861</td>\n",
       "      <td>0.583791</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.030735</td>\n",
       "      <td>13137.000000</td>\n",
       "      <td>3.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.501276</td>\n",
       "      <td>14406.000000</td>\n",
       "      <td>4.521951</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.565181</td>\n",
       "      <td>14645.750000</td>\n",
       "      <td>4.920635</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>0.620987</td>\n",
       "      <td>14881.300000</td>\n",
       "      <td>5.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>0.781723</td>\n",
       "      <td>15611.570513</td>\n",
       "      <td>9.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              NDVI           LST  BURNED_AREA\n",
       "count  1713.000000   1713.000000  1713.000000\n",
       "mean      0.555665  14622.802073     4.674973\n",
       "std       0.092847    366.927861     0.583791\n",
       "min       0.030735  13137.000000     3.000000\n",
       "25%       0.501276  14406.000000     4.521951\n",
       "50%       0.565181  14645.750000     4.920635\n",
       "75%       0.620987  14881.300000     5.000000\n",
       "max       0.781723  15611.570513     9.000000"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input/features\n",
    "X = df[[\"NDVI\", \"LST\", \"BURNED_AREA\"]]\n",
    "\n",
    "#output\n",
    "y = df[\"CLASS\"]\n",
    "\n",
    "#replace the categories with numerical values\n",
    "y.replace({\"no_fire\":0, \"fire\":1}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train Test split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30, random_state = 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Scaler\n",
    "scaler = StandardScaler()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM WITH BALANCED CLASS WEIGHT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 50 candidates, totalling 250 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  64 tasks      | elapsed:    1.1s\n",
      "[Parallel(n_jobs=-1)]: Done 187 out of 250 | elapsed:    2.5s remaining:    0.8s\n",
      "[Parallel(n_jobs=-1)]: Done 250 out of 250 | elapsed:    3.4s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 199.52623149688787, 'gamma': 2.0, 'kernel': 'rbf'}\n",
      "SVC(C=199.52623149688787, break_ties=False, cache_size=200,\n",
      "    class_weight='balanced', coef0=0.0, decision_function_shape='ovr', degree=3,\n",
      "    gamma=2.0, kernel='rbf', max_iter=-1, probability=False, random_state=5,\n",
      "    shrinking=True, tol=0.001, verbose=False)\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.85      0.70      0.77       391\n",
      "           1       0.39      0.59      0.47       123\n",
      "\n",
      "    accuracy                           0.68       514\n",
      "   macro avg       0.62      0.65      0.62       514\n",
      "weighted avg       0.74      0.68      0.70       514\n",
      "\n",
      "[[275 116]\n",
      " [ 50  73]]\n"
     ]
    }
   ],
   "source": [
    "#### GRID SEARCH ON SVM \n",
    "clf = SVC(random_state=5, class_weight='balanced')\n",
    "# defining parameter range \n",
    "param_grid = {'C': np.logspace(1, 2.3, 10),  \n",
    "              'gamma': np.linspace(0.01,2, 5), \n",
    "              'kernel': ['rbf']}  \n",
    "  \n",
    "grid = GridSearchCV(clf, param_grid, refit = True, cv = 5, verbose = 3,\n",
    "                    error_score=0,\n",
    "                    n_jobs=-1) \n",
    "  \n",
    "# fitting the model for grid search \n",
    "grid.fit(scaler.fit_transform(X_train), y_train) \n",
    "\n",
    "#### Best Grid search parameter fitting\n",
    "\n",
    "# print best parameter after tuning \n",
    "print(grid.best_params_) \n",
    "  \n",
    "# print how our model looks after hyper-parameter tuning \n",
    "print(grid.best_estimator_) \n",
    "\n",
    "grid_predictions = grid.predict(scaler.transform(X_test)) \n",
    "  \n",
    "# print classification report \n",
    "print(classification_report(y_test, grid_predictions)) \n",
    "print(confusion_matrix(y_test, grid_predictions)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.681 (+/- 0.01)\n"
     ]
    }
   ],
   "source": [
    "#### Cross val score\n",
    "scores_SVM = cross_val_score(grid.best_estimator_, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation \n",
    "print(\"Accuracy: %0.3f (+/- %0.2f)\" % (scores_SVM.mean(), scores_SVM.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### BAGGING CLASSIFER (Built on SVM with Balanced Class Weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 100 candidates, totalling 500 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  64 tasks      | elapsed:   27.3s\n",
      "[Parallel(n_jobs=-1)]: Done 224 tasks      | elapsed:   34.0s\n",
      "[Parallel(n_jobs=-1)]: Done 500 out of 500 | elapsed:   36.3s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'max_features': 3, 'n_estimators': 10}\n",
      "BaggingClassifier(base_estimator=SVC(C=199.52623149688787, break_ties=False,\n",
      "                                     cache_size=200, class_weight='balanced',\n",
      "                                     coef0=0.0, decision_function_shape='ovr',\n",
      "                                     degree=3, gamma=2.0, kernel='rbf',\n",
      "                                     max_iter=-1, probability=False,\n",
      "                                     random_state=5, shrinking=True, tol=0.001,\n",
      "                                     verbose=False),\n",
      "                  bootstrap=True, bootstrap_features=False, max_features=3,\n",
      "                  max_samples=1.0, n_estimators=10, n_jobs=-1, oob_score=False,\n",
      "                  random_state=5, verbose=0, warm_start=False)\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.85      0.78      0.81       391\n",
      "           1       0.44      0.55      0.49       123\n",
      "\n",
      "    accuracy                           0.73       514\n",
      "   macro avg       0.65      0.67      0.65       514\n",
      "weighted avg       0.75      0.73      0.74       514\n",
      "\n",
      "[[306  85]\n",
      " [ 55  68]]\n"
     ]
    }
   ],
   "source": [
    "#grid search for bagging classifier using the SVM classifer obtained above \n",
    "\n",
    "bag = BaggingClassifier(grid.best_estimator_, n_jobs=-1, random_state=5)\n",
    "\n",
    "param_grid = {'n_estimators': list(range(0, 110, 10))[1:],  'max_features': list (range(1,21, 2))}  \n",
    "\n",
    "grid = GridSearchCV(bag, param_grid, refit = True, cv = 5, verbose = 3,\n",
    "                    error_score=0,\n",
    "                    n_jobs=-1) \n",
    "  \n",
    "# fitting the model for grid search \n",
    "grid.fit(scaler.fit_transform(X_train), y_train) \n",
    "\n",
    "#### Best Grid search parameter fitting\n",
    "\n",
    "# print best parameter after tuning \n",
    "print(grid.best_params_) \n",
    "  \n",
    "# print how our model looks after hyper-parameter tuning \n",
    "print(grid.best_estimator_) \n",
    "\n",
    "grid_predictions = grid.predict(scaler.transform(X_test)) \n",
    "  \n",
    "# print classification report \n",
    "print(classification_report(y_test, grid_predictions)) \n",
    "print(confusion_matrix(y_test, grid_predictions)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7268 (+/- 0.0206)\n"
     ]
    }
   ],
   "source": [
    "#bagging classifier (SVM)\n",
    "scores_BAG = cross_val_score(grid.best_estimator_, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation\n",
    "print(\"Accuracy: %0.4f (+/- %0.4f)\" % (scores_BAG.mean(), scores_BAG.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### EXTRA TREES CLASSIFIER WITH BALANCED CLASS WEIGHT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1000 candidates, totalling 5000 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  64 tasks      | elapsed:    6.2s\n",
      "[Parallel(n_jobs=-1)]: Done 224 tasks      | elapsed:    8.3s\n",
      "[Parallel(n_jobs=-1)]: Done 448 tasks      | elapsed:   11.4s\n",
      "[Parallel(n_jobs=-1)]: Done 736 tasks      | elapsed:   15.7s\n",
      "[Parallel(n_jobs=-1)]: Done 1088 tasks      | elapsed:   20.9s\n",
      "[Parallel(n_jobs=-1)]: Done 1504 tasks      | elapsed:   26.6s\n",
      "[Parallel(n_jobs=-1)]: Done 1984 tasks      | elapsed:   33.7s\n",
      "[Parallel(n_jobs=-1)]: Done 2528 tasks      | elapsed:   40.4s\n",
      "[Parallel(n_jobs=-1)]: Done 3136 tasks      | elapsed:   46.0s\n",
      "[Parallel(n_jobs=-1)]: Done 3808 tasks      | elapsed:   52.4s\n",
      "[Parallel(n_jobs=-1)]: Done 4544 tasks      | elapsed:   59.6s\n",
      "[Parallel(n_jobs=-1)]: Done 5000 out of 5000 | elapsed:  1.1min finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'max_depth': 17, 'max_features': 1, 'n_estimators': 50}\n",
      "ExtraTreesClassifier(bootstrap=False, ccp_alpha=0.0, class_weight='balanced',\n",
      "                     criterion='gini', max_depth=17, max_features=1,\n",
      "                     max_leaf_nodes=None, max_samples=None,\n",
      "                     min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "                     min_samples_leaf=1, min_samples_split=2,\n",
      "                     min_weight_fraction_leaf=0.0, n_estimators=50, n_jobs=-1,\n",
      "                     oob_score=False, random_state=5, verbose=0,\n",
      "                     warm_start=False)\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.84      0.90      0.87       391\n",
      "           1       0.58      0.46      0.51       123\n",
      "\n",
      "    accuracy                           0.79       514\n",
      "   macro avg       0.71      0.68      0.69       514\n",
      "weighted avg       0.78      0.79      0.78       514\n",
      "\n",
      "[[350  41]\n",
      " [ 67  56]]\n"
     ]
    }
   ],
   "source": [
    "#### GRID SEARCH for extra trees classifier \n",
    "\n",
    "ext = ExtraTreesClassifier(n_jobs=-1, random_state=5, class_weight='balanced')\n",
    "# defining parameter range \n",
    "param_grid = {'n_estimators': list(range(0, 110, 10))[1:],  'max_features': list (range(1,21, 2)), 'max_depth' :list(range(1,21, 2))}  \n",
    "  \n",
    "\n",
    "grid = GridSearchCV(ext, param_grid, refit = True, cv = 5, verbose = 3,\n",
    "                    error_score=0,\n",
    "                    n_jobs=-1) \n",
    "  \n",
    "# fitting the model for grid search \n",
    "grid.fit(scaler.fit_transform(X_train), y_train) \n",
    "\n",
    "#### Best Grid search parameter fitting\n",
    "\n",
    "# print best parameter after tuning \n",
    "print(grid.best_params_) \n",
    "  \n",
    "# print how our model looks after hyper-parameter tuning \n",
    "print(grid.best_estimator_) \n",
    "\n",
    "grid_predictions = grid.predict(scaler.transform(X_test)) \n",
    "  \n",
    "# print classification report \n",
    "print(classification_report(y_test, grid_predictions)) \n",
    "print(confusion_matrix(y_test, grid_predictions)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8190 (+/- 0.0273)\n"
     ]
    }
   ],
   "source": [
    "#Accuracy for extra trees classifier \n",
    "scores_EXT = cross_val_score(grid.best_estimator_, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation \n",
    "print(\"Accuracy: %0.4f (+/- %0.4f)\" % (scores_EXT.mean(), scores_EXT.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ADABOOST CLASSIFIER WITH BALANCED CLASS WEIGHT "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 50 candidates, totalling 250 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  64 tasks      | elapsed:    3.0s\n",
      "[Parallel(n_jobs=-1)]: Done 250 out of 250 | elapsed:    4.6s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'learning_rate': 1, 'n_estimators': 100}\n",
      "AdaBoostClassifier(algorithm='SAMME.R',\n",
      "                   base_estimator=DecisionTreeClassifier(ccp_alpha=0.0,\n",
      "                                                         class_weight='balanced',\n",
      "                                                         criterion='gini',\n",
      "                                                         max_depth=1,\n",
      "                                                         max_features=None,\n",
      "                                                         max_leaf_nodes=None,\n",
      "                                                         min_impurity_decrease=0.0,\n",
      "                                                         min_impurity_split=None,\n",
      "                                                         min_samples_leaf=1,\n",
      "                                                         min_samples_split=2,\n",
      "                                                         min_weight_fraction_leaf=0.0,\n",
      "                                                         presort='deprecated',\n",
      "                                                         random_state=None,\n",
      "                                                         splitter='best'),\n",
      "                   learning_rate=1, n_estimators=100, random_state=5)\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.84      0.72      0.77       391\n",
      "           1       0.39      0.57      0.46       123\n",
      "\n",
      "    accuracy                           0.68       514\n",
      "   macro avg       0.61      0.64      0.62       514\n",
      "weighted avg       0.73      0.68      0.70       514\n",
      "\n",
      "[[280 111]\n",
      " [ 53  70]]\n"
     ]
    }
   ],
   "source": [
    "#### GRID SEARCH for Ada bosst classifier \n",
    "\n",
    "adb = AdaBoostClassifier(base_estimator=DecisionTreeClassifier(max_depth=1, class_weight='balanced'), random_state=5)\n",
    "# defining parameter range \n",
    "param_grid = {'n_estimators': list(range(0, 110, 10))[1:],  'learning_rate': [0.2, 0.4, 0.6, 0.8, 1]}  \n",
    "  \n",
    "\n",
    "grid = GridSearchCV(adb, param_grid, refit = True, cv = 5, verbose = 3,\n",
    "                    error_score=0,\n",
    "                    n_jobs=-1) \n",
    "  \n",
    "# fitting the model for grid search \n",
    "grid.fit(scaler.fit_transform(X_train), y_train) \n",
    "\n",
    "#### Best Grid search parameter fitting\n",
    "\n",
    "# print best parameter after tuning \n",
    "print(grid.best_params_) \n",
    "  \n",
    "# print how our model looks after hyper-parameter tuning \n",
    "print(grid.best_estimator_) \n",
    "\n",
    "grid_predictions = grid.predict(scaler.transform(X_test)) \n",
    "  \n",
    "# print classification report \n",
    "print(classification_report(y_test, grid_predictions)) \n",
    "print(confusion_matrix(y_test, grid_predictions)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6894 (+/- 0.0485)\n"
     ]
    }
   ],
   "source": [
    "#Adaboost classifier \n",
    "scores_ADB = cross_val_score(grid.best_estimator_, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation\n",
    "print(\"Accuracy: %0.4f (+/- %0.4f)\" % (scores_ADB.mean(), scores_ADB.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GRADIENT BOOSTING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1000 candidates, totalling 5000 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  64 tasks      | elapsed:    0.4s\n",
      "[Parallel(n_jobs=-1)]: Done 384 tasks      | elapsed:    1.2s\n",
      "[Parallel(n_jobs=-1)]: Done 832 tasks      | elapsed:    2.3s\n",
      "[Parallel(n_jobs=-1)]: Done 1984 tasks      | elapsed:    5.0s\n",
      "[Parallel(n_jobs=-1)]: Done 3027 tasks      | elapsed:   10.8s\n",
      "[Parallel(n_jobs=-1)]: Done 3656 tasks      | elapsed:   13.8s\n",
      "[Parallel(n_jobs=-1)]: Done 4410 tasks      | elapsed:   19.4s\n",
      "[Parallel(n_jobs=-1)]: Done 4937 out of 5000 | elapsed:   22.9s remaining:    0.3s\n",
      "[Parallel(n_jobs=-1)]: Done 5000 out of 5000 | elapsed:   24.1s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'max_depth': 15, 'max_features': 1, 'n_estimators': 90}\n",
      "GradientBoostingClassifier(ccp_alpha=0.0, criterion='friedman_mse', init=None,\n",
      "                           learning_rate=0.1, loss='deviance', max_depth=15,\n",
      "                           max_features=1, max_leaf_nodes=None,\n",
      "                           min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "                           min_samples_leaf=1, min_samples_split=2,\n",
      "                           min_weight_fraction_leaf=0.0, n_estimators=90,\n",
      "                           n_iter_no_change=None, presort='deprecated',\n",
      "                           random_state=5, subsample=0.289, tol=0.0001,\n",
      "                           validation_fraction=0.1, verbose=0,\n",
      "                           warm_start=False)\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.83      0.95      0.89       391\n",
      "           1       0.72      0.37      0.49       123\n",
      "\n",
      "    accuracy                           0.82       514\n",
      "   macro avg       0.77      0.66      0.69       514\n",
      "weighted avg       0.80      0.82      0.79       514\n",
      "\n",
      "[[373  18]\n",
      " [ 77  46]]\n"
     ]
    }
   ],
   "source": [
    "#Gradient Boosting \n",
    "gb_clf2 = GradientBoostingClassifier( subsample=0.289, random_state=5)\n",
    "# defining parameter range \n",
    "param_grid = {'n_estimators': list(range(0, 110, 10))[1:],  'max_features': list (range(1,21, 2)), 'max_depth' :list(range(1,21, 2))}  \n",
    "  \n",
    "\n",
    "grid = GridSearchCV(gb_clf2, param_grid, refit = True, cv = 5, verbose = 3,\n",
    "                    error_score=0,\n",
    "                    n_jobs=-1) \n",
    "  \n",
    "# fitting the model for grid search \n",
    "grid.fit(scaler.fit_transform(X_train), y_train) \n",
    "\n",
    "#### Best Grid search parameter fitting\n",
    "\n",
    "# print best parameter after tuning \n",
    "print(grid.best_params_) \n",
    "  \n",
    "# print how our model looks after hyper-parameter tuning \n",
    "print(grid.best_estimator_) \n",
    "\n",
    "grid_predictions = grid.predict(scaler.transform(X_test)) \n",
    "  \n",
    "# print classification report \n",
    "print(classification_report(y_test, grid_predictions)) \n",
    "print(confusion_matrix(y_test, grid_predictions)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8447 (+/- 0.0292)\n"
     ]
    }
   ],
   "source": [
    "#Gradient boosting classfier \n",
    "scores_GB = cross_val_score(grid.best_estimator_, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation\n",
    "print(\"Accuracy: %0.4f (+/- %0.4f)\" % (scores_GB.mean(), scores_GB.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### XGBOOST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1000 candidates, totalling 5000 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  64 tasks      | elapsed:    3.2s\n",
      "[Parallel(n_jobs=-1)]: Done 224 tasks      | elapsed:    3.9s\n",
      "[Parallel(n_jobs=-1)]: Done 448 tasks      | elapsed:    5.0s\n",
      "[Parallel(n_jobs=-1)]: Done 736 tasks      | elapsed:    6.2s\n",
      "[Parallel(n_jobs=-1)]: Done 1408 tasks      | elapsed:    8.5s\n",
      "[Parallel(n_jobs=-1)]: Done 2240 tasks      | elapsed:   11.5s\n",
      "[Parallel(n_jobs=-1)]: Done 3200 tasks      | elapsed:   15.7s\n",
      "[Parallel(n_jobs=-1)]: Done 4288 tasks      | elapsed:   20.8s\n",
      "[Parallel(n_jobs=-1)]: Done 5000 out of 5000 | elapsed:   24.2s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'max_depth': 11, 'max_features': 1, 'n_estimators': 30}\n",
      "XGBClassifier(base_score=0.5, booster=None, colsample_bylevel=1,\n",
      "              colsample_bynode=1, colsample_bytree=1, gamma=0, gpu_id=-1,\n",
      "              importance_type='gain', interaction_constraints=None,\n",
      "              learning_rate=0.300000012, max_delta_step=0, max_depth=11,\n",
      "              max_features=1, min_child_weight=1, missing=nan,\n",
      "              monotone_constraints=None, n_estimators=30, n_jobs=0,\n",
      "              num_parallel_tree=1, objective='binary:logistic', random_state=5,\n",
      "              reg_alpha=0, reg_lambda=1, scale_pos_weight=1, subsample=1,\n",
      "              tree_method=None, validate_parameters=False, verbosity=None)\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.82      0.91      0.87       391\n",
      "           1       0.57      0.37      0.45       123\n",
      "\n",
      "    accuracy                           0.78       514\n",
      "   macro avg       0.70      0.64      0.66       514\n",
      "weighted avg       0.76      0.78      0.77       514\n",
      "\n",
      "[[357  34]\n",
      " [ 77  46]]\n"
     ]
    }
   ],
   "source": [
    "xg_clf = xgb.XGBClassifier(random_state=5)\n",
    "\n",
    "param_grid = {'n_estimators': list(range(0, 110, 10))[1:] ,  'max_features': list (range(1,21, 2)), 'max_depth':list(range(1,21, 2))}  \n",
    "  \n",
    "\n",
    "grid = GridSearchCV(xg_clf , param_grid, refit = True, cv = 5, verbose = 3,\n",
    "                    error_score=0,\n",
    "                    n_jobs=-1) \n",
    "  \n",
    "# fitting the model for grid search \n",
    "grid.fit(scaler.fit_transform(X_train), y_train) \n",
    "\n",
    "#### Best Grid search parameter fitting\n",
    "\n",
    "# print best parameter after tuning \n",
    "print(grid.best_params_) \n",
    "  \n",
    "# print how our model looks after hyper-parameter tuning \n",
    "print(grid.best_estimator_) \n",
    "\n",
    "grid_predictions = grid.predict(scaler.transform(X_test)) \n",
    "  \n",
    "# print classification report \n",
    "print(classification_report(y_test, grid_predictions)) \n",
    "print(confusion_matrix(y_test, grid_predictions)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8184 (+/- 0.0436)\n"
     ]
    }
   ],
   "source": [
    "#Extreme Gradient Boosting classifier \n",
    "scores_XGB = cross_val_score(grid.best_estimator_, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation\n",
    "print(\"Accuracy: %0.4f (+/- %0.4f)\" % (scores_XGB.mean(), scores_XGB.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### RANDOM FOREST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1000 candidates, totalling 5000 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  64 tasks      | elapsed:    2.7s\n",
      "[Parallel(n_jobs=-1)]: Done 224 tasks      | elapsed:    3.5s\n",
      "[Parallel(n_jobs=-1)]: Done 480 tasks      | elapsed:    4.7s\n",
      "[Parallel(n_jobs=-1)]: Done 1056 tasks      | elapsed:    6.7s\n",
      "[Parallel(n_jobs=-1)]: Done 1760 tasks      | elapsed:    8.9s\n",
      "[Parallel(n_jobs=-1)]: Done 2592 tasks      | elapsed:   11.9s\n",
      "[Parallel(n_jobs=-1)]: Done 3552 tasks      | elapsed:   15.2s\n",
      "[Parallel(n_jobs=-1)]: Done 4640 tasks      | elapsed:   19.1s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'max_depth': 16, 'max_features': 1, 'n_estimators': 40}\n",
      "RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n",
      "                       criterion='gini', max_depth=16, max_features=1,\n",
      "                       max_leaf_nodes=None, max_samples=None,\n",
      "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "                       min_samples_leaf=1, min_samples_split=2,\n",
      "                       min_weight_fraction_leaf=0.0, n_estimators=40,\n",
      "                       n_jobs=None, oob_score=False, random_state=5, verbose=0,\n",
      "                       warm_start=False)\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.83      0.94      0.88       391\n",
      "           1       0.69      0.40      0.51       123\n",
      "\n",
      "    accuracy                           0.81       514\n",
      "   macro avg       0.76      0.67      0.70       514\n",
      "weighted avg       0.80      0.81      0.79       514\n",
      "\n",
      "[[369  22]\n",
      " [ 74  49]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done 5000 out of 5000 | elapsed:   20.2s finished\n"
     ]
    }
   ],
   "source": [
    "#Random Forest\n",
    "\n",
    "rf_clf2 = RandomForestClassifier(random_state=5)\n",
    "\n",
    "\n",
    "param_grid = {'n_estimators': list(range(0, 110, 10))[1:], 'max_features': list (range(1,21, 2)), 'max_depth' :list(range(0,21, 2))[1:]}  \n",
    "  \n",
    "\n",
    "grid = GridSearchCV(rf_clf2 , param_grid, refit = True, cv = 5, verbose = 3,\n",
    "                    error_score=0,\n",
    "                    n_jobs=-1) \n",
    "  \n",
    "# fitting the model for grid search \n",
    "grid.fit(scaler.fit_transform(X_train), y_train) \n",
    "\n",
    "#### Best Grid search parameter fitting\n",
    "\n",
    "# print best parameter after tuning \n",
    "print(grid.best_params_) \n",
    "  \n",
    "# print how our model looks after hyper-parameter tuning \n",
    "print(grid.best_estimator_) \n",
    "\n",
    "grid_predictions = grid.predict(scaler.transform(X_test)) \n",
    "  \n",
    "# print classification report \n",
    "print(classification_report(y_test, grid_predictions)) \n",
    "print(confusion_matrix(y_test, grid_predictions)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8476 (+/- 0.0244)\n"
     ]
    }
   ],
   "source": [
    "#Random Forest classfier \n",
    "scores_RF = cross_val_score(grid.best_estimator_, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation\n",
    "print(\"Accuracy: %0.4f (+/- %0.4f)\" % (scores_RF.mean(), scores_RF.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SKLEARN NEURAL NET"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 10 candidates, totalling 50 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   4 out of  50 | elapsed:    0.5s remaining:    5.3s\n",
      "[Parallel(n_jobs=-1)]: Done  21 out of  50 | elapsed:    1.1s remaining:    1.5s\n",
      "[Parallel(n_jobs=-1)]: Done  38 out of  50 | elapsed:    1.3s remaining:    0.4s\n",
      "[Parallel(n_jobs=-1)]: Done  50 out of  50 | elapsed:    1.5s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'hidden_layer_sizes': 50}\n",
      "MLPClassifier(activation='relu', alpha=1, batch_size='auto', beta_1=0.9,\n",
      "              beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
      "              hidden_layer_sizes=50, learning_rate='constant',\n",
      "              learning_rate_init=0.001, max_fun=15000, max_iter=200,\n",
      "              momentum=0.9, n_iter_no_change=10, nesterovs_momentum=True,\n",
      "              power_t=0.5, random_state=5, shuffle=True, solver='adam',\n",
      "              tol=0.0001, validation_fraction=0.1, verbose=False,\n",
      "              warm_start=False)\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.77      0.98      0.86       391\n",
      "           1       0.53      0.07      0.13       123\n",
      "\n",
      "    accuracy                           0.76       514\n",
      "   macro avg       0.65      0.53      0.50       514\n",
      "weighted avg       0.71      0.76      0.69       514\n",
      "\n",
      "[[383   8]\n",
      " [114   9]]\n"
     ]
    }
   ],
   "source": [
    "ml_clf2 = MLPClassifier(hidden_layer_sizes=30\n",
    "                        , activation='relu', solver='adam', alpha=1, random_state=5,)\n",
    "param_grid = {'hidden_layer_sizes': list(range(0, 51, 5))[1:]}  \n",
    "  \n",
    "\n",
    "grid = GridSearchCV(ml_clf2 , param_grid, refit = True, cv = 5, verbose = 3,\n",
    "                    error_score=0,\n",
    "                    n_jobs=-1) \n",
    "  \n",
    "# fitting the model for grid search \n",
    "grid.fit(scaler.fit_transform(X_train), y_train) \n",
    "\n",
    "#### Best Grid search parameter fitting\n",
    "\n",
    "# print best parameter after tuning \n",
    "print(grid.best_params_) \n",
    "  \n",
    "# print how our model looks after hyper-parameter tuning \n",
    "print(grid.best_estimator_) \n",
    "\n",
    "grid_predictions = grid.predict(scaler.transform(X_test)) \n",
    "  \n",
    "# print classification report \n",
    "print(classification_report(y_test, grid_predictions)) \n",
    "print(confusion_matrix(y_test, grid_predictions)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7828 (+/- 0.0150)\n"
     ]
    }
   ],
   "source": [
    "#MLP Classifier\n",
    "scores_NN = cross_val_score(grid.best_estimator_, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation\n",
    "print(\"Accuracy: %0.4f (+/- %0.4f)\" % (scores_NN.mean(), scores_NN.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NEAREST NEIGHBOUR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 7 candidates, totalling 35 fits\n",
      "{'n_neighbors': 11}\n",
      "KNeighborsClassifier(algorithm='brute', leaf_size=30, metric='minkowski',\n",
      "                     metric_params=None, n_jobs=None, n_neighbors=11, p=2,\n",
      "                     weights='uniform')\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.80      0.94      0.86       391\n",
      "           1       0.56      0.24      0.33       123\n",
      "\n",
      "    accuracy                           0.77       514\n",
      "   macro avg       0.68      0.59      0.60       514\n",
      "weighted avg       0.74      0.77      0.74       514\n",
      "\n",
      "[[368  23]\n",
      " [ 94  29]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.82      0.86      0.84       391\n",
      "           1       0.47      0.38      0.42       123\n",
      "\n",
      "    accuracy                           0.75       514\n",
      "   macro avg       0.64      0.62      0.63       514\n",
      "weighted avg       0.73      0.75      0.74       514\n",
      "\n",
      "0.7490272373540856\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   8 out of  35 | elapsed:    0.1s remaining:    0.2s\n",
      "[Parallel(n_jobs=-1)]: Done  20 out of  35 | elapsed:    0.1s remaining:    0.1s\n",
      "[Parallel(n_jobs=-1)]: Done  32 out of  35 | elapsed:    0.1s remaining:    0.0s\n",
      "[Parallel(n_jobs=-1)]: Done  35 out of  35 | elapsed:    0.1s finished\n"
     ]
    }
   ],
   "source": [
    "neigh = KNeighborsClassifier(n_neighbors=3, algorithm=\"brute\")\n",
    "param_grid = {'n_neighbors': list(range(1, 15, 2))}  \n",
    "\n",
    "grid = GridSearchCV(neigh , param_grid, refit = True, cv = 5, verbose = 3,\n",
    "                    error_score=0,\n",
    "                    n_jobs=-1) \n",
    "  \n",
    "# fitting the model for grid search \n",
    "grid.fit(scaler.fit_transform(X_train), y_train) \n",
    "\n",
    "#### Best Grid search parameter fitting\n",
    "\n",
    "# print best parameter after tuning \n",
    "print(grid.best_params_) \n",
    "  \n",
    "# print how our model looks after hyper-parameter tuning \n",
    "print(grid.best_estimator_) \n",
    "\n",
    "grid_predictions = grid.predict(scaler.transform(X_test)) \n",
    "  \n",
    "# print classification report \n",
    "print(classification_report(y_test, grid_predictions)) \n",
    "print(confusion_matrix(y_test, grid_predictions)) \n",
    "neigh.fit(scaler.fit_transform(X_train), y_train)\n",
    "predictions = neigh.predict(scaler.transform(X_test))\n",
    "\n",
    "print(classification_report(y_test, predictions)) \n",
    "print(accuracy_score(y_test, predictions))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7846 (+/- 0.0321)\n"
     ]
    }
   ],
   "source": [
    "#Nearest NEighbour Classifier\n",
    "scores_NNeigh = cross_val_score(grid.best_estimator_, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation\n",
    "print(\"Accuracy: %0.4f (+/- %0.4f)\" % (scores_NNeigh.mean(), scores_NNeigh.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GAUSSIAN NAIVE BAYES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7776 (+/- 0.0128)\n"
     ]
    }
   ],
   "source": [
    "#NAive bayes classfier\n",
    "gnb = GaussianNB()\n",
    "scores_NB = cross_val_score(gnb, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation\n",
    "print(\"Accuracy: %0.4f (+/- %0.4f)\" % (scores_NB.mean(), scores_NB.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### STOCHASTIC GRADIENT WITH BALANCED CLASS WEIGHT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 9 candidates, totalling 45 fits\n",
      "{'loss': 'squared_hinge'}\n",
      "SGDClassifier(alpha=0.0001, average=False, class_weight='balanced',\n",
      "              early_stopping=False, epsilon=0.1, eta0=0.0, fit_intercept=True,\n",
      "              l1_ratio=0.15, learning_rate='optimal', loss='squared_hinge',\n",
      "              max_iter=1000, n_iter_no_change=5, n_jobs=None, penalty='l2',\n",
      "              power_t=0.5, random_state=5, shuffle=True, tol=0.001,\n",
      "              validation_fraction=0.1, verbose=0, warm_start=False)\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.83      0.75      0.79       391\n",
      "           1       0.39      0.50      0.44       123\n",
      "\n",
      "    accuracy                           0.69       514\n",
      "   macro avg       0.61      0.63      0.62       514\n",
      "weighted avg       0.72      0.69      0.71       514\n",
      "\n",
      "[[295  96]\n",
      " [ 61  62]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  14 out of  45 | elapsed:    0.1s remaining:    0.2s\n",
      "[Parallel(n_jobs=-1)]: Done  30 out of  45 | elapsed:    0.1s remaining:    0.1s\n",
      "[Parallel(n_jobs=-1)]: Done  45 out of  45 | elapsed:    0.2s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.82      0.86      0.84       391\n",
      "           1       0.47      0.38      0.42       123\n",
      "\n",
      "    accuracy                           0.75       514\n",
      "   macro avg       0.64      0.62      0.63       514\n",
      "weighted avg       0.73      0.75      0.74       514\n",
      "\n"
     ]
    }
   ],
   "source": [
    "param_grid = {'loss': ['hinge', 'log', 'modified_huber',\n",
    "    'squared_hinge', 'perceptron', 'squared_loss',\n",
    "    'huber', 'epsilon_insensitive', 'squared_epsilon_insensitive']}\n",
    "sgc = SGDClassifier(random_state=5, class_weight='balanced')\n",
    "grid = GridSearchCV(sgc , param_grid, refit = True, cv = 5, verbose = 3,\n",
    "                    error_score=0,\n",
    "                    n_jobs=-1) \n",
    "  \n",
    "# fitting the model for grid search \n",
    "grid.fit(scaler.fit_transform(X_train), y_train) \n",
    "\n",
    "#### Best Grid search parameter fitting\n",
    "\n",
    "# print best parameter after tuning \n",
    "print(grid.best_params_) \n",
    "  \n",
    "# print how our model looks after hyper-parameter tuning \n",
    "print(grid.best_estimator_) \n",
    "\n",
    "grid_predictions = grid.predict(scaler.transform(X_test)) \n",
    "  \n",
    "# print classification report \n",
    "print(classification_report(y_test, grid_predictions)) \n",
    "print(confusion_matrix(y_test, grid_predictions)) \n",
    "neigh.fit(scaler.fit_transform(X_train), y_train)\n",
    "predictions = neigh.predict(scaler.transform(X_test))\n",
    "print(classification_report(y_test, predictions)) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.5955 (+/- 0.3730)\n"
     ]
    }
   ],
   "source": [
    "#Stochastic Gradient boosting classifier \n",
    "scores_SGD = cross_val_score(grid.best_estimator_, scaler.fit_transform(X), y, cv=5)\n",
    "\n",
    "#print accuracy and standard deviation\n",
    "print(\"Accuracy: %0.4f (+/- %0.4f)\" % (scores_SGD.mean(), scores_SGD.std() * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### PLOT BAR CHART"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Description \n",
    "SVM = Support Vector Machine with Balanced Class Weight <br>\n",
    "BAG_SVM = bagging Classifiers (of SVMs with Balanced Class Weight)<br>\n",
    "EXT = Extra Trees Classifier with Balanced Class Weight<br>\n",
    "ADB = Adabost Classifier with Balanced Class Weight <br>\n",
    "GB = Gradient Boosting <br>\n",
    "XGB = Extreme Gradient Boosting <br>\n",
    "RF = Random Forest <br>\n",
    "NN = Neural Network <br>\n",
    "NNEIGH = Nearest Neighbour <br>\n",
    "SGD = Stochastic Gradient Descent with Balanced Class Weight "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creating plot elelments\n",
    "models = ['SVM with bal', 'BAG_SVM wit bal', 'EXT with bal', 'ADB with bal', 'GB', 'XGB', 'RF', 'NN', 'NNEIGH', 'NB', 'SGD with bal']\n",
    "x_pos = np.arange(len(models))\n",
    "mean = [scores_SVM.mean(), scores_BAG.mean(), scores_EXT.mean(), scores_ADB.mean(), scores_GB.mean(), scores_XGB.mean(), scores_RF.mean(),scores_NN.mean(), scores_NNeigh.mean(), scores_NB.mean(), scores_SGD.mean() ]\n",
    "std = [scores_SVM.std(), scores_BAG.std(), scores_EXT.std(), scores_ADB.std(), scores_GB.std(), scores_XGB.std(), scores_RF.std(),scores_NN.std(), scores_NNeigh.std(), scores_NB.std(), scores_SGD.std() ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAFgCAYAAACmDI9oAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xe4XFXVx/HvL6F3EAid0AVEUCJFRUI1dEVAem9SFMSCghBQeSnSFF6liKCAERARXlFAIYAIUiwoIL2FHgi9w3r/WHvIyfWWubl37pT8Ps8zz52Zc+6ZvefMnFlnn7X3VkRgZmZmZmZpWLMLYGZmZmbWShwgm5mZmZlVOEA2MzMzM6twgGxmZmZmVuEA2czMzMyswgGymZmZmVmFA2SzDiTpXEnfa3Y5upL0iKT1B3F74yXtWee6oyVNGITX3EHS1QP4/99L2mWg5ZiK1/2epImSnu7n/9X9Hk9FmRaT9Kqk4eXxCEk3SHpF0omSvi3p7Ea8dpdyDMnrTA1Ju0r6c+Xxq5KWnIrtDOhzOxiqZe/rGCUpJC1d7s8s6QpJL0m6uBXqYp1vumYXwKweksYDKwMLRMRbTS5Ox5IUwDIR8UCzy9KqIuIC4IJ61pU0Flg6Inas/P9GDSpab+VYFDgEWDwinh3q1+9JRDwGzFZ5am9gIjBHDOEg/RFxzFC91kBFxGx9rSNpJPAwMH1EvFv+r+7PbaPUU/YebAWMAD5Uqw9Nrot1PrcgW8srB/u1gAA2H+LX9klkC/B+GLDFgedbKTjuweLA3QMNjpVa7vfNn+OptjhwXyU47pHfYxssLXcAMevGzsAtwLnAFJemy6W3EyU9Wi6//VnSzGXZpyX9RdKLkh6XtGt5fopLxt1cwgxJ+0u6H7i/PHdq2cbLku6QtFZl/eHlEu2D5dLwHZIWlXS6pBO7lPcKSQd1V8k+XmOspIsk/by8xl2SRlWWf0zS38qyXwEz9fRmSlpa0vXl/ZpY1kfSDWWVf5ZLoV+UNLek/5P0nKRJ5f4ilW2Nl/RdSTeV175a0ryV5TuVffO8pMO6lGM1STeX/fOUpNMkzdDHfthA0n9K2U8D1Es9Zy6XcSdJuhv4RJflC0n6danbw5K+XHn+DUnzdHl/J0qavpvPS7f7TdIY4NvAF8v7+c/Ke7ZnuT9M0uHlPXq27N85y7KR5T3YRdJj5fWneA+71GfO8v/Ple0dXra/PnANsFApx7k9/P8Wkv5R6vFgKX/XdZaSdG3ZnxMlXSBprsryb0p6onwW7pW0Xnl+NUm3l20/I+mkLnWcrpRrF+AbpZzrl8/9+ZXtr6HJ3+l/ShpdWTZe0vcl3QS8DixZ9tVDpTwPS9qhh7p/8DpT8b6fK+knkq4pr3O9pMUry7v7HH+4rP9CeZ+2qaz/IUmXl/fqVmCpLq/XNfWgu+Nf7bv8Ynkv1+zmcxuS9pV0v/I7croklWXDy3YnlvftgNp+6qb+u0m6ovL4AUkXVR4/LmmVrmXvZjtfVx4HnpS0e+X5o4AjmPw92qOHuvTnPd5Y0t1lfz0h6WvdlcmmcRHhm28tfQMeAPYDVgXeAUZUlp0OjAcWBoYDnwRmBBYDXgG2A6YHPgSsUv5nPLBnZRu7An+uPA4yoJgHmLk8t2PZxnTkpeqngZnKsq8D/wKWIwO2lcu6qwFPAsPKevOSP9wjeqhnb68xFngT2LjU83+AW8qyGYBHgYNLXbcq79P3enidXwKHkSfIMwGf7lL3pSuPPwR8AZgFmB24GLissnw88CCwLDBzeXxsWbYC8CrwmbJPTgLeBdYvy1cF1ij1HQncAxzU034o79/LpX7Tl/q+W92XXep5LHBj+f9FgX8DE8qyYcAd5A/vDMCSwEPAZ8vya4G9Kts6AfhJD5+Xvvbb+V3KNb5WZmB38vO9JJlqcCnwi7JsZHkPzir1Xxl4C1i+h/r+HPht2U8jgfuAPcqy0bW69/C/qwEvARuU92Zh4MPdlHfpss6MwHxkIHZKWbYc8DiwUKX8S5X7NwM7lfuzAWt0qeN05fG5VD631fevlOl58jswrJTjeWC+SjkfA1Ys+2JO8vOyXFm+ILBiD/Wvvk5/3/dzyWNN7XN+Kr0cT4BZy/u0Wynnx8m0khXL+uOAi8p6HwGe6GZ7S/dx/Jvife3lOPd/wFzk8fI5YExZti9wN7AIMDfwx67bq2xnSeDFsk8WJI9FT1SWTWLyMbBa9g/2NTAGeKbUd1bgwi7rfrB/6jlm1/EePwWsVe7PDXx8oL9TvnXerekF8M233m7Ap8lgb97y+D/AweX+MOANYOVu/u9bwG962OZ4+g6Q1+2jXJNqrwvcC2zRw3r3ABuU+wcAV/aj7tXXGAv8sbJsBeCNcv8zZCCuyvK/0HOA/HPgTGCRbpZNESB3s3wVYFKX9/LwyuP9gD+U+0cA4yrLZgXepgTI3Wz7oOo+67ofKFcSKo8FTKDnAPkhyg9+ebw3kwPk1YHHuvnM/Kzc3xO4tvI6jwOf6e7zUsd+6y1A/hOwX2XZcuXzXjtpiOp+Am4Ftu3mNYeTQdwKlef2AcaX+6PpPUA+Azi5nu9Ll2WfA/5e7i8NPAusT+a+Vte7ATiK8j2uPF+rYz0B8jcpJw+V5VcBu1TKeXSXz9uL5AnezH1816qvU/f7Xilz9XM+G/AesGgPn+MvAjd28/4fWfbjO5STk7LsGLoJkOn9+DfF+9rd57Ysr54cXwQcWu5fC+xTWbZ+1+11eb3HySB0W/LYcivwYTJAvbxr2bvua+Acyol1ebws/Q+Q63qPy/3HyO/HHL19Lnybtm9OsbBWtwtwdURMLI8vZHKaxbxkC+iD3fzfoj08X6/Hqw8kHSLpnnIZ80WydaqWStDba51HtjBS/v6ipxfs4zUgWyZrXgdmKpc8FyJbbKKy/NFe6vYNMui7VZmqsXtPK0qaRdIZ5RLuy2SgM5fKqAM9lKvWEWchKu9jRLxGtvjVtr2sMmXj6bLtY7rUF6bcD123F12Wd7VQl+XV92RxMuXgxdqNTIcYUZZfAqwpaSHyBCTI1uj/Usd+681CXcr1KBkcj6g819P7WzUvk68kVLe1cJ3lqOv7Iml+SePKZemXgfPLaxPZsfMgMph5tqy3UPnXPcig5z+SbpO0aZ3lqloc2LrLPvs02WpZ0/Xz9kWyNfQpSb+T9OF+vF4973t3r/sq8AK5b/9reanH6l3qsQOwANkqPx09f26rejv+1auu7y69f88AridPwj5T7o8H1i636+soR2/f1XrV+x5DnjRtDDxaUmLWnIrXsw7nANlaVsml2wZYuwRRT5OX1VeWtDJ5yexNuuToFY/38DzAa2TKQM0C3azzQbCpzCn9ZinL3BExF3k5upb/2ttrnQ9sUcq7PHBZdyvV8Rq9eQpYuJY/WCzW08oR8XRE7BURC5GtKP/bU14gmTKwHLB6RMxB/gDSj3ItWnsgaRYyFaHmx+QVgWXKtr/dzXarQX/X7an6uK/XZ8r35HHg4YiYq3KbPSI2BoiIF4Gryf2xPfDLLicgtTL0td/+63+6eJL8Ma+W8V3ycnN/TCRbHrtu64k6/7+3z3DV/5B1+mjZZztS2WcRcWFEfLqUI4DjyvP3R8R2wPzluUskzVpn2apl/EWXfTZrRBxbWWeK9zsiroqIDcgg+j9k2kQjVD+Xs5GX+p/soVyPA9d3qcdsEfElMs3hXXr+3Fb1dvzr63PXl6fI9Iqa3r5nMDlAXqvcv57+Bci9fVfrVe97TETcFhFbkJ/Hy8jWc7MpOEC2VvY58lLlCuSl/VXIIPNGYOeIeJ+8NHeSsmPV8NIZZUZyCKD1JW2j7AD0oVpHEeAfwJaldXRpsnWrN7OTP1rPAdNJOgKYo7L8bOC7kpZR+qikDwFExATgNrLl+NcR8cZUvkZvbi7/++VS1y3JnNJuSdpakzvaTSJ/WN4rj58h8war5XqD7OwzD3kZuF6XAJsqO0vOABzNlMec2ckc0VdLy96X+tje74AVJW1ZWs6/TPcnNzUXAd9SdjRcBDiwsuxW4GVlp7KZy2fnI5KqHfkuJNM6vlDud6ev/fYMMFI9j6jwS+BgSUuUwOoY4FdRR2/9qoh4r9T3+5JmV3YS+yp5glaPnwK7SVpP2bFv4R5aW2cn88pflLQwmX8PgKTlJK1bvn9vkp+b98qyHSXNV76zL5Z/eY/+OR/YTNJny/6aSTm29SLdrawcU3nzEoi/Vcrd39es18aVz/l3gb9GRE+trv8HLKvswDp9uX1C0vJlP14KjC3HpxXo0jG5po/j33PA+0z5Xe6Pi4CvlM/BXORJYG+uB9YhU1kmkMfoMeQJ8d/rfL1dJa1QTqT7c5zpTo/vsaQZlOMozxkR75DHoEZ9LqyNOUC2VrYLmRP6WGn1fDoingZOA3YoQdLXyA5yt5GXNY8jO4Q8Rl5CO6Q8/w+ysw3AyWQu7DNkCkRf42leBfye7PT0KPnjX/3xO4k8wF9NHmx/SnYUqTkPWIle0ivqeI0eRcTbwJZkXt4k8rLypb38yyeAv0p6Fbgc+EpEPFyWjQXOK5cltwFOKXWZSI4k8od6ylTKdRewPxlcPlXKVp2o42tk6+wrZMver/rY3kRga7Lz3fPAMsBNvfzLUeR7+TC5bz54/0sgshl50vVwqd/ZZHpEzeXlNZ6JiH/28Bp97beLy9/nJf2tm/8/p5TrhlKON5kykO+PA8mrIw8Bfybf93Pq+ceIuJXMFz2ZbAG/nilbo2uOInNNXyJPWKqfsxnJfTORvHQ/P3lVADJYuqt85k4l83nf7EfdKAHnFmWbz5Hv89fp+XdsGPn9f5I8BqxN5sg3woVkUPcC2fm029EyACLiFWBDMl/3SfK9Oo58/yD7KsxWnj8X+Fkvr9vT8e914PvATeW7vEY/63MW+Z25kwxwryRPBLsNJCPiPvIE5Mby+GXyc3hT+a71KiJ+Tx5rriU7rV7bz/J23V5f7/FOwCPKNKF9mZwGZ/YBdXPV0MwGkaTPkK1fI0urj5l1COXwdBMi4vBml6VRJG1EjuLS3UmTWUdyC7JZA0maHvgKcLaDYzNrByXtaOOSsrUw2Tr+m2aXy2woOUA2axBJy5P5lguSlw/NzNqByHSaSWSKxT3ksI1m0wynWJiZmZmZVbgF2czMzMys4r/mVW918847b4wcObLZxTAzMzOzNnPHHXdMjIj5+lqv7QLkkSNHcvvttze7GGZmZmbWZiTVNVOjUyzMzMzMzCocIJuZmZmZVThANjMzMzOrcIBsZmZmZlbhANnMzMzMrMIBspmZmZlZhQNkMzMzM7MKB8hmZmZmZhUOkM3MzMzMKhwgm5mZmZlVOEA2s/YxdixIrXMbO7bZ70h78H4zszajiGh2Gfpl1KhRcfvttze7GGbWrkaPzr/jxzezFNZf3m9mNggk3RERo/pazy3IZmZmZmYVDpDNzMzMzCqma3YBzMx6cvI19w36Nrea9AYAlzRg2wdvsOygb7Mdtdt+A+87M5uSW5DNzMzMzCocIJuZtQKP9GBm1jKcYmFm1grGjh14UNqiIz2s8fMfseb5pw3Ktg7ecLkBb+PmHQ/glp0PHITSmFmncoBs056xY+Goo5pdismOPNKtdXVyoNWebtn5QL9PZtZWHCDbtKeDW+o6nQMtMzMbCs5BNjMzMzOrcAuydbx2G3LKw02ZmZk1lwNkM7Mm8ImbmVnramiKhaQxku6V9ICkQ7tZvpik6yT9XdKdkjZuZHnMzMzMzPrSsABZ0nDgdGAjYAVgO0krdFntcOCiiPgYsC3wv40qj5mZmZlZPRqZYrEa8EBEPAQgaRywBXB3ZZ0A5ij35wSebGB5zAAPFWZmZma9a2SAvDDweOXxBGD1LuuMBa6WdCAwK7B+A8tjBnioMDOzunnceJtGNTJAVjfPRZfH2wHnRsSJktYEfiHpIxHx/hQbkvYG9gYYMWIE4z32rPXDwm++1ewi9Mv48b6QUtPJ+64RdZvx/TfKth8e9G03u26N5u9dD0aPnjzu+1Ra5aCDAPjHKacMvDzg8edtSDQyQJ4ALFp5vAj/nUKxBzAGICJuljQTMC/wbHWliDgTOBNg1KhRMXqAX1abtjRitIBG2ma0Rwuo6eR917Vug5n6s83mYwa8ja6pPwOpWzvw966B5poLAP92WztpZIB8G7CMpCWAJ8hOeNt3WecxYD3gXEnLAzMBzzWwTGZmLcmpP23MaQhmHadhAXJEvCvpAOAqYDhwTkTcJelo4PaIuBw4BDhL0sFk+sWuEdE1DcPMzKx1efp6s47T0IlCIuJK4Mouzx1RuX838KlGlsHMzGwwdfIkL51ct2659d960NCJQszMzMxa1tixEDGw29pr522g24kY3OB47FiQWufWZoG/p5o2MzMbAI+t3h4a1Xm0ZVvInfozIA6QzczMBsAdLM06jwNkMzMz61ant453ev1s6jlANjMzs251eut4p9fPpp476ZmZmZmZVThANjMzMzOrcIBsZmZmZlbhANnMzMzMrMIBspmZmZlZhQNkMzMzM7MKB8hmZmZmZhUOkK17nsPdzMzMplGeKMS65znczczMbBrlFmQzMzMzswq3IBsnX3NfQ7a71aQ3ALikAds/eINlB32bZmZmZuAWZDMzMzOzKThANjMzMzOrcIqFdWuNn/+INc8/bVC2dfCGyw14GzfveAC37HzgIJSmw40dC0cd1exSTHbkkR6BxMzM2o4DZOvWLTsf6IC0HXn0ETMzswFzioWZmZmZWYUDZDMzMzOzCgfIZmZmZmYVDpDNzMzMzCocIJuZmZmZVXgUC7M21ohZED0DopmZTevcgjy1xo4FqXVuHmvWzMzMbFC4BblO/9VS96nt4ertB7TNrb62EwCX/OAXA9rOBypldEudmZmZ2dRxC7KZmZmZWYVbkKeSp2I2MzMz60wOkKeSp2I2MzMz60xOsTAzMzMzq3ALslkHceqPmZnZwDlANusgTv0xMzMbOKdYmJmZmZlVOEA2MzMzM6twgGxmZmZmVuEA2czMzMyswgGymZmZmVmFA2QzMzMzswoHyGZmZmZmFQ6QzczMzMwqHCCbmZmZmVU4QDYzMzMzq3CAbGZmZmZW4QDZzMzMzKyioQGypDGS7pX0gKRDe1hnG0l3S7pL0oWNLI+ZmZmZWV+ma9SGJQ0HTgc2ACYAt0m6PCLurqyzDPAt4FMRMUnS/I0qj5mZmZlZPRrZgrwa8EBEPBQRbwPjgC26rLMXcHpETAKIiGcbWB4zMzMzsz41MkBeGHi88nhCea5qWWBZSTdJukXSmAaWx8zMzMysTw1LsQDUzXPRzesvA4wGFgFulPSRiHhxig1JewN7A4wYMYLx48cPemH7svCbbw35aw7E+PFP1r1uu9UNOrt+rttknVw/1621dHL9XLfUbnWD/h8zB9sqL2Y49o8mxF3N1sgAeQKwaOXxIkDXPT0BuCUi3gEelnQvGTDfVl0pIs4EzgQYNWpUjB49ulFl7tHJ19w35K85ENuMXrbuddutbtDZ9XPdJuvk+rluraWT6+e6pXarGzS/fkvFjAD8/Z2FBn3bB2/Qv9+DodbIFIvbgGUkLSFpBmBb4PIu61wGrAMgaV4y5eKhBpbJzMzMzKxXDQuQI+Jd4ADgKuAe4KKIuEvS0ZI2L6tdBTwv6W7gOuDrEfF8o8pkZmZmZtaXRqZYEBFXAld2ee6Iyv0AvlpuZmZmZmZN55n0zMzMzMwqHCCbmZmZmVU4QDYzMzMzq3CAbGZmZmZW4QDZzMzMzKzCAbKZmZmZWYUDZDMzMzOzCgfIZmZmZmYVDpDNzMzMzCocIJuZmZmZVThANjMzMzOrcIBsZmZmZlbhANnMzMzMrMIBspmZmZlZhQNkMzMzM7OKPgNkSQdImnsoCmNmZmZm1mz1tCAvANwm6SJJYySp0YUyMzMzM2uWPgPkiDgcWAb4KbArcL+kYyQt1eCymZmZmZkNubpykCMigKfL7V1gbuASScc3sGxmZmZmZkNuur5WkPRlYBdgInA28PWIeEfSMOB+4BuNLaKZmZmZ2dDpM0AG5gW2jIhHq09GxPuSNm1MsczMzMzMmqOeFIsrgRdqDyTNLml1gIi4p1EFMzMzMzNrhnoC5B8Dr1Yev1aeMzMzMzPrOPUEyCqd9IBMraC+1AwzMzMzs7ZTT4D8kKQvS5q+3L4CPNTogpmZmZmZNUM9AfK+wCeBJ4AJwOrA3o0slJmZmZlZs/SZKhERzwLbDkFZzMzMzMyarp5xkGcC9gBWBGaqPR8RuzewXGZmZmZmTVFPisUvgAWAzwLXA4sArzSyUGZmZmZmzVJPgLx0RHwHeC0izgM2AVZqbLHMzMzMzJqjngD5nfL3RUkfAeYERjasRGZmZmZmTVTPeMZnSpobOBy4HJgN+E5DS2VmZmZm1iS9BsiShgEvR8Qk4AZgySEplZmZmZlZk/SaYlFmzTtgiMpiZmZmZtZ09eQgXyPpa5IWlTRP7dbwkpmZmZmZNUE9Oci18Y73rzwXON3CzMzMzDpQPTPpLTEUBTEzMzMzawX1zKS3c3fPR8TPB784ZmZmZmbNVU+KxScq92cC1gP+BjhANjMzM7OOU0+KxYHVx5LmJKefNjMzMzPrOPWMYtHV68Ayg10QMzMzM7NWUE8O8hXkqBWQAfUKwEWNLJSZmZmZWbPUk4P8g8r9d4FHI2JCg8pjZmZmZtZU9QTIjwFPRcSbAJJmljQyIh5paMnMzMzMzJqgnhzki4H3K4/fK8+ZmZmZmXWcegLk6SLi7dqDcn+GxhXJzMzMzKx56gmQn5O0ee2BpC2AifVsXNIYSfdKekDSob2st5WkkDSqnu2amZmZmTVKPTnI+wIXSDqtPJ4AdDu7XpWk4cDpwAblf26TdHlE3N1lvdmBLwN/7U/BzczMzKx7a/z8R6x5/ml9r1iHgzdcbsDbuHnHA7hl5wP7XrFF1DNRyIPAGpJmAxQRr9S57dWAByLiIQBJ44AtgLu7rPdd4Hjga3WX2szMzMx6dMvOB7ZVQNpqFBG9ryAdAxwfES+Wx3MDh0TE4X3831bAmIjYszzeCVg9Ig6orPMx4PCI+IKk8cDXIuL2bra1N7A3wIgRI1YdN25cP6o4OJ595a0hf82BmH/2Getet93qBp1dP9dtsk6un+vWWjq5fq5bare6QWfXr7+/B4NlnXXWuSMi+kzprSfFYqOI+HbtQURMkrQx0GuADKib5z6IxiUNA04Gdu2rABFxJnAmwKhRo2L06NF9l3qQnXzNfUP+mgOxzehl61633eoGnV0/122yTq6f69ZaOrl+rltqt7pBZ9evv78HQ62eTnrDJX0Q5kuaGagn7J8ALFp5vAjwZOXx7MBHgPGSHgHWAC53Rz0zMzMza6Z6WpDPB/4k6Wfl8W7AeXX8323AMpKWAJ4AtgW2ry2MiJeAeWuPe0uxMDMzMzMbKvV00jte0p3A+mTaxB+Axev4v3clHQBcBQwHzomIuyQdDdweEZcPrOhmZmZmZoOvnhZkgKfJ2fS2AR4Gfl3PP0XElcCVXZ47ood1R9dZFjMzMzOzhukxQJa0LJkWsR3wPPArctSLdYaobGZmZmZmQ663FuT/ADcCm0XEAwCSDh6SUpmZmZmZNUlvo1h8gUytuE7SWZLWo/uh28zMzMzMOkaPAXJE/CYivgh8GBgPHAyMkPRjSRsOUfnMzMzMzIZUn+MgR8RrEXFBRGxKjmX8D+DQhpfMzMzMzKwJ6pko5AMR8UJEnBER6zaqQGZmZmZmzdSvANnMzMzMrNM5QDYzMzMzq3CAbGZmZmZW4QDZzMzMzKzCAbKZmZmZWYUDZDMzMzOzCgfIZmZmZmYVDpDNzMzMzCocIJuZmZmZVThANjMzMzOrcIBsZmZmZlbhANnMzMzMrMIBspmZmZlZhQNkMzMzM7MKB8hmZmZmZhUOkM3MzMzMKhwgm5mZmZlVOEA2MzMzM6twgGxmZmZmVuEA2czMzMyswgGymZmZmVmFA2QzMzMzswoHyGZmZmZmFQ6QzczMzMwqHCCbmZmZmVU4QDYzMzMzq3CAbGZmZmZW4QDZzMzMzKzCAbKZmZmZWYUDZDMzMzOzCgfIZmZmZmYVDpDNzMzMzCocIJuZmZmZVThANjMzMzOrcIBsZmZmZlbhANnMzMzMrMIBspmZmZlZhQNkMzMzM7MKB8hmZmZmZhUOkM3MzMzMKhoaIEsaI+leSQ9IOrSb5V+VdLekOyX9SdLijSyPmZmZmVlfGhYgSxoOnA5sBKwAbCdphS6r/R0YFREfBS4Bjm9UeczMzMzM6tHIFuTVgAci4qGIeBsYB2xRXSEirouI18vDW4BFGlgeMzMzM7M+KSIas2FpK2BMROxZHu8ErB4RB/Sw/mnA0xHxvW6W7Q3sDTBixIhVx40b15Ay9+bZV94a8tcciPlnn7HuddutbtDZ9XPdJuvk+rluraWT6+e6pXarG3R2/fr7ezBY1llnnTsiYlRf603XwDKom+e6jcYl7QiMAtbubnlEnAmcCTBq1KgYPXr0IBWxfidfc9+Qv+ZAbDN62brXbbe6QWfXz3WbrJPr57q1lk6un+uW2q1u0Nn16+/vwVBrZIA8AVi08ngR4MmuK0laHzgMWDsi2uv0x8zMzMw6TiNzkG8DlpG0hKQZgG2By6srSPoYcAaweUQ828CymJmZmZnVpWEBckS8CxwAXAXcA1wUEXdJOlrS5mW1E4DZgIsl/UPS5T1szszMzMxsSDQyxYKIuBK4sstzR1Tur9/I1zczMzMz6y/PpGdmZmZmVuEA2czMzMyswgGymZmZmVmFA2QzMzMzswoHyGZmZmZmFQ6QzczMzMwqHCCbmZmZmVU4QDYzMzMzq3CAbGZmZmZW4QDZzMzMzKzCAbKZmZmZWYUDZDMzMzOzCgfIZmZmZmYVDpDNzMzMzCocIJuZmZmZVThANjMzMzOrcIBsZmZmZlbhANnMzMzMrMIBspmZmZlZhQNkMzMzM7MKB8hmZmZmZhUOkM3MzMzMKhwgm5mZmZlVOEA2MzMzM6twgGxmZmZmVuEA2czMzMyswgGymZmZmVmFA2QzMzMzswoHyGZmZmZmFQ6QzczMzMwqHCCbmZn7TFSrAAAgAElEQVSZmVU4QDYzMzMzq3CAbGZmZmZW4QDZzMzMzKzCAbKZmZmZWYUDZDMzMzOzCgfIZmZmZmYVDpDNzMzMzCocIJuZmZmZVThANjMzMzOrcIBsZmZmZlbhANnMzMzMrMIBspmZmZlZhQNkMzMzM7MKB8hmZmZmZhUOkM3MzMzMKhoaIEsaI+leSQ9IOrSb5TNK+lVZ/ldJIxtZHjMzMzOzvjQsQJY0HDgd2AhYAdhO0gpdVtsDmBQRSwMnA8c1qjxmZmZmZvVoZAvyasADEfFQRLwNjAO26LLOFsB55f4lwHqS1MAymZmZmZn1ShHRmA1LWwFjImLP8ngnYPWIOKCyzr/LOhPK4wfLOhO7bGtvYO/ycDng3oYUujnmBSb2uVb76uT6uW7tq5Pr57q1r06uXyfXDTq7fp1Wt8UjYr6+VpqugQXoriW4azRezzpExJnAmYNRqFYj6faIGNXscjRKJ9fPdWtfnVw/1619dXL9Orlu0Nn16+S69aaRKRYTgEUrjxcBnuxpHUnTAXMCLzSwTGZmZmZmvWpkgHwbsIykJSTNAGwLXN5lncuBXcr9rYBro1E5H2ZmZmZmdWhYikVEvCvpAOAqYDhwTkTcJelo4PaIuBz4KfALSQ+QLcfbNqo8LawjU0cqOrl+rlv76uT6uW7tq5Pr18l1g86uXyfXrUcN66RnZmZmZtaOPJOemZmZmVmFA2QzMzMzswoHyB1A0tKS5m52Oax/JK3e7DI0mqR5JE3f7HJYZ5hWJpIqM9GadYx2jFMcILe58oHbDzhM0lzNLs9QkzRzs8swAN+R9M9mF6JRJC0FHAOs06pB8jQUcHVKPWdpdgEaSdKnJc0WEe9Ni0GypBmbXQYbfO0apzhAbnMRMQn4HfAe8LV2O0MbCElzAOdI+myzyzI1ImJT4EFJf2l2WRrkIXJ0ms2AtVohSJa0tqS9JG0qafpOHVZS0ickbShpBYBOqKekzYArJM0iqVN/u3YG7psWg2RJywFfkbRYs8vSX5JWlrSepAWaXZZW1K5xSqceZDpetUUoIv4EXAnMChzSLh++QTAM+Auwn6R1ml2YetT2W+2HLyK2BCZ1UpCsNKwEZYcBzwPb0OQguZxInQZ8lBxS8jOVZZ3SwoqkjYCfAXuRP0YjK8vasp5l3x0KnBARrze7PI0SEXsDVwB/mwaD5CWApYCtJC3S7MLUS9LGwIXA14ETJM3W5CK1jHaPUxwgtyFJqrUISRopaXhEXA/8EpiN/PC1zWWMqRURLwIXAP9HBgItHSRX9xuwlKSPAETEJsDznRAk1+oYEe9LmqfU9yjgMeCLNClIlrQhcDbwhYg4EJgIrCDpY5JmjIjohFZJSWOAU8h6bg3MRdZzQciW5HYLkiWtBPwe+E5E/F7SEmR6UjunV31A0gaSdpT0UYCI2IdsbfvntBQkR8QfyO/ossB2khZqcpH6VE7cTgS2iYgxwILApyTN1QnHk4HohDjF4yC3sTIRy9bArcAzEfEDSasC25MnP2Mj4qVmlrERugSatdbYvchL+T+IiOuaVrg6SDoY+BzwLnB/ROxbnr8UWD4ilm9m+QaDpP2AdYE7gKsj4g5J3wQWB35Lzpr5zhCVZUZgH2B3YN2IeEHSg8CdwOvAvMDnIuKNoShPo5SWq5OBBSNi0/K9eISs54vA0xFxSBOL2C+177mk2YFzgeeAY4FfABdGxI+bWb7BUPbZpcB6wL/IffV78jtyLLAW8MmIeKMEGO81rbANIOmT5HnbzeXxvOTv2V3A9cCvIuLxJhaxR+Vz+VPg1YjYXdJMwIPA38nUsnvIKx7vNrGYTdfOcco0fYbTziTtRLbIbQssBOwk6cSIuAO4BHgDmKGJRWyIyo/mRpJOkHQksEBE/IRsST5I0gZNLmaPyn77fESsTR4wdpJ0LnyQbvG36iXxdiRpT2A7Mr1ia+BbkjaJiOPIltsxwJC0Ikv6dCnLvcCpwEWS7gWOiIjPAweQP2ZfHIryNErJp36VTCG5TdLZwO1kq+smwOnA4pLWamY5+2kGgIh4BdiBbHV6ELgoIn7c7i10khYF3iJTR35CXqZ/kkwz+AtwP7Ay2ZI8S6cFx8XKwAWSlpE0A3AZcBxwNLAwsLWkxZtZwO6UffcG8CPgOUnfB24ig71NyROclYC2b+wYiHaPU9r6ADMtqV4WLWeqrwNbltu8wG7A6pJOKmfjR0XEc00pbAOV4HgT4LvkNOajgIslLVlalP5EXrqZpxUuJXfzI/4vYMdyVr08sCjwGUm/BoiIHSLikaEt5eAouccfAhYhP5cbAC8BfwX2lbRxRBwBfG8o8khLusFpZMeQN4Bfk5+Zt8hWnlrnkRdo4YN0XyStS6YcbBIR/yRbIN8hW41rn6u/kO9DW+RHlpSYcZLGStoyIt4krwJcCKwJUNJ42jL1QNII4JvA/mSr8SXAPOQJ5HHAjsA/gd8Aw8lL9x2jpCBMV47Z/wNcTrYanxERZ0TEbeR3dXlgc0nTNbG4U6jsuwPIoPgK8qTmUTJ9gIj4NTA7ME112uu0OMUBcpuo5PJMHxFvli/gO8BoYPeI+Bt5OXUJSfNHxFtNK2wDlUuS65EtSrMDcwI3A5dIGhkRPwT2jogXmt1zv7R2v1/uzydpzoj4B/AEsDrw44h4gfzRX1jSfE0s7lSrnQSU3OPnydafWYFNImIdsuV2MWC9klP5/BCUaW0yON4nIn4RETdExMtkq/3RwLGSlpO0PhlwXd/oMjWCsoPQccC/gccBIuJWssX4FmCsctSHDYBlyJb0llZObL4L/BEQsJGkZSLiNXKoqPckXVK+X+3aqvocuX9GkulhN5AdmEYCXwFeiIgbyMvQq0TEg80p5uCrnLgeWH7PziLzeGcl3xPgg5zkceQVg1ZKU6juu33K/VPIAHmf8n3biGwouK9ZhWyGTotTnIPc4iStDNxZWk4PAtYBXgYui4hfSxpPHmxmJXNwv9TKZ2RTo5uc43nI1pYLycvnj5MtggGMKq1NTaUcsmiFiPiNpC8DWwDzkXmFN5AB/qLAs+Rlxq9ExIRmlXdqSFo+Iu4p9/cEPkYGareQQ7zdDaxP/pDsAewfEc8MUdkOIo/Xp1aeOx7YBTgDuI3M1wXYPCLuHopyDSblRDPnAztGxF8rz28IXAssSQ4btjYwN9mRqKXrWb7bE4EtIuIK5WgG3ydPJm8p68xABk5vRMQOzStt/0laBhgWEfeW1rZNgY3I782Z5MnaluRVjXNbNf92aknalOy0+01gQkT8p7Jsf2Bv8jes5Tos97Lv7iKPKWuSx/mlym27iLirWeUdSp0ap7TMZQvr0QnAK5JOJDs9/YDMzTpL0svAkeRluvmAg9rhQ1cvZS/1dyLi3XIZeTHypO5nyo5X/yKHEBtFXoq8tEWC4+HkwXNpZY/79YHPk7m365L5tzeSrcjrA99ow+B4JuA0SXeRl0e3J/MHFyUPgAcDY8lRRt4HdhuK4LhyMrUUmd5Re34j8nLn50qZHgeOB26sBfltaD7gpxHxV5UOXJJOIN//W8hgYxyZVnFmqwfHAJEdKDcDjpd0fURMKFdWjpX0D3K/nQPsSZulxZT0o3uBiZKOIlNeziSvgi0J7Eu2/M9IHhdea1JRG6I0GhwD7FFSKGrP70d2ujxd0vtkas0Xqus0Wz/23XDypHTbdvi+DaKOjFPcgtwGJF1G/uD/LCJOKs/VLl1/BngbeL8VgsPBohz+5Syyju8B55E/jNuTP/5fJcd6fZU8i98lIq5qTmn/m3KMx13I4H3GyCG3apcXTwQ2i4iHyqWoIRnNYbApOxOeRA7LtHdE/KW0AG4FrBQRB5YThJeHIq2iS9nWIzs/fTMi/qYcWk4R8bakb5Mt3Be34yX6crL4OrAC2Xq8bnl+ReBbwBHk9+OxiDhe0gwR8XbTCjwVygnND4E/kHmoZ5BXjfYkc3O/WlJm2krZd38k0yhWIlv2XyWP4fMAf4yIMyTNHG0+qkpXyklrvhERu9Y+k5KOJscPfgpYLSImStoNuD4iHmpqgbvox76bsdVTBxqhE+MUB8gtrHRieLfcvxgYQQ5TVXvuAuDwiHi4icVsGOWwYKOBB4AbIuLi0lljPHAd2UK5HDBdRNzZpGL+l1orpqQ5gZ2AjcmWvl+X5RcAP4+Iq7qmj7Qb5axXVwIPRsQW5blVyCBth2b9yEualfzhnQW4pOTlImk74MBStrb83pQWrDnJ1IMfkMOEXRGl01ppST4EmD4ijm1mWQei5IdfTQ5b90x5bhgwT0RMbGrhBqDkg/+QTK0aQba4bQusBjwDrBktOuzV1KgF+5I+BfwwIlYtzy9EpiGcqBwF4iPAlq180jqt7bt6dHKc4k56LaykFtRmXNuabDUaJ2l9SVuRl+jbsvWxNyW/i8hhwX5DjgW6kqTZy5fuC+QBaeaIuLuVgmOYPBlDOVCeR7Y6rKcclm5b4BPAf2rrNrGoAxYRj5EnAHNLOqMEMIuRqRazNrFcr5FXIF4lL9efLOkYMv9xz3Y8WFfcBMxXLlPeS+b7fR6gBMfbApuTgXPbiog/ApsA1ypHDiAi3m/n4BggIq4BvkbmHb8WEeeRV8aWBzbupABL0vLAGcoO1DcB90g6XdJMEfEk8L9l1TvIIe5aelSSaWnf1auT4xS3ILcQ5fS871ce11oiu56hrUXm/FweEfc3qbgNUwLkYbWWBEl7kePpHkd2rvowmf+13lBfuu+OehjAv7Y/S0vyDuREFTcDP4qIturd3FdLd2lJ/h0wB5mL/JNWyO0teewfJ4ecewIY347fmZIysjzZGfVJsoPqhmQ++x5k69vy5NWVzYGtIuLfTSnsIJO0BZnDOKp6fGx3JY3kVLLVsenHscGmHKXgWUm/IIdW/B6Zg7ormT++X0S8I2l78qrOHu2St9vp+64301Kc4gC5RVSDLOUUxC+X1rna8uqH73zyksUjTSlsA5TUiQ/ORktLWPU9OZAccPwZ8gz11xFxWfNK/N/K5bcnyZmVHi3P1eoyBzm26cXt0kGhpnpALJ1V3omIl7s5UC5Bpr0c2UmfzVZQfpC3Bj5EtsyvSg4tdSOZkz8D8FlgAvBEp73/yuEBX212OQZbCf7HAqt2WPA/hhzzdpeIeFM5cU2QKUEzkznyK5DDoC0H7BoR/2pWeadGp+673kxrcYoD5BYg6cPAFyLi+5L2IXvEzkbmGF4eOVZubWzBtrxU0Ztyeebz5MxRS5EtYLuTB9TqWML7kK0PO0fE/c3O31UOs3VYRGxecltPIHOj3yA7KtSmT60FycPa7UBaPptzR8TNkr5Kjs4xC/D1iLixmyD5gwOkNUY5Efk+OQ747OSwaB8CTqvluVv76LTgvzQUnAgcHBF/qjx/FnlMPyYiHlEODfYiOVzfs80p7cB02r7rzbQYp3iYtyYrOZtLkgNnnwgsHREfU/b+PAiYQdLFETGpUz50VcrRHt4ix/28mMxB268SdNXyeSOyh/Dva2eszc7fjRxeaynlGI9/BlYhW/c2B75Uin1L7Yy7nYLjWpoLOWrArMoxQD9LDmG0AXCFpM0j4oZqq4KD48apnYxExMOSbgM+GhGbSVqQTLf4e5OLaFOhkwKscqXjbLKT1r3KkW4OIK8q7VVakr9TOuXd2exj+EB10r7rzbQap7iTXhOVjgrvR8SVwP+Vp+cDiIjryBynTcj5y+dqUjEbRjkr3p7kEDk3kp3ZXgFeLbmjwAed3qYv9x/rbltDSTlRAQARsSIwiRzS7aWSWvF74Hbgm5JWa04pB2y6EvQeTg74Pgb4T0RMiIifkQfFSyWt113+tQ2+LidYl5L5x0TEUxFxXrTYsFg2TZqHnBZ7YrkyeBE5IchrABGxJznO89dxA11bmJbjFAfITSJpduALkpaQ9FlynvI/AE9J+nb5UF4L/Bj4ZDPL2ijl7Ptc8rLbgeT0soeSl2w2hLysI2nWVjkrlTQLsK+kBSR9SdK3IuLzZG70JQAR8QBwVbm11QQg8EGr/mrlRODjwG+BB4FFJH2ytBifSwbP50iaubQ429B5Cfh4SfMxaypJa0maIyIuIC+9P0LmF58UEadU1lsgInYExrbKMd16Nq3HKT6Da4LyoXpF0ptkEAWwXGkpnYEMDg+WdEpE/EHSDRHxevNKPPgquasvkVN0rkQOBfO/wEzAQZI+Sg6pM4Yc/aGpNLlX9otkvvRDZNoBETFK0s2SLo2ILcvlxYfa7UegtNRPB3yKPFlZLiKWlXQHeeJSm/Dk1oj4iaRfRodNaNAmXiJHsuioqYitbe0EXCxpmYg4U1Kt8eOftRUk7QRsJWnnGKIp523qOU5xC/KQUloG+G3J6XmK7PD0GNmTFzLN4EpgCTJ3C7LTV6eRpKXJ3N2/k3lrHybr/FvgMHIa6c/XOrs1k3IYs/2VUyxfQ05gMBt5uRCAiFiTnF76ovK43YLjDwPfiRxl43VyutuLSwv+W+QYwm8xeYZAyPQLG2Ild/PYyLFkzZoqIvYmj9t/Ly3JF5JXBW+WtJxymMKDgG/HNDhWcDtxnDKZR7FoAuVQWauSZ9eTyOG/tgT+JyJukvRxYHHgz9FmQ4L1pdbhrvL4eHLYn6+QZ6QbkePVnl3rFdvd/zVDya9aElia7FC4B9nCvV1E/F3SChFxt6TFWiFXur+UM1u9AyxCTrCxMNlC/iJwUekcthQ5wsip7drz3MwGTjlaxQiys92d5bmTgc8BK0cOBbkXOU34w8Cm0QJjo1t9puU4pcYpFkOoEuS9BKwBjANWiYhzlOPkHiHp3+QsZPtFm88Y1Z1yeWYtMrH/AOBXZEvlp8tlmtmBtckJJ16o/l8zygtT7LdXyVSQTYDXI+JsSTMCF0i6BNhd0ifaMTgGiIgnlZOa7AwsQAbCb5AHxs+VE4SZgKNrnW7MbNpTOlh/HVgP+JekO8nOyYeRIxHdKOmTEXGWpBfIDr4OjtuA45TJHCAPoRIcfgLYLCKOKP2abpa0RkScIukZchrlIzvtQ9elBfhJcji0rcjxW4eT6T43RMTFJZep6TlqlTIPk7QGOTHDmmSnwi+W5adLeoQc9H69iHiqeSUeGEmfKXdPAA4hO14cQE6XvRH5Y7i/g2OzaZekRYGnyT4KewCPkqNXLAX8Bfgpedy4U9LK4bG528q0HKd05QB5CJWe/u8Bi5bevEeXZPc/S1o3In4p6ZJ2y12tR+VLt2ZE/FDSOPKy27/JaaO3l/R+RBzXCsExTG61LsOY3STpRmC30ioyK/D50oJ8GXBls1NA+qubtJU1gdERsZGkY8kfwFPJSUG+K+kkB8dm0y5JI4BvAg8Ap5Ej93yWnKzmVPJYOA/wG3Jc+BHklTdrE9NynNKVO+kNEeW0lN8n83keITulERGHkweZ35URBDp5TNk3yCHSDibfg/3JA+vWZKvlX5pXtO5J2kXSdaXTwq3ACElzR8SPgXuBdYCZ2i04hsknAJK2lLRWRBwHPCTphyWn7GSyU96xyjFNO6qHspn123Pk1OYjgb2AG8jOWiPJfiQvRMQNwPbkZfkHm1NMmxqOU6bkTnpDoPQEPZ2cm/6n5KX6nwBXRBkjUtK8nXS5ouSrvhcRr5THKq3IcwNfJQ+0u5FfxH2BdyPi3VbojFdVDhinltui5FiPF0fEiWX53BExqYlF7LfKvhgOCLiHPFn+HXAWsAPwm8iZAkeS+dbukGc2jSoNBMMih68UOeX8Rky+Argm2YHrBeDciPDwg21mWoxT+uIUiwaTtAp50NgfeI0cJmVj4G1gB0m/jYiHySHNOkIZDeE24ATlOLnPlIBsuoiYpJxmdDHyvdgSmDciJkDzp4+ukbQ+MH9EXChpW3J0h1+RI218X9KjEXFJuwXHMMV7vFRE3CdpS/IHbzHgGHL4utmBv0bEI80ppZm1gjKawb3k7HhHka2HZwJzkqP67EsGVjOSHa6dhtVmpsU4pR4OkAdRN0OYzQnsDbxLzqj2S2B54K9kx4YfAG9C6wSGg2QWcsroNYDnJf0pIp4sLcTDIuJNcpal/ZWDjLfUbHPlEtIMwHdKr91x5BieF5Nn17uT+7AtlRagEcAVks4gx7l8i2wln4Gs346SvgNM6rDPppn1Q0Q8XxoM/kheaVqZbCx4lQygVgLeiYgzJN0UnjiorUzDcUqfnGIxiCTNHjnzjOCDjmkfIoORI8lBtZ8DfhAR10maMXICho5SLt3/iLzsdhNwB9mJ7ZnKOsMi4v1WSKmQtAmwcESc2eX5+YHjgLvJlu5LI+IESTNExNtNKOqAVFIran+XBzYAFgI2I2cG3DsinpI0Z3hAfzMrlOMe/5AMkEcA6wLbAqsBz5AdsH3MaGHd/AZoWo1T6uEAeZAoZwo6hRzl4PaSzxNdWpQPJafkfJMMHt+NnG657SlnxVsCuC8iHpU0LzlU2CTgo8B1ZC5TS+WyStqQPEPePyJurDw/PCLeU473uSo5IcgKwErRZtNpSloceJb8vr/e5QRuFnLM6SPIIZtOA75RRu4wM/tAaUw4GVgjIl4ofUqmB2ZxOlbrK8f7N4DZSmPeNBWn9JcD5EEi6TDgu+S0yQdGxF8qraTDawGHpI+QPX07ZorYMuTZJeQEHzeTQdad5JfsUjKndV9ylIrfRIsM4ybps8CF5KxwR5fnhtUOBt2kzCwYbTbOsaSNyc/lPWRr/jnk5dD/ar2XtAdwtTvYmFlPJG1EpmOtGRHTVE5qO5M0hhxdZC4yX/yHEfG7yvKOjlOmhgPkQSJpZnIWoRnJcSG/Ui5PTHEpo7mlHHzKcTE/Tnbc2AKYn5xI4xpysPhXyEtxGwFfJFsnm55zXALHY4FrybLfFBGXlmVdA8eWSQfpj1LHo4ADyQ54nycPkMOrI4ZUD4xmZn0po/uMBVadVlsX20m5UnoKOYLU2+SITKcCB0XEuZ0ep0wtd9IbAEkfA16KiIfIBPcgJ7/4BnCqpC9HxPgO/9DtRk4uMUZSkMOgzUG2Vi5ApiUsFBG/lXRzK6RYSFqC3Ef7lpb+fYCNym76TdcDRe0HoJ32oaRFgBOB30bELcrZ/k4CzgDekHReRPwNPpgIxcysLuV4/icHx62vtPifRf5OP1Bp8JkIjJP0dET8AdrrN24oeKKQqSRpKbLz2W8lbQ2MAo4np2CcSHbuOknS+p38oYuIY4HZJO1G9nK+jZw6+rMR8V1gH+CJsvpzzSnlZJJWBPYDNomI2sQkl5OTgGws6fPwQX6umlTMwfAWOfTScEn7kSkwJwLnk6NWHCppniaWz8zaWER4hrz2MCfZEbv2eza8XDX8Hdm3Zk9JM7f5711DOECeCsopkx8mOyssSE6t+VVyJqHbgZUj4gLyrG1sp374KnU6E1i+nAj8CbgaWELSkcCbUaakbJEThafI2e+WlDS8tBQ/BVxBBskbSvoitEx5+0XSjOXg9xw52PsD5NiWD0bEyZGzXF1BXvHo+KlCzcymRZLmlzR9RIwjO2DfLunT5fd4ePn9fgZ4KyLeaMffu0ZzgDx1vgocFhGHkNNsjiGDkCDzcdcpQcqPyZbKjvnwSRop6czSgj5LefoOYDNJnyvDwVxTbvORuU5NJ2kGSTNFxAvkcGazlNSCYQAR8TTZknwPsGYZvaKtlE6HPwKulPRTYJ2IOKM897pyQhCAD5MD/M/YnJKamVmjlLSKM8krhdNHxM/IBrzfSVorIt4uMcl8wCvl97HjGvEGyp30poKkrcgUgr3K48vIIVH2JGehWToi7m9iERtCOWlGkCM/PEXmGh8ZOf3oFsB2wFcj4klJ0wFzRQtMSylpBfJg8RI56ceeZAD/g8hJS6rrLgi8EREvDnlBB6B0wjiVvGQ2MzkT3qnAlyLigpJnvSJ5UrMisGdE3NWs8pqZ2eCTtClwNDm51XMRcU9l2W5kZ71PAIuT/VK29W9B9xwgT4XSuvhnYFzJwUXSJeR4kNtFGSe3kzrnKSeV+BFweOn0tSI5IsIm5CX718hOeWdHxL+bV9IpSVosIh5TTqW5IDm73+rklKi/B34LvEymV0yIiHebVtipVILjc8lOGPdVnh9DnhBsTXaa3AvYAdi9lfaRmZkNnKSRZH+T/SLi1srzBwLXRsRdknYlh/t8CNg8Iu5uQlHbglMs6iBpeUl71R6XzgkHAx+VtGR5bitymt6fVdbrlOB4OeDnZMtxbeSDuyLiMPJ9eJQMwr4MnNCscnZVLjP9RNJCEfGPiPh9RBwJ7EyOz/xLsgPDV4BDyfEh29F8ZMfImSHHs5Q0XemZ/G0yzed14AJgQwfHZmYdScDjZL7x9ACSxgLfB86WtHJEnEvODLuFg+PeOUDug3Ke8jHAppJukrSucmayP5OXq5eorRsRG5H5yR2j5CUdAvw6Is6JiLclzSVpPeWUy9dFxNnk2M/fIUfvaDrltKjHACeXlI9ZStpHzUrAPyPiRGA94JutkA4yNUqH0IOA8yVt0GXYttfJHsxExMR2Sx0xM7Peld83kf1K5gOIiHckzQc8HBFzABcB3yl9cS5zWkXfHCD34v/bu99QvesyjuPvD+EUVytTwUX/yKyFTJOmaEutICF6kD2QWRGiYSYY2LJtKPpkooErFhIMDEr6cygF50DBmU5XJM0WuiEpuRjmmOWcphZrun18cH1P/Vjn1NnY/N3nd39eD+/7bHw55+bmuq/7+l4fVazmt6n0t88D91Gd0glgMfA7YKUqbhMA2zum+r9mq9YF3wVsk3SMpJXULt2fUJfBTm4/twu42W3vc38nBkmfBu6iZqvub13+1VRYBm0X8x20Dze299j+e1/nPRSqgJZ/sz3Bf1YLXtAZFZkD7Djgw0FERAyAKhDqJmC+7Sep+0F3tm8Rn6fG7KC+6X2F1H0zll/UNNqg+03UhoZnAFxxxCuoy083UkPuZ1F55UP2GJUSuIka7r8HOAXYDtww+UMjFAIsTcgAAAVISURBVKixixo3eJ8qa/5nwFOuQJeuS9/0kx0GkhYAOyV974DRn58Cq4DvSjq9bbX4BnDbbJytjoiI6bU65WbgIWplG8CV1IX0dZLmUivdvgQsB26ZvCMV/18u6U1B0klUl3iZ7UclzaG+upgHvGj7n61z+l5qxvNK20/3d+IjT9KHgLdP/j7aqMVnqQjppaNWgLVd1euB/dSFhV90nltIXSrc6xGIvT5Ykt5DdQXWUTHef6U64g/bfrm9Ga4BXqDmjzNnFhExIFPUKUdTd1GOp7ZNXUuNEu6mxi6usL21r/PORvnadWr/okIU9kg6huoaf4LaUrFd0lLb24BtwIb+jnnkTW7i6G5HaMXxOcB3gGtHrTgGaG8Y5wEbqTcNACRdAlwMXOIRiL0+FLb/ImkTtXP7c9TYz1eBZZK+BfyWuoSxo7viJyIiBmOqOuVcqq77I/Xt4QlUsfya7Rf6OuhslRGLqb1EzRuvopLI3k917JZRL7bFvZ3sCJpMlus+duC4hKR5kr5OdSivt31P3zPH02mfli8AfiBpSZtNvgq4ZrYWx53f9XLqtXgCNXN2GvAE1TVYDjyS4jgiYrCmqlMmqDplLpXVsNP2cymOD01GLKbRdh0vpJLg7m4JcbSEsg1t3nMwJJ0CXEZ1Hzf+r0trbQfyUbYfmw27niUtouann6d2Bc/qwrEVyXOorSEfoDrJK2yvbX/HXbZf7POMERFxZI1bnfJmS4F8ECRdRHXnlrQRi0FoISA/puZY19ve0nlu5AvgmWhpevtsP9X3WQ6Xtp/618Cttlf2fZ6IiOjXUOuUPmQGeQZa/PASKolsUC86Se+i9iOusn175/HFwE7bf+4WyZLeYntf++S6yPZDvRz8IA3xopor4ns5ta3j2NxOjogYT0OuU/qSGeSZeQn4E5U8M7QUsuOpkYrbJ+dbJS2lYqWvl3TaFMXxO6h46YRO9O8R4GN9HyIiIno15DqlFxmxGHOSzqUu3H3K9t8kzaPGLdYAHwHmU7Ou+2zvb8XxL4EbbW/s6djRke5xRETE4ZUO8phqARoAW6jY7LNaofUylUC3nlo2Ppf6ILVf0tuAu0lxPFJSHEdERBxeKZDHjKQPSjqd2ulM21axHfgycL6k49qe47OBrwFrbe9t//w84JspjiMiImLIMmIxRloi4J3A2cAPgWdsr2nPXQ18FPgw8DAVNHGN7XVD2WQRERERMRPZYjFGWmd4A7U79z5gddub+xvbqyUdC5wP7AXusL05xXFERESMm4xYjJ/vA88CJ9o+A9hDJc39ihqheML2A7Y3w38n6UVEREQMXQrkgZN0oqR3twt22N4P/ByY3zZWfAG4DrgXuJi6lBcRERExtjKDPGCSFlAzx48CJwMX2t4taSG1jeI44Abbt7aff6ft3b0dOCIiImIEpIM8UC1aeQ01UnEFsBU4SdLRtrcCK4FNneJYKY4jIiIiUiAPkqSjgHXAq7ZvAwxcCKwANks6g+ogv94K6cwaR0RERDQpkAfI9mvAF6nwj6uAHwF3AZcCE9QGiz3A01TUdEREREQ0mUEeMEmLgPuBJ22f03l8ArjF9h96O1xERETEiEoHecBs/x74JLBA0uUAkj4OLAJe7/FoERERESMrQSEDZ/txSZ8B7m2zx6cCV9ve0vPRIiIiIkZSRizGhKQzgQeBr9he2/d5IiIiIkZVCuQxIumttl9NfHRERETE9DKDPF7+0fcBIiIiIkZdOsgRERERER3pIEdEREREdKRAjoiIiIjoSIEcEREREdGRAjkiIiIioiMFckRERERExxtvDiy7Pqxv4AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot with class weight balance \n",
    "fig, ax = plt.subplots(figsize =(10,5))\n",
    "ax.bar(x_pos, mean, yerr=std, align='center', alpha=0.5, ecolor='red', capsize=18)\n",
    "ax.set_ylabel('Accuracy')\n",
    "ax.set_xticks(x_pos)\n",
    "ax.set_xticklabels(models, rotation=45)\n",
    "ax.set_title('Accuracy and standard deviation of classifiers in predicting wildfires')\n",
    "ax.yaxis.grid(True)\n",
    "# Save the figure and show\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"accuracy_1\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More details on the result analysis can be found in my blogpost: https://sites.tufts.edu/olukunleowolabi/2020/03/15/a-comprehensive-classification-model-for-predicting-wildfires-with-uncertainty/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}