SVM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import stats\n",
    "import seaborn as sns\n",
    "import missingno as msno\n",
    "from collections import Counter\n",
    "from itertools import chain, combinations\n",
    "import sklearn as sk\n",
    "from sklearn.metrics import accuracy_score, f1_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SVM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we train an SVM on the MICE imputed dataset.  \n",
    "\n",
    "We first randomly shuffle and split the dataset into train and test sets and reduce them to the sizes of 400 and 200.  \n",
    "We the use Grid Search to adjust the C, gamma and kernel.  \n",
    "\n",
    "We then train and evaluate the SVM with those parameters on every single of our target variales separately. We also train it on has_dep_diag using class_weight for balancing.  \n",
    "We then plot the learning curve for the model.  \n",
    "\n",
    "We also try out NuSVC with no success.  \n",
    "\n",
    "We normalize the data and train an SVM on them oth without and with auto balancing.  \n",
    "Using random undersampling we obtain a balanced data subset. We run and SVM on it. We also run an SVM on this subset, but normalised.\n",
    "\n",
    "We apply PCA to the data and try to plot the decision boundaries.\n",
    "\n",
    "Then we plot the ROC curves for the combinations of:\n",
    "+ Imbalanced train set, imbalanced evaluation\n",
    "+ Balanced train set, imbalanced evaluation\n",
    "+ Imbalanced train set, balanced evaluation\n",
    "+ Balanced train set, balanced evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data0 = pd.read_csv(\"newdata3.csv\", engine='python')\n",
    "data1 = pd.read_csv(\"imputed_dataset_1.csv\", engine='python')\n",
    "data1.head()\n",
    "data2 = pd.read_csv(\"imputed_dataset_2.csv\", engine='python')\n",
    "data2.head()\n",
    "data3 = pd.read_csv(\"imputed_dataset_3.csv\", engine='python')\n",
    "data3.head()\n",
    "data4 = pd.read_csv(\"imputed_dataset_4.csv\", engine='python')\n",
    "data4.head()\n",
    "data5 = pd.read_csv(\"imputed_dataset_5.csv\", engine='python').drop(['Unnamed: 0'], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>weight_16</th>\n",
       "      <th>height_16</th>\n",
       "      <th>comp_noint_bed_16</th>\n",
       "      <th>comp_int_bed_16</th>\n",
       "      <th>talk_phon_wend</th>\n",
       "      <th>text_wend</th>\n",
       "      <th>talk_mob_wend</th>\n",
       "      <th>comp_wend</th>\n",
       "      <th>musi_wend</th>\n",
       "      <th>read_wend</th>\n",
       "      <th>...</th>\n",
       "      <th>anx_band_15</th>\n",
       "      <th>exercise</th>\n",
       "      <th>child_bull</th>\n",
       "      <th>has_dep_diag</th>\n",
       "      <th>secd_diag</th>\n",
       "      <th>prim_diag</th>\n",
       "      <th>panic_score</th>\n",
       "      <th>dep_thoughts</th>\n",
       "      <th>dep_score</th>\n",
       "      <th>comp_house</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>59.294132</td>\n",
       "      <td>181.602831</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.5</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>62.290242</td>\n",
       "      <td>168.453878</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>62.290242</td>\n",
       "      <td>168.453878</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>49.812426</td>\n",
       "      <td>160.224186</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>62.270030</td>\n",
       "      <td>191.703227</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>...</td>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 42 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   weight_16   height_16  comp_noint_bed_16  comp_int_bed_16  talk_phon_wend  \\\n",
       "0  59.294132  181.602831                0.0              0.0             1.0   \n",
       "1  62.290242  168.453878                0.0              0.0             1.0   \n",
       "2  62.290242  168.453878                0.0              0.0             1.0   \n",
       "3  49.812426  160.224186                0.0              0.0             1.0   \n",
       "4  62.270030  191.703227                1.0              0.0             0.0   \n",
       "\n",
       "   text_wend  talk_mob_wend  comp_wend  musi_wend  read_wend  ...  \\\n",
       "0        1.0            1.0        2.0        0.0        1.0  ...   \n",
       "1        1.0            1.0        2.0        0.0        1.0  ...   \n",
       "2        1.0            1.0        2.0        0.0        1.0  ...   \n",
       "3        2.0            1.0        2.0        0.0        1.0  ...   \n",
       "4        0.0            0.0        1.0        0.0        2.0  ...   \n",
       "\n",
       "   anx_band_15  exercise  child_bull  has_dep_diag  secd_diag  prim_diag  \\\n",
       "0          0.5       4.0         0.0           0.0        0.0        0.0   \n",
       "1          3.0       3.0         0.0           0.0        1.0        1.0   \n",
       "2          3.0       3.0         0.0           0.0        1.0        1.0   \n",
       "3          3.0       3.0         0.0           0.0        0.0        1.0   \n",
       "4          3.0       3.0         0.0           0.0        1.0        1.0   \n",
       "\n",
       "   panic_score  dep_thoughts  dep_score  comp_house  \n",
       "0          0.0           1.0        0.0         1.0  \n",
       "1          0.0           3.0        1.0         0.0  \n",
       "2          0.0           3.0        1.0         0.0  \n",
       "3          0.0           2.0        0.0         0.0  \n",
       "4          0.0           3.0        0.0         0.0  \n",
       "\n",
       "[5 rows x 42 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data5.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare the data:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Separate target from data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(13734, 36)\n",
      "(13734, 5)\n"
     ]
    }
   ],
   "source": [
    "X = data5.drop(['has_dep_diag'],axis=1).drop(['secd_diag'],axis=1).drop(['prim_diag'],axis=1).drop(['dep_score'],axis=1).drop(['dep_thoughts'],axis=1).drop(['panic_score'], axis=1)\n",
    "print(X.shape)\n",
    "Y = np.column_stack((data5['has_dep_diag'], data5['secd_diag'], data5['prim_diag'], data5['dep_score'], data5['dep_thoughts']))\n",
    "print(Y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Randomly shuffle the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import shuffle\n",
    "\n",
    "def shuffle_dataset(N, X, y, X_shuffled, y_shuffled):\n",
    "    ind_list = [i for i in range(N)]\n",
    "    shuffle(ind_list)\n",
    "    X_shuffled  = X.iloc[ind_list]\n",
    "    y_shuffled = y.iloc[ind_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_shuffled = X\n",
    "y_shuffled = Y\n",
    "shuffle_dataset(13734, pd. DataFrame(X), pd. DataFrame(Y), pd. DataFrame(X_shuffled), pd. DataFrame(y_shuffled))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train-test split."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9613, 36)\n",
      "(4121, 36)\n",
      "(9613, 5)\n",
      "(4121, 5)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_shuffled, y_shuffled,test_size=0.3, random_state=40)\n",
    "print(X_train.shape); print(X_test.shape)\n",
    "print(y_train.shape); print(y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reduce the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(400, 36)\n",
      "(200, 36)\n",
      "(400, 5)\n",
      "(200, 5)\n"
     ]
    }
   ],
   "source": [
    "X_train_reduced, y_train_reduced = X_train[0:400], y_train[0:400]\n",
    "X_test_reduced, y_test_reduced = X_test[0:200], y_test[0:200]\n",
    "print(X_train_reduced.shape); print(X_test_reduced.shape)\n",
    "print(y_train_reduced.shape); print(y_test_reduced.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({0.0: 381, 1.0: 19})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "Counter(y_train_reduced[:,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train model:\n",
    "####  Imputed dataset 5, for has_dep_diag "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import svm\n",
    "from sklearn.svm import SVC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tune hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 40 candidates, totalling 200 fits\n",
      "{'C': 5, 'gamma': 'auto', 'kernel': 'rbf'}\n",
      "0.5481230351851158\n",
      "0.5125063309072234\n",
      "0.5481230351851158\n",
      "0.5125063309072234\n",
      "39.29264523599704 mins\n"
     ]
    }
   ],
   "source": [
    "## on f1 macro\n",
    "import time\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "start = time.perf_counter()\n",
    "\n",
    "param_grid = {\n",
    "    'C': [0.1,1, 5, 10, 100], \n",
    "    'gamma': ['scale', 'auto'],\n",
    "    'kernel': ['rbf', 'sigmoid', 'linear', 'poly']\n",
    "}\n",
    "tuned_svm = GridSearchCV(SVC(), param_grid, cv = 5, scoring='f1_macro' , verbose = 2, n_jobs=-1)\n",
    "tuned_svm.fit(X_train_reduced, y_train_reduced[:,0])\n",
    "\n",
    "end = time.perf_counter()\n",
    "\n",
    "params = tuned_svm.best_params_\n",
    "\n",
    "print(params)\n",
    "print(tuned_svm.score(X_train,y_train[:,0]))\n",
    "print(tuned_svm.score(X_test,y_test[:,0]))\n",
    "y_pred = tuned_svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,0], average = \"macro\"))\n",
    "y_pred_test = tuned_svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,0], average = \"macro\"))\n",
    "\n",
    "\n",
    "print(str((end - start)) + ' mins')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic SVM, with accuracy and f1-score:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "bar_x = np.array([0, 1, 2, 3, 4])\n",
    "bar_y = np.array([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.9835639238531155\n",
      "SVM classifier accuracy - test set: 0.9716088328075709\n",
      "0.7973116592095809\n",
      "0.4928\n"
     ]
    }
   ],
   "source": [
    "##imbalanced\n",
    "#svm = SVC(C=0.1, gamma='scale', kernel='linear')\n",
    "svm = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm.fit(X_train, y_train[:,0])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,0])}')\n",
    "\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,0], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,0], average = \"macro\"))\n",
    "\n",
    "bar_y = np.append(bar_y, f1_score(y_pred_test, y_test[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.9766982211588474\n",
      "SVM classifier accuracy - test set: 0.9378791555447706\n",
      "0.8488531348919115\n",
      "0.5514588336133768\n"
     ]
    }
   ],
   "source": [
    "##auto balancing\n",
    "#svm = SVC(C=0.1, gamma='scale', kernel='linear', class_weight = 'balanced')\n",
    "svm = SVC(C=5, gamma='auto', kernel='rbf', class_weight = 'balanced')\n",
    "svm.fit(X_train, y_train[:,0])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,0])}')\n",
    "\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,0], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### All the other targets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.9288463538957662\n",
      "SVM classifier accuracy - test set: 0.8371754428536763\n",
      "0.7299424596417491\n",
      "0.21216648388671538\n"
     ]
    }
   ],
   "source": [
    "#svm = SVC(C=0.1, gamma='scale', kernel='linear')\n",
    "svm = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm.fit(X_train, y_train[:,1])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,1])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,1])}')\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,1], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,1], average = \"macro\"))\n",
    "\n",
    "bar_y = np.append(bar_y, f1_score(y_pred_test, y_test[:,1], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.9025278269010715\n",
      "SVM classifier accuracy - test set: 0.7279786459597185\n",
      "0.7748325247953213\n",
      "0.1491549080150774\n"
     ]
    }
   ],
   "source": [
    "#svm = SVC(C=0.1, gamma='scale', kernel='linear')\n",
    "svm = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm.fit(X_train, y_train[:,2])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,2])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,2])}')\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,2], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,2], average = \"macro\"))\n",
    "\n",
    "bar_y = np.append(bar_y, f1_score(y_pred_test, y_test[:,2], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.9288463538957662\n",
      "SVM classifier accuracy - test set: 0.8410579956321281\n",
      "0.805389018960321\n",
      "0.34309855644252973\n"
     ]
    }
   ],
   "source": [
    "#svm = SVC(C=0.1, gamma='scale', kernel='linear')\n",
    "svm = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm.fit(X_train, y_train[:,3])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,3])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,3])}')\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,3], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,3], average = \"macro\"))\n",
    "\n",
    "bar_y = np.append(bar_y, f1_score(y_pred_test, y_test[:,3], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.7086237386871944\n",
      "SVM classifier accuracy - test set: 0.6993448192186362\n",
      "0.3882198387456414\n",
      "0.346648460891229\n"
     ]
    }
   ],
   "source": [
    "#svm = SVC(C=0.1, gamma='scale', kernel='linear')\n",
    "svm = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm.fit(X_train_reduced, y_train_reduced[:,4])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,4])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,4])}')\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,4], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,4], average = \"macro\"))\n",
    "\n",
    "bar_y = np.append(bar_y, f1_score(y_pred_test, y_test[:,4], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(bar_x, bar_y)\n",
    "plt.title('SVM performance with different target variables')\n",
    "plt.xlabel('target variables')\n",
    "plt.ylabel('F1 score')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import learning_curve\n",
    "\n",
    "#plot learning curve function from the labs\n",
    "def plot_learning_curve(n, est, xs, ys, title):\n",
    "    train_sizes, train_scores, valid_scores = learning_curve(estimator = est, X = xs, y = ys, cv = n)\n",
    "\n",
    "    train_mean = np.mean(train_scores, axis=1)\n",
    "    valid_mean = np.mean(valid_scores, axis=1)\n",
    "\n",
    "    plt.plot(train_sizes, train_mean, color='blue', label='Training Accuracy')\n",
    "    plt.plot(train_sizes, valid_mean, color='green', label='Validation Accuracy')\n",
    "\n",
    "    plt.xlabel('Dataset size')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.title(title)\n",
    "    plt.legend()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_learning_curve(5, SVC(C=5, gamma='auto', kernel='rbf'),X_train_reduced, y_train_reduced[:,0], 'SVM learning curve')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tune hypermarameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 20 candidates, totalling 100 fits\n",
      "{'C': 0.1, 'gamma': 'scale', 'kernel': 'rbf'}\n",
      "0.9710808280453552\n",
      "0.9728221305508372\n",
      "0.492664133417775\n",
      "0.49311193111931123\n",
      "0.17924579999998969 mins\n"
     ]
    }
   ],
   "source": [
    "##on accuracy\n",
    "import time\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "start = time.perf_counter()\n",
    "\n",
    "param_grid = {\n",
    "    'C': [0.1,1, 5, 10, 100], \n",
    "    'gamma': ['scale', 'auto'],\n",
    "    'kernel': ['rbf', 'sigmoid']\n",
    "}\n",
    "tuned_svm = GridSearchCV(SVC(), param_grid, cv = 5, scoring='accuracy', verbose = 2, n_jobs=-1)\n",
    "tuned_svm.fit(X_train_reduced, y_train_reduced[:,0])\n",
    "\n",
    "end = time.perf_counter()\n",
    "\n",
    "params = tuned_svm.best_params_\n",
    "\n",
    "print(params)\n",
    "print(tuned_svm.score(X_train,y_train[:,0]))\n",
    "print(tuned_svm.score(X_test,y_test[:,0]))\n",
    "y_pred = tuned_svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,0], average = \"macro\"))\n",
    "y_pred_test = tuned_svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,0], average = \"macro\"))\n",
    "print(str((end - start)) + ' mins')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NuSVC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.6799126183293457\n",
      "SVM classifier accuracy - test set: 0.6915797136617325\n",
      "0.4509202948812156\n",
      "0.4484762205109116\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import NuSVC\n",
    "## the largst nu I was allowed\n",
    "svm = NuSVC(nu = 0.05)\n",
    "svm.fit(X_train, y_train[:,0])\n",
    "\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,0])}')\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,0], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## On normalized data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.31011812 0.94981285 0.         0.         0.00523017 0.00523017\n",
      " 0.00523017 0.01046033 0.         0.00523017 0.01046033 0.00523017\n",
      " 0.         0.00523017 0.01046033 0.01046033 0.00523017 0.\n",
      " 0.         0.00523017 0.01046033 0.         0.00523017 0.01046033\n",
      " 0.00523017 0.         0.00523017 0.01046033 0.01046033 0.00523017\n",
      " 0.         0.00261508 0.00261508 0.02092066 0.         0.00523017]\n",
      "[0. 0. 0. 0. 1.]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import preprocessing\n",
    "\n",
    "normalized_data = preprocessing.normalize(X_shuffled)\n",
    "normalized_target = preprocessing.normalize(y_shuffled)\n",
    "print(normalized_data[0,:])\n",
    "print(normalized_target[0,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9613, 36)\n",
      "(4121, 36)\n",
      "(9613, 5)\n",
      "(4121, 5)\n",
      "(400, 36)\n",
      "(200, 36)\n",
      "(400, 5)\n",
      "(200, 5)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train_norm, X_test_norm, y_train_norm, y_test_norm = train_test_split(normalized_data, y_shuffled,test_size=0.3, random_state=40)\n",
    "print(X_train_norm.shape); print(X_test_norm.shape)\n",
    "print(y_train_norm.shape); print(y_test_norm.shape)\n",
    "X_train_reduced_norm, y_train_reduced_norm = X_train_norm[0:400], y_train_norm[0:400]\n",
    "X_test_reduced_norm, y_test_reduced_norm = X_test_norm[0:200], y_test_norm[0:200]\n",
    "print(X_train_reduced_norm.shape); print(X_test_reduced_norm.shape)\n",
    "print(y_train_reduced_norm.shape); print(y_test_reduced_norm.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.9710808280453552\n",
      "SVM classifier accuracy - test set: 0.9728221305508372\n",
      "0.492664133417775\n",
      "0.49311193111931123\n"
     ]
    }
   ],
   "source": [
    "##imbalanced\n",
    "svm_norm = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm_norm.fit(X_train_norm, y_train_norm[:,0])\n",
    "print(f'SVM classifier accuracy: {svm_norm.score(X_train_norm, y_train_norm[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm_norm.score(X_test_norm, y_test_norm[:,0])}')\n",
    "\n",
    "y_pred_norm = svm_norm.predict(X_train_norm)\n",
    "print(f1_score(y_pred_norm, y_train_norm[:,0], average = \"macro\"))\n",
    "y_pred_test_norm = svm_norm.predict(X_test_norm)\n",
    "print(f1_score(y_pred_test_norm, y_test_norm[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.959117861229585\n",
      "SVM classifier accuracy - test set: 0.9602038340208687\n",
      "0.525010532874828\n",
      "0.5185720228631346\n"
     ]
    }
   ],
   "source": [
    "##auto balancing\n",
    "##has_dep_diag\n",
    "svm_norm = SVC(C=5, gamma='auto', kernel='rbf', class_weight = 'balanced')\n",
    "svm_norm.fit(X_train_norm, y_train_norm[:,0])\n",
    "print(f'SVM classifier accuracy: {svm_norm.score(X_train_norm, y_train_norm[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm_norm.score(X_test_norm, y_test_norm[:,0])}')\n",
    "\n",
    "y_pred_norm = svm_norm.predict(X_train_norm)\n",
    "print(f1_score(y_pred_norm, y_train_norm[:,0], average = \"macro\"))\n",
    "y_pred_test_norm = svm_norm.predict(X_test_norm)\n",
    "print(f1_score(y_pred_test_norm, y_test_norm[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### other targets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.8667429522521586\n",
      "SVM classifier accuracy - test set: 0.8240718272264014\n",
      "0.788654709695681\n",
      "0.21549902470429322\n"
     ]
    }
   ],
   "source": [
    "##auto balancing\n",
    "##secd_diag\n",
    "svm = SVC(C=5, gamma='auto', kernel='rbf', class_weight = 'balanced')\n",
    "svm.fit(X_train, y_train[:,1])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,1])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,1])}')\n",
    "\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,1], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,1], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.8211796525538334\n",
      "SVM classifier accuracy - test set: 0.6753215239019655\n",
      "0.7816698968147355\n",
      "0.19502957010049057\n"
     ]
    }
   ],
   "source": [
    "##auto balancing\n",
    "##prim_diag\n",
    "svm = SVC(C=5, gamma='auto', kernel='rbf', class_weight = 'balanced')\n",
    "svm.fit(X_train, y_train[:,2])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,2])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,2])}')\n",
    "\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,2], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,2], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.8955580984084053\n",
      "SVM classifier accuracy - test set: 0.8352341664644504\n",
      "0.8573057565059617\n",
      "0.376113890185654\n"
     ]
    }
   ],
   "source": [
    "##auto balancing\n",
    "##dep_score\n",
    "svm = SVC(C=5, gamma='auto', kernel='rbf', class_weight = 'balanced')\n",
    "svm.fit(X_train, y_train[:,3])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,3])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,3])}')\n",
    "\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,3], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,3], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.8944138146260272\n",
      "SVM classifier accuracy - test set: 0.7359864110652754\n",
      "0.8497689347848918\n",
      "0.3990067262044544\n"
     ]
    }
   ],
   "source": [
    "##auto balancing\n",
    "##dep_thoughts\n",
    "svm = SVC(C=5, gamma='auto', kernel='rbf', class_weight = 'balanced')\n",
    "svm.fit(X_train, y_train[:,4])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,4])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,4])}')\n",
    "\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,4], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,4], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random over and undersampling:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(400, 36)\n",
      "(400, 5)\n",
      "(200, 36)\n",
      "(200, 36)\n",
      "(200, 5)\n",
      "(200, 5)\n"
     ]
    }
   ],
   "source": [
    "from itertools import chain, combinations\n",
    "from scipy import stats\n",
    "#dep = np.random.choice(df,replace = False, size = n)\n",
    "dep = data5.query('has_dep_diag in [1.0]')\n",
    "dep = dep.sample(n = 200, random_state = 1)\n",
    "no_dep = data5.query('has_dep_diag in [0.0]')\n",
    "no_dep = no_dep.sample(n = 200, random_state = 1)\n",
    "\n",
    "balanced = dep.append(no_dep)\n",
    "\n",
    "Xb = balanced.drop(['has_dep_diag'],axis=1).drop(['secd_diag'],axis=1).drop(['prim_diag'],axis=1).drop(['dep_score'],axis=1).drop(['dep_thoughts'],axis=1).drop(['panic_score'], axis=1)\n",
    "print(Xb.shape)\n",
    "Yb = np.column_stack((balanced['has_dep_diag'], balanced['secd_diag'], balanced['prim_diag'], balanced['dep_score'], balanced['dep_thoughts']))\n",
    "print(Yb.shape)\n",
    "\n",
    "Xb_shuffled = Xb\n",
    "yb_shuffled = Yb\n",
    "shuffle_dataset(200, pd. DataFrame(Xb), pd. DataFrame(Yb), pd. DataFrame(Xb_shuffled), pd. DataFrame(yb_shuffled))\n",
    "\n",
    "Xb_train, Xb_test, yb_train, yb_test = train_test_split(Xb_shuffled, yb_shuffled,test_size=0.5, random_state=40)\n",
    "print(Xb_train.shape); print(Xb_test.shape)\n",
    "print(yb_train.shape); print(yb_test.shape)\n",
    "#def random_sampling(df, n):\n",
    " #   random_sample = np.random.choice(df,replace = False, size = n)\n",
    "  #  return(random_sample)\n",
    "#randomSample = random_sampling(population_df, N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.985\n",
      "SVM classifier accuracy - test set: 0.68\n",
      "0.9849906191369606\n",
      "0.6791979949874686\n"
     ]
    }
   ],
   "source": [
    "svm_b = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm_b.fit(Xb_train, yb_train[:,0])\n",
    "print(f'SVM classifier accuracy: {svm_b.score(Xb_train, yb_train[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm_b.score(Xb_test, yb_test[:,0])}')\n",
    "\n",
    "y_pred = svm_b.predict(Xb_train)\n",
    "print(f1_score(y_pred, yb_train[:,0], average = \"macro\"))\n",
    "y_pred_test = svm_b.predict(Xb_test)\n",
    "print(f1_score(y_pred_test, yb_test[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.6494330593987309\n",
      "SVM classifier accuracy - test set: 0.6561514195583596\n",
      "0.4493106857879846\n",
      "0.4470988691457688\n"
     ]
    }
   ],
   "source": [
    "print(f'SVM classifier accuracy: {svm_b.score(X_train, y_train[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm_b.score(X_test, y_test[:,0])}')\n",
    "\n",
    "y_pred = svm_b.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,0], average = \"macro\"))\n",
    "y_pred_test = svm_b.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### random sample + normalisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.33008443 0.93922408 0.         0.00569745 0.00569745 0.01139489\n",
      " 0.00569745 0.01139489 0.         0.00569745 0.00569745 0.00569745\n",
      " 0.00569745 0.00569745 0.01139489 0.00569745 0.00569745 0.00569745\n",
      " 0.00569745 0.00569745 0.01139489 0.         0.00569745 0.00569745\n",
      " 0.00569745 0.00569745 0.00569745 0.01139489 0.00569745 0.00569745\n",
      " 0.         0.00284872 0.08546168 0.01709234 0.         0.        ]\n",
      "[0.09128709 0.09128709 0.91287093 0.27386128 0.27386128]\n",
      "(200, 36)\n",
      "(200, 36)\n",
      "(200, 5)\n",
      "(200, 5)\n",
      "(200, 36)\n",
      "(200, 36)\n",
      "(200, 5)\n",
      "(200, 5)\n"
     ]
    }
   ],
   "source": [
    "normalized_data = preprocessing.normalize(Xb_shuffled)\n",
    "normalized_target = preprocessing.normalize(yb_shuffled)\n",
    "print(normalized_data[0,:])\n",
    "print(normalized_target[0,:])\n",
    "\n",
    "X_train_norm, X_test_norm, y_train_norm, y_test_norm = train_test_split(normalized_data, yb_shuffled,test_size=0.5, random_state=40)\n",
    "print(X_train_norm.shape); print(X_test_norm.shape)\n",
    "print(y_train_norm.shape); print(y_test_norm.shape)\n",
    "X_train_reduced_norm, y_train_reduced_norm = X_train_norm[0:400], y_train_norm[0:400]\n",
    "X_test_reduced_norm, y_test_reduced_norm = X_test_norm[0:200], y_test_norm[0:200]\n",
    "print(X_train_reduced_norm.shape); print(X_test_reduced_norm.shape)\n",
    "print(y_train_reduced_norm.shape); print(y_test_reduced_norm.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.505\n",
      "SVM classifier accuracy - test set: 0.495\n",
      "0.3355481727574751\n",
      "0.33110367892976583\n"
     ]
    }
   ],
   "source": [
    "svm_norm = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm_norm.fit(X_train_norm, y_train_norm[:,0])\n",
    "print(f'SVM classifier accuracy: {svm_norm.score(X_train_norm, y_train_norm[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm_norm.score(X_test_norm, y_test_norm[:,0])}')\n",
    "\n",
    "y_pred_norm = svm_norm.predict(X_train_norm)\n",
    "print(f1_score(y_pred_norm, y_train_norm[:,0], average = \"macro\"))\n",
    "y_pred_test_norm = svm_norm.predict(X_test_norm)\n",
    "print(f1_score(y_pred_test_norm, y_test_norm[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decision Boundaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SVC on the deataset with reduced dimensionality (PCA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.9525\n",
      "SVM classifier accuracy - test set: 0.98\n",
      "0.48783610755441736\n",
      "0.494949494949495\n"
     ]
    }
   ],
   "source": [
    "#non-normalized\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "pca = PCA(n_components=2)\n",
    "X_pca = pca.fit_transform(X_train_reduced)\n",
    "X_test_pca = pca.fit_transform(X_test_reduced)\n",
    "\n",
    "svm_pca = SVC(C=0.1, gamma='scale', kernel='linear', class_weight = 'balanced')\n",
    "svm_pca.fit(X_pca, y_train_reduced[:,0])\n",
    "print(f'SVM classifier accuracy: {svm_pca.score(X_pca, y_train_reduced[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm_pca.score(X_test_pca, y_test_reduced[:,0])}')\n",
    "y_pred = svm_pca.predict(X_pca)\n",
    "print(f1_score(y_pred, y_train_reduced[:,0], average = \"macro\"))\n",
    "y_pred_test = svm_pca.predict(X_test_pca)\n",
    "print(f1_score(y_pred_test, y_test_reduced[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.53\n",
      "SVM classifier accuracy - test set: 0.525\n",
      "0.3967398280066743\n",
      "0.39395872539950877\n"
     ]
    }
   ],
   "source": [
    "#normalized\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "pca = PCA(n_components=2)\n",
    "X_pca = pca.fit_transform(X_train_reduced_norm)\n",
    "X_test_pca = pca.fit_transform(X_test_reduced_norm)\n",
    "\n",
    "svm_pca = SVC(C=5, gamma='auto', kernel='rbf', class_weight = 'balanced')\n",
    "svm_pca.fit(X_pca, y_train_reduced_norm[:,0])\n",
    "print(f'SVM classifier accuracy: {svm_pca.score(X_pca, y_train_reduced_norm[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm_pca.score(X_test_pca, y_test_reduced_norm[:,0])}')\n",
    "y_pred = svm_pca.predict(X_pca)\n",
    "print(f1_score(y_pred, y_train_reduced_norm[:,0], average = \"macro\"))\n",
    "y_pred_test = svm_pca.predict(X_test_pca)\n",
    "print(f1_score(y_pred_test, y_test_reduced_norm[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "def plot_decision_boundaries(X, y, model, title):\n",
    "    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n",
    "    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n",
    "    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))\n",
    "    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])\n",
    "    Z = Z.reshape(xx.shape)\n",
    "    colors = {0.0:'red', 1.0:'green'}  \n",
    "    print(Z.shape)\n",
    "    print(Z.ravel().shape)\n",
    "    print(X[:, 0].shape)\n",
    "    print(X[:, 1].shape)\n",
    "    \n",
    "    colored_labels = np.array([colors[xi] for xi in y]) #Z.ravel()\n",
    "    plt.contourf(xx, yy, Z, cmap='viridis')\n",
    "\n",
    "\n",
    "    cb = plt.colorbar()\n",
    "    plt.xlim(xx.min(), xx.max())\n",
    "    plt.ylim(yy.min(), yy.max())\n",
    "    plt.xlabel(\"PC1\")\n",
    "    plt.ylabel(\"PC2\")\n",
    "    plt.title(title)\n",
    "    plt.scatter(X[:, 0], X[:, 1], c=colored_labels, cmap='viridis', s=10)\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(24, 25)\n",
      "(600,)\n",
      "(200,)\n",
      "(200,)\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "'c' argument has 400 elements, which is inconsistent with 'x' and 'y' with size 200.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-53-bc66454c0451>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m##can break the whole notebook on the non-normalized PCA\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mplot_decision_boundaries\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_pca\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train_reduced\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msvm_pca\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Decision Boundaries'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-52-a016c452da2f>\u001b[0m in \u001b[0;36mplot_decision_boundaries\u001b[0;34m(X, y, model, title)\u001b[0m\n\u001b[1;32m     22\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"PC2\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 24\u001b[0;31m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcolored_labels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'viridis'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\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     25\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     26\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\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[0;32m~/anaconda3/lib/python3.8/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, verts, edgecolors, plotnonfinite, data, **kwargs)\u001b[0m\n\u001b[1;32m   2888\u001b[0m         \u001b[0mverts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeprecation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_deprecated_parameter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2889\u001b[0m         edgecolors=None, *, plotnonfinite=False, data=None, **kwargs):\n\u001b[0;32m-> 2890\u001b[0;31m     __ret = gca().scatter(\n\u001b[0m\u001b[1;32m   2891\u001b[0m         \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2892\u001b[0m         \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmax\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlinewidths\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlinewidths\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.8/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1436\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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   1437\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1438\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msanitize_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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   1439\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1440\u001b[0m         \u001b[0mbound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_sig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.8/site-packages/matplotlib/cbook/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m    409\u001b[0m                          \u001b[0;32melse\u001b[0m \u001b[0mdeprecation_addendum\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    410\u001b[0m                 **kwargs)\n\u001b[0;32m--> 411\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\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    412\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    413\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.8/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, verts, edgecolors, plotnonfinite, **kwargs)\u001b[0m\n\u001b[1;32m   4449\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   4450\u001b[0m         \u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0medgecolors\u001b[0m \u001b[0;34m=\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4451\u001b[0;31m             self._parse_scatter_color_args(\n\u001b[0m\u001b[1;32m   4452\u001b[0m                 \u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0medgecolors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   4453\u001b[0m                 get_next_color_func=self._get_patches_for_fill.get_next_color)\n",
      "\u001b[0;32m~/anaconda3/lib/python3.8/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36m_parse_scatter_color_args\u001b[0;34m(c, edgecolors, kwargs, xsize, get_next_color_func)\u001b[0m\n\u001b[1;32m   4305\u001b[0m                     \u001b[0;31m# NB: remember that a single color is also acceptable.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   4306\u001b[0m                     \u001b[0;31m# Besides *colors* will be an empty array if c == 'none'.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4307\u001b[0;31m                     \u001b[0;32mraise\u001b[0m \u001b[0minvalid_shape_exception\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxsize\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   4308\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   4309\u001b[0m             \u001b[0mcolors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m  \u001b[0;31m# use cmap, norm after collection is created\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: 'c' argument has 400 elements, which is inconsistent with 'x' and 'y' with size 200."
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "##can break the whole notebook on the non-normalized PCA\n",
    "plot_decision_boundaries(X_pca, y_train_reduced[:,0], svm_pca, 'Decision Boundaries')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC Curves"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imbalanced train set, imbalanced evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.9835639238531155\n",
      "SVM classifier accuracy - test set: 0.9716088328075709\n",
      "0.7973116592095809\n",
      "0.4928\n"
     ]
    }
   ],
   "source": [
    "svm = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm.fit(X_train, y_train[:,0])\n",
    "print(f'SVM classifier accuracy: {svm.score(X_train, y_train[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(X_test, y_test[:,0])}')\n",
    "\n",
    "y_pred = svm.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,0], average = \"macro\"))\n",
    "y_pred_test = svm.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA4UUlEQVR4nO3dd3gU1dfA8e8h9K4QQenSpAcIIL1LVbDQFKxIsQKCoMhPX3vvCCgiKggqSlFpFgJI75CEIgJCqKFILynn/WMGWWOyWUI2m3I+z7NPdnbuzJy5SebMvTN7R1QVY4wxJinZAh2AMcaY9M0ShTHGGK8sURhjjPHKEoUxxhivLFEYY4zxyhKFMcYYryxRmMsiIhEi0iLQcaQXIvK0iIwP0LYnisiLgdh2ahORu0RkfgqXtb9JP7NEkYGJyC4ROSsip0TkgHvgyO/PbapqNVUN8+c2LhKRXCLyiojsdvfzDxEZJiKSFttPJJ4WIhLl+Zmqvqyqff20PRGRx0QkXEROi0iUiHwrIjX8sb2UEpHnRGTSlaxDVSer6k0+bOs/yTEt/yazKksUGd/NqpofCAFqA08FNpzLJyLZk5j1LdAa6AgUAPoA/YD3/BCDiEh6+394D3gceAy4GqgEzAA6pfaGvPwO/C6Q2zY+UlV7ZdAXsAto4zH9OvCTx/SNwFLgb2AD0MJj3tXAZ8A+4Bgww2NeZ2C9u9xSoGbCbQLXAWeBqz3m1QYOAznc6fuBze765wFlPMoq8DDwB7AzkX1rDZwDSiX4vAEQB1Rwp8OAV4CVwHFgZoKYvNVBGPASsMTdlwrAfW7MJ4EdQH+3bD63TDxwyn1dBzwHTHLLlHX36x5gt1sXIz22lwf43K2PzcCTQFQSv9uK7n7W9/L7nwiMBn5y410BlPeY/x6wBzgBrAGaesx7DpgGTHLn9wXqA8vcutoPfAjk9FimGvAzcBQ4CDwNtAcuADFunWxwyxYCPnXXsxd4EQhy593r1vk77rpedD/73Z0v7rxD7u90I1Ad5yQhxt3eKeCHhP8HQJAb159unawhwd+QvVJwrAl0APa6gl/ev/9BSgKbgPfc6RLAEZyz8WxAW3c62J3/E/A1cBWQA2jufl7H/Qdt4P7T3eNuJ1ci2/wNeNAjnjeAse77rsB2oAqQHXgGWOpRVt2DztVAnkT27VVgYRL7/ReXDuBh7oGoOs7B/DsuHbiTq4MwnAN6NTfGHDhn6+Xdg1Vz4AxQxy3fggQHdhJPFJ/gJIVawHmgiuc+uXVeEucAmFSiGAD8lczvfyLOgba+G/9kYKrH/N5AEXfeE8ABILdH3DHu7ymbG29dnMSa3d2XzcAgt3wBnIP+E0Bud7pBwjrw2PYMYJz7O7kGJ5Ff/J3dC8QCj7rbysO/E0U7nAN8Yff3UAW41mOfX/TyfzAM5/+gsrtsLaBIoP9XM/or4AHY6wp+ec4/yCmcMycFfgUKu/OGA18mKD8P58B/Lc6Z8VWJrHMM8EKCz7ZyKZF4/lP2BX5z3wvO2Wszd3oO8IDHOrLhHHTLuNMKtPKyb+M9D3oJ5i3HPVPHOdi/6jGvKs4ZZ5C3OvBY9vlk6ngG8Lj7vgW+JYqSHvNXAj3d9zuAdh7z+iZcn8e8kcDyZGKbCIz3mO4IbPFS/hhQyyPuRcmsfxAw3X3fC1iXRLl/6sCdLoaTIPN4fNYLWOC+vxfYnWAd93IpUbQCtuEkrWyJ7LO3RLEV6HKl/1v2+vcrvfXJmsvXVVUL4BzEbgCKup+XAbqJyN8XX0ATnCRRCjiqqscSWV8Z4IkEy5XC6WZJaBrQUESuA5rhHCQXe6znPY91HMVJJiU8lt/jZb8Ou7Em5lp3fmLr+QunZVAU73WQaAwi0kFElovIUbd8Ry7Vqa8OeLw/A1y8weC6BNvztv9HSHr/fdkWIvKEiGwWkePuvhTi3/uScN8riciP7o0RJ4CXPcqXwunO8UUZnN/Bfo96H4fTskh0255U9Tecbq/RwEER+VhECvq47cuJ0/jIEkUmoaoLcc623nQ/2oNzNl3Y45VPVV91510tIoUTWdUe4KUEy+VV1SmJbPNvYD7QHbgTmKLuaZ27nv4J1pNHVZd6rsLLLv0CNBCRUp4fikh9nIPBbx4fe5YpjdOlcjiZOvhPDCKSC6fr6k2gmKoWBmbjJLjk4vXFfpwup8TiTuhXoKSIhKZkQyLSFKdF1R2n5VgYp7/f846xhPszBtgCVFTVgjh9/RfL78HpkktMwvXswWlRFPWo94KqWs3LMv9eoer7qloXp1uwEk6XUrLLJROnSSFLFJnLu0BbEQnBuUh5s4i0E5EgEcnt3t5ZUlX343QNfSQiV4lIDhFp5q7jE2CAiDRw7wTKJyKdRKRAEtv8CrgbuN19f9FY4CkRqQYgIoVEpJuvO6Kqv+AcLL8TkWruPtyI0w8/RlX/8CjeW0Sqikhe4HlgmqrGeauDJDabE8gFRAOxItIB8Lxl8yBQREQK+bofCXyDUydXiUgJ4JGkCrr79xEwxY05pxt/TxEZ4cO2CuBcB4gGsovI/4DkzsoL4FzYPiUiNwADPeb9CBQXkUHubcsFRKSBO+8gUPbiXWPu39d84C0RKSgi2USkvIg09yFuRKSe+/eXAziNc1NDnMe2rvey+HjgBRGp6P791hSRIr5s1yTNEkUmoqrRwBfAKFXdA3TBOSuMxjnTGsal33kfnDPvLTgXrwe561gNPIjT9D+Gc0H6Xi+bnYVzh85BVd3gEct04DVgqtuNEQ50uMxduh1YAMzFuRYzCedOmkcTlPsSpzV1AOdC62NuDMnVwb+o6kl32W9w9v1Od/8uzt8CTAF2uF0qiXXHefM8EAXsxGkxTcM5807KY1zqgvkbp0vlVuAHH7Y1D+dkYBtOd9w5vHd1AQzF2eeTOCcMX1+c4dZNW+BmnHr+A2jpzv7W/XlERNa67+/GSbyROHU5Dd+60sBJaJ+4y/2F0w13saX8KVDVrf8ZiSz7Ns7vbz5O0vsU52K5uQJyqafAmIxHRMJwLqQG5NvRV0JEBuJc6PbpTNuYQLEWhTFpRESuFZHGbldMZZxbTacHOi5jkuO3RCEiE0TkkIiEJzFfROR9EdkuIhtFpI6/YjEmnciJc/fPSZyL8TNxrkMYk675revJvTh6CvhCVasnMr8jTl9zR5wvd72nqg0SljPGGBNYfmtRqOoinHvnk9IFJ4moqi4HCouIrxe7jDHGpJFADsZVgn/fhRHlfrY/YUER6Yczzgv58uWre8MNN6RJgMYYk5HFx8PJbfspcPoA64g/rKrBKVlPIBNFYkNFJ9oPpqofAx8DhIaG6urVq/0ZlzHGZHi//Kw82E+ocXoWT9SYT4tNo/9K6boCeddTFP/+ZmpJnJFMjTHGpNDxXcdYXOkBFtz0MjlzwrBFt9B844dXtM5AJopZwN3u3U83Asfdb3QaY4xJgRUjpnOufFUa/vE5LRvHsGEDNG165ev1W9eTiEzBGaiuqDhPBXsWZ6AwVHUszhg6HXG++XsG5zkAxhhjLlN0+EG2d3iUhlHfsiV3CEfH/0Sbu1LvGwd+SxSq2iuZ+Yrz4BpjjDEpoAqTJ8NnD+9h1omfCGv7Eo1nDCNH3hypuh37ZrYxxmRA+5b9xZjqH9KnD5ytFsrepbtpMf/pVE8SENi7nowxxlym+Nh4fu89htpfj6APkPP527nv6WsJCvLfILmWKIwxJoPYNW8rJ7r3pdmJ31lVpB3FZ4yjbxP/f0/Zup6MMSadi42Fd146Q772TSh1MoLFD0wk9NAcSjUpkybbtxaFMcakY1tmbaPP8xVZvSYvJxt+Sf8xITStVTxNY7AWhTHGpEPnj59jYZORVOhSlXp/TOabb2DUkvYUS+MkAdaiMMaYdCd83BLyPvYAzS9sZVH5+3hxXieuDuCTwK1FYYwx6cTp0zCn0QtUHdCUHHHnWPXiPJptn8DV5a8KaFzWojDGmHTg11+cQfyq7Qwhd41HqTv3JUpdlz/QYQHWojDGmIA6vvMoSyvdQ1jbF8meHYYtvJmWG9+jYDpJEmCJwhhjAmbV8GlcqFCFen98RdPGyoYN0KxZoKP6L+t6MsaYNHZ4037+7PgIDaK+JyJPXQ6Nn89Nd9YKdFhJshaFMcakkYuD+PVouo9qUfP49abXqHRkOdXScZIASxTGGJMm9i3dxbjqH9C7N5ypUpeopXtoPe9JcuRJ/x076T9CY4zJwOJj4ljWezS1vnmaO8lG0PPduP/p4gQFBfaW18thicIYY/xk15zNnOzZl8YnlrKySHuKzRjHg03S/pvVV8q6nowxJpXFxsK7L58hX8dmlDi5hYUPfEG9Q7Mp06R0oENLEWtRGGNMKto2awu9X6jMqtV5+bvhZAaMqUXzWsUCHdYVsRaFMcakgvN/n+X3xsMp36UaoVsn8/XX8OySmyiewZMEWIvCGGOuWOTYReR9vC9NLvzBggp9eWFuZ4oEcBC/1GYtCmOMSaEzZ2Beo/+j6sDmSFwsy1/8hZZ/fEKR8oUDHVqqshaFMcakwILflL4PCjfsCCV7zcHUm/sCZa7NF+iw/MJaFMYYcxlO7DjM8op9WND6BbJlgyfDOtF6w9sUzKRJAixRGGOMb1RZPfwbLlSsSt3tU2nUJBsbN0Lz5oEOzP+s68kYY5JxZNM+dnZ4iNC9MwnPE8rBT3+hfa+agQ4rzViLwhhjkqAKU6ZA92YHqLT3N36+6Q0qHV5GtSyUJMAShTHGJGr/kh2Mr/4ud94JpyvXYe/S3bSdN5ScebNeR0zW22NjjPEiPiaOFXe9T61vR9KdHMQ/15O+zxQnKKhwoEMLGEsUxhjj2j0nglM9HqDhyRUsL9KJa2eOpX/jjDeIX2qzridjTJYXFwfvv3qGvB2bc82pP/mt71c0OPQDZRqXDHRo6YK1KIwxWdofMyPp/VIVVq7KS/SNU3loXC1a1QwOdFjpirUojDFZ0oW/z7C08TCu71qD0C2TmDoVnl/ahmstSfyHtSiMMVnOlrFh5Hn8QRpd2M6vFfrz/LxbKHJ9oKNKv6xFYYzJMs6cgfkNn+WGgS3ROGXZS7/R+o+xFLm+UKBDS9esRWGMyRLCFjiD+FX+sz5S8wnqz32estfmDXRYGYJfWxQi0l5EtorIdhEZkcj8QiLyg4hsEJEIEbnPn/EYY7KeE39Gs7LCnSxo9TwAwxZ0ou2GNylkScJnfksUIhIEjAY6AFWBXiJSNUGxh4FIVa0FtADeEpGc/orJGJOFqLJu2FfEVqpCyJ/TaNA0Jxs3QosWgQ4s4/Fn11N9YLuq7gAQkalAFyDSo4wCBUREgPzAUSDWjzEZY7KAIxui+KvjQOrs+5ENeRqQbcKndOxZLdBhZVj+7HoqAezxmI5yP/P0IVAF2AdsAh5X1fiEKxKRfiKyWkRWR0dH+yteY0wGpwpTp0K3FtGU37eIee3epsqRJdSwJHFF/JkoJJHPNMF0O2A9cB0QAnwoIgX/s5Dqx6oaqqqhwcF2j7Mx5r8O/L6dCTXeoVcvOF2pNnuX7aHd3MHkzBMU6NAyPH8miiiglMd0SZyWg6f7gO/VsR3YCdzgx5iMMZmMxsSyvNubFGpag9sj/o8xzx1k6VKoeuN/zjlNCvkzUawCKopIOfcCdU9gVoIyu4HWACJSDKgM7PBjTMaYTGTP7E1sLdKIG6cNY22Rmzi2OIIBzxYjyBoRqcpvF7NVNVZEHgHmAUHABFWNEJEB7vyxwAvARBHZhNNVNVxVD/srJmNM5hAXBx+9eYZeI1qSW7LxS9+ptBrbnWxBifV4myvl1y/cqepsYHaCz8Z6vN8H3OTPGIwxmcv2GeH0fqUaK1bm5cCNX/PwuFq0qVk00GFlajaEhzEmQ7hw7DTLGw3h+ltrUidyEl99BS8ubc11liT8zobwMMake1tG/0r+wQ9yY8xO5ld8iOfndqGoDeKXZqxFYYxJt86cgV8ajeKGR9pwIT47S15eyE3bRlP0erujKS1Zi8IYky4tXBBP337ZqLC9EbE1n6ThvOe4vnieQIeVJVmLwhiTrpz88xCrK/QkrNX/ER8Pw37tQPsNr1HIkkTAWKIwxqQPqqwfOonYSlWo8ed06jbJy6ZN0KpVoAMz1vVkjAm4oxv2sLvjAEL2zWZ9noZkmzCezj0TDjZtAsVaFMaYgFGFb76BO1oeoey+Jcxp/x5VDi+mpiWJdMUShTEmIA4u3sbEGm/SowecLB/C3mV76DDnMXLltfE30hvrejLGpCmNiWV1r7eo8d2zdCUPZ//Xh36jipE9e4FAh2aSYInCGJNmon7awJle91Pv5FoWFb2VUjNH81CjYoEOyyTDup6MMX4XFwcfvn6G3J1bU+jUXub3m0aTg99TrtG1gQ7N+MBaFMYYv/pz+kZ6v1aD5SvysrfBtzzySS1uqnF1oMMyl8FaFMYYv4g5dooVDR+n3G0h1I74ksmT4eVlLSlhSSLDsRaFMSbVbRv9M/kG96NBzC7mVXyE/5t7K8E2iF+GZS0KY0yqOXsWfms4kkqP3MRZzcXvryym3bYPCL7e7mjKyHxuUYhIPlU97c9gjDEZ16IwZxC/8n804Vytp2g0939UKJ470GGZVJBsi0JEGolIJLDZna4lIh/5PTJjTIZw8o8DrCt/B2EtnyM2Fob+0oGO61+msCWJTMOXrqd3gHbAEQBV3QA082dQxpgMQJWNQyYSd0NVquz4kZCmBdm0CVq3DnRgJrX51PWkqntE/vXQ8jj/hGOMyQiOrf+LqI79qLl/PmvyNCHos/Hc0qNyoMMyfuJLi2KPiDQCVERyishQ3G4oY0zWogrffgu3tfqbEvtX8WP7D6l+ZCEhliQyNV8SxQDgYaAEEAWEAA/5MSZjTDp0aPFWvqjxBt27w8nra7Fv2W46z3mYXHns5snMzpffcGVVvUtVi6nqNaraG6ji78CMMemDXohh9e2vULBZLTpHvMqH/zvE8uVQ/cb8gQ7NpBFfEsUHPn5mjMlk9v64ju1FGxD6/dMsL3ozfy+J5OH/u4bs9lXdLCXJX7eINAQaAcEiMsRjVkHABow3JhOLi4Nx75yh+7C2BEkO5vX7jrZjbiOb9TJlSd7OC3IC+d0ynl+rPAHc4c+gjDGBs+O7dfR+M4Rly/PyV/1pPDq+Fu1qXBXosEwAJZkoVHUhsFBEJqrqX2kYkzEmAGKOnmRDx6cIXTGakHyf89CXd3PXXS34953xJivypafxjIi8AVQD/vmqpaq28ltUxpg0tf3DueQd0p86MXuYXfFx/m/ebQSXC3RUJr3wpcdxMrAFKAf8H7ALWOXHmIwxaeTsWVjQ8CkqPNqBU5qPxa8soeO2dwkuZ3c0mUt8aVEUUdVPReRxj+6ohf4OzBjjX4vD4ujbP4iy21pwKiQ7TeY8Q6XiuQIdlkmHfEkUMe7P/SLSCdgHlPRfSMYYfzr1x362t3+YsB3VuFD2BYb93I42bdoFOiyTjvmSKF4UkULAEzjfnygIDPJnUMYYP1Bl0xMTKf3uECrrOXY1bUL4HMiXL9CBmfQu2UShqj+6b48DLQFEpLE/gzLGpK6/1+8iquOD1Nj/C6vzNCXos/F07VEp0GGZDCLJi9kiEiQivURkqIhUdz/rLCJLgQ/TLEJjzBWZNg1ubXWca/evZVaHj6hxJIzaliTMZfB219OnQF+gCPC+iHwGvAm8rqq1fVm5iLQXka0isl1ERiRRpoWIrBeRCLtIbkzqiV4YyaTqr9KtG5wo5wzid8vsgTaIn7ls3rqeQoGaqhovIrmBw0AFVT3gy4pFJAgYDbTFGXV2lYjMUtVIjzKFgY+A9qq6W0SuSeF+GGNcev4C63q9TrXpL9CeArz/zP0MfPYasme3ixEmZbydWlxQ1XgAVT0HbPM1SbjqA9tVdYeqXgCmAl0SlLkT+F5Vd7vbOXQZ6zfGJLBv1mp2FK1HnemjWBx8G8eXRvLoCzaIn7ky3hLFDSKy0X1t8pjeJCIbfVh3CWCPx3SU+5mnSsBVIhImImtE5O7EViQi/URktYisjo6O9mHTxmQt8fEw5s3T5OrSjjynDzO7/0xaHZhC+YbWSDdXztt5xpU+cyKxEWI0ke3XBVoDeYBlIrJcVbf9ayHVj4GPAUJDQxOuw5gsbed3a+nzVghLluVjR/3pPPpJTTrWLBzosEwm4m1QwCsdCDAKKOUxXRLny3oJyxxW1dPAaRFZBNQCtmGM8SrmyAk2dhxB3ZVjqJnvc/p/cTe9ezezQfxMqvPn7Q+rgIoiUk5EcgI9gVkJyswEmopIdhHJCzTAnsdtTLL+/GA2R66tRsjKcfxQcQjPbrydPn2wJGH8wm+XuFQ1VkQeAebhPOhogqpGiMgAd/5YVd0sInOBjUA8MF5Vw/0VkzEZ3blzsKLlcJovf52t2auy+ZVp3DyiQaDDMpmcT4lCRPIApVV16+WsXFVnA7MTfDY2wfQbwBuXs15jshxVliyO54F+QZTe2pq/Q3LTbM7TVLZB/EwaSLbrSURuBtYDc93pEBFJ2IVkjPGTU1v3srF8V8KaP8v58zBs/k10Wfd/XGVJwqQRX65RPIfznYi/AVR1PVDWXwEZY1yqRAz6hPgqVam4cz5VmhZl0yZo2zbQgZmsxpeup1hVPS52lcyYNPP3up3s7/gA1Q4sYEXeFmSf8Am39agQ6LBMFuVLiyJcRO4EgkSkooh8ACz1c1zGZFnffQdd25wi+MBGZnQYR63oX6lrScIEkC+J4lGc52WfB77CGW58kB9jMiZLOhwWzlfVX+aOO+BEmRrsXbqbrrP7kTuvDeJnAsuXrqfKqjoSGOnvYIzJivT8BTb0fIWqM16iLYV4b2RfBj57DTly5A10aMYAvrUo3haRLSLygohU83tExmQh+2etYlfRuoTMeI6w4G4cXxrJYy9eQ44cgY7MmEuSTRSq2hJoAUQDH7uDAj7j78CMyczi42HsW6fJ2aU9OU8f46f+s2hzYDIVGgYHOjRj/sOnzk9VPaCq7wMDcL5T8T9/BmVMZrZr2mqaN41n4NB8vFx/JnEbIug09may2aUIk0758oW7KiLynIiE4zwCdSnOAH/GmMsQc/g46xr0p2y3elRfP4mJE+HN5U0oXaNQoEMzxitfLmZ/BkwBblLVhKO/GmN88Oe7P1DgyQHUjDnAzIpDeXbuHRS/PtBRGeObZBOFqt6YFoEYkxmdOwerWgyj6Yo3icxeg/BXZ9BleL1Ah2XMZUkyUYjIN6ra3X26nefDggRQVa3p9+iMyahUWbo4jgf6Z6fklpsYWLsgLWYPp2rxnIGOzJjL5q1F8bj7s3NaBGJMZnF6axQ72w8kbFdNzpR+iaFz29KunQ3QZDKuJC9mq+p+9+1DqvqX5wt4KG3CMyYDiY8n8vFxxFepSrldv1GxaXHCw6Fdu0AHZsyV8eWGvMROhTqkdiDGZGTH1+1gS4lWVH1/AJvy1Cfy6010W/QoBQoEOjJjrlySiUJEBrrXJyqLyEaP106cJ9IZY4Dp06Fr29NcfSCS7zqOp87hn6nX3W5pMpmHt2sUXwFzgFeAER6fn1TVo36NypgM4EjYJuY/MpM7I54hJKQGe2f9xe2N8gQ6LGNSnbeuJ1XVXcDDwEmPFyJytf9DMyZ90nPn2dD1fxRsWYfWEe/z7tOHWLkSaluSMJlUci2KzsAanNtjPZ9cpIC1rU2Wc2DGcs73eYBapyKZE9yH8jPf4fGGRQIdljF+lWSiUNXO7s9yaReOMelTfDyMf+80dwzpRIzkY9aA2XQe3cHGZzJZgi9jPTUWkXzu+94i8raIlPZ/aMakD7u/XUHL5vH0H5KP5+v9QPzGCG4ZY0nCZB2+/KmPAc6ISC3gSeAv4Eu/RmVMOhB7+G821OtL6e43UmXtJD77DN5Z0Ygy1e2eV5O1+DIoYKyqqoh0Ad5T1U9F5B5/B2ZMIO18Zwb5hz9EtZhDfF9xOM/O7ca1dlXOZFG+JIqTIvIU0AdoKiJBgD1/y2RK58/D6uZDaLziHcKz12Ljaz9w25N1Ax2WMQHlS6LoAdwJ3K+qB9zrE2/4Nyxj0pgqy353BvG7bnNHBoQUodXcJ6lezM6JjPHlUagHgMlAIRHpDJxT1S/8HpkxaeT05t1EluvEgmbPcvo0DJ3ThjvWjeRqSxLGAL7d9dQdWAl0A7oDK0TkDn8HZozfxcez5bGP0GrVKPPXQio0u47wcGjfPtCBGZO++NL1NBKop6qHAEQkGPgFmObPwIzxpxNrt3Og4/3ccHAxv+dtS87PPqZ797KBDsuYdMmX22OzXUwSriM+LmdMujRjBnRpd46CB7fxbcfPqBs9j/qWJIxJki8tirkiMg/nudngXNye7b+QjPGPI7+u59fHZtIj8llq1arOvpm76NYod6DDMibd8+Vi9jBgHFATqAV8rKrD/R2YMalFz55jU5eRFGoTSrPIMbzz1CFWrYI6liSM8Ym3Z2ZXBN4EygObgKGqujetAjMmNRz4fikX7n6AGqe38FPwPVSY+TaDGtrgx8ZcDm8tignAj8DtOCPIfpAmERmTCuLj4ZN3T5Pz9pvhzBlmDJhL+/0TqWxJwpjL5u0aRQFV/cR9v1VE1qZFQMZcqT3fLKPPhw1YuDgfm0J/ZMiE6nStYeMzGZNS3loUuUWktojUEZE6QJ4E08kSkfYislVEtovICC/l6olInH0/w1yJ2OhjbKx3P6V6NKLK6i/59FN4b2VDylqSMOaKeGtR7Afe9pg+4DGtQCtvK3bHhBoNtAWigFUiMktVIxMp9xow7/JCN+aSXW9/T/7hD1M1NppplZ5i1JweXGeD+BmTKrw9uKjlFa67PrBdVXcAiMhUoAsQmaDco8B3QL0r3J7Jgs6fhzXNB9Noxbtsyh7Cutdmc/uw2ogkv6wxxje+fI8ipUoAezymo4AGngVEpARwK07rJMlEISL9gH4ApUvbM5MMoMryJc4gfsUjO9M/5BpazxlKjeI2PpMxqc2f37BO7JxOE0y/CwxX1ThvK1LVj1U1VFVDg4ODUys+k0GdidzFlrLtCWs6ipMnYejs1nRf9xRFLEkY4xf+bFFEAaU8pksC+xKUCQWmitNPUBToKCKxqjrDj3GZjCo+nq2PjabkR09RQoUyzW4l/AcoWDDQgRmTuSWbKMQ5it8FXK+qz7vPoyiuqiuTWXQVUFFEygF7gZ44z7X4h6qW89jOROBHSxImMSfW/MHBTvdR+eASFuVtT67PxtKre5lAh2VMluBL19NHQEOglzt9EuduJq9UNRZ4BOdups3AN6oaISIDRGRACuM1WdCsWdClwwXyH/yTqZ2+oF70bBpYkjAmzfjS9dRAVeuIyDoAVT0mIjl9WbmqzibBAIKqOjaJsvf6sk6TdRz9dR2/PT6TbhHPUbNmNfbN2EXPRrkCHZYxWY4vLYoY97sOCv88jyLer1GZLE3PniPilqco2KYejSPG8daIaFatgrqWJIwJCF8SxfvAdOAaEXkJ+B142a9RmSzr4He/sze4FtV+eJW5wXdzfGkkQ14JJqdPbVhjjD8k2/WkqpNFZA3QGueW166qutnvkZksJT4eJrx/itsGd+GsFGT6wPnc8kFbgoICHZkxxpe7nkoDZ4AfPD9T1d3+DMxkHXum/M7dYxsRtig/G0J/YsiE6txaI3+gwzLGuHy5mP0TzvUJAXID5YCtQDU/xmWygNiDR9jacTDV1n7JDXkm0nv8Pdx//402/IYx6YwvXU81PKfdkWP7+y0ik/mp8tfb08g/4hEqxR7l60qjGDW3J9eVS35RY0zau+xvZqvqWhGxAfxMipw/D2ubD6bhivdYn70uB1+bT/dhtawVYUw65ss1iiEek9mAOkC03yIymZMqK5fGcn//HFwTcQv9al9Hm9lDCCnuz1FkjDGpwZf/Us+nvsTiXLP4zj/hmMzobOROdnfox4LddTle8lVe+7EVnTp5fZyJMSYd8Zoo3C/a5VfVYWkUj8lM4uL44/EPKfHR01yrQZRs1o0IG8TPmAwnyUQhItlVNdbXx54a4+nkmm0c6ngvFQ8tIyxvB3JPHMdd3Uolv6AxJt3x1qJYiXM9Yr2IzAK+BU5fnKmq3/s5NpNB/fADvPVALJOj/2JKp0l0+fpO8uazq9XGZFS+XKO4GjiC8xS6i9+nUMAShfmXYz+vJmzwTG6LeIEaNaqyf/oOejW28ZmMyei8JYpr3DuewrmUIC5K+KQ6k4XpmbNs7v4slX96i/oU540nH+OxF4LJmdOShDGZgbdEEQTkx7dHmpos6tC3C4m9ty9Vz2xnRvCDVJ75OkMbFg50WMaYVOQtUexX1efTLBKTocTHw8QPT9F10G2cojDTBv7KrR+0skH8jMmEvA0zblcfTaKipiymTat4Hng8P8/UmQMbNnLHR5YkjMmsvCWK1mkWhckQ4g4eJrJub0re2YxKK77kk09g9Kr6XF8jX6BDM8b4UZJdT6p6NC0DMemYKrvf+ob8Tz1KxdhjTKn0LKPm9KTE9YEOzBiTFmygHePVhQuwrunjNFj5AWuz1+Pga7/Sc1gNG8TPmCzEEoVJnCqrlsZw/4CcFA2/lb61y9BuziDqFLMLEcZkNb48M9tkMWfD/2R7mdaENXmGY8fgiR9actfaJyhqScKYLMkShbkkLo7tD70NNWsQvGcNxZpXJiICOncOdGDGmECyricDwMlVWzjc6R4qRK/k17w3k/uzMdzdvUSgwzLGpAPWojD8+CPc0jme7NH7mNR5Cg0PzaSxJQljjMsSRRZ2bN5KZlQfyc03w+FrqnLg9z/p/UNPG+nVGPMvliiyID19hi2dh1KwfUNCIz7n9WHRrFkD9RrnDHRoxph0yBJFFhP9zQIOXFODG356i5nBD3JiaQTDXg8mp+UIY0wSLFFkEarw2QenyNazG2fOCl8PWECX/WOp2rBQoEMzxqRzliiygL2Tw2jTKp77H8vPyNrOIH49xrSwQfyMMT6xRJGJxR2IZkvtXpTo3ZIKyycxbhx8tKoe5WvkDXRoxpgMxL5HkRmpEvXGFPKPfIxysSf5svILjJrdk5I2iJ8xJgUsUWQyFy7A+qaPUn/laFZlv5FDr39K76FVbRA/Y0yKWaLILOLjWb08lvsH5OTqTXdwf+0KdJj9KPWK24UIY8yV8es1ChFpLyJbRWS7iIxIZP5dIrLRfS0VkVr+jCezOrvxD/4s24qwxiM5cgSemNWCu9cOItiShDEmFfgtUYhIEDAa6ABUBXqJSNUExXYCzVW1JvAC8LG/4smUYmP5c+CbSEhNiuxZT3CzKkRGws03BzowY0xm4s+up/rAdlXdASAiU4EuQOTFAqq61KP8cqCkH+PJVE6t2szhTndTPno1P+ftQp7PPuKe7tcFOixjTCbkz66nEsAej+ko97OkPADMSWyGiPQTkdUisjo6OjoVQ8yYZs92Wg3Zog/yRaevaXxoOk0sSRhj/MSfiSKx+2w00YIiLXESxfDE5qvqx6oaqqqhwcHBqRhixvL33OXMqvYUnTrBoSJVOPD7n9z9Y3cbxM8Y41f+TBRRQCmP6ZLAvoSFRKQmMB7ooqpH/BhPhqWnTrO142AKdmhESORkXhsazdq1UL9xjkCHZozJAvyZKFYBFUWknIjkBHoCszwLiEhp4Hugj6pu82MsGdbhqb9wqFh1Ks95l2nBD3FyWQRPvhFMrlyBjswYk1X47WK2qsaKyCPAPCAImKCqESIywJ0/FvgfUAT4SJxvhMWqaqi/YspIVOGLj07R+dGenOBqfhu4iG7vNyW7ffPFGJPGRDXRywbpVmhoqK5evTrQYfjVvkm/cc+E5vyyIIgH66xh+OdVKV89T6DDMsZkYCKyJqUn4jYoYDoSt+8g20K6c12f1pRfNomxY2HsqrqWJIwxAWUdGemBKntfm0T+UYMoE3uKzyu9xMg5d1LKBvEzxqQDligC7MIF2NjkYUJXjWFl9oYcfO1T7h5WxQbxM8akG5YoAiU+njXLY7h/YC4Kb+zBvbWr0Omnh6h/rY3PZIxJX+waRQCc27CVnWWaE9Z4JNHRMGRGc+5b+yjXWJIwxqRDlijSUkwMO/u/itSuReGocK5qVoPISOjSJdCBGWNM0qzrKY2cWhHB0c59KHd4HXPz3ka+iaO5v1vxQIdljDHJshZFGpgzB27uGkT84aN81mkaTQ99R1NLEsaYDMIShR8dn7OUH6sPp2NHOHT1DRxYvJ37frydfPkCHZkxxvjOEoUf6MlT/NHhMQp0bEL1iK955YnDrF0LNzaxnj5jTMZjiSKVHZkyn+hi1Sk/90O+CX6EU8vCGfFmURvEzxiTYVmiSCUXB/HTu+7i2LncTH1oMXfse5/qN+YPdGjGGHNFLFGkgv1f/Ez7tnHc83B+RtSeT7YN67lzdGMb6dUYkylYorgCcVH72V7rdq695ybK/D6Zjz6Cj1fVpmKN3IEOzRhjUo2d86aEKvte+Zz8/xtMybizTKj0Ks/MuZPSNoifMSYTskRxmWJiYFPjgdRZNY5l2ZsQ/fp47hta2QbxMyYRMTExREVFce7cuUCHkmXkzp2bkiVLkiNH6j0q2RKFr+LjWbcyhvsG5KLghju5p05Nbv5pAA2LW++dMUmJioqiQIEClC1bFrGzKb9TVY4cOUJUVBTlypVLtfXaUc4H59ZtZlfppoQ1epqDB2HI9GY8sOYhrrEkYYxX586do0iRIpYk0oiIUKRIkVRvwdmRzpuYGHb1e5lsdUMosHcLBZrVJjISunYNdGDGZByWJNKWP+rbup6ScHplBEc79abs4fX8lLcbBSZ+QN9uxQIdljHGpDlrUSRi7lzo3DU7MYeP82mn72l+8BuaWZIwJsOaPn06IsKWLVv++SwsLIzOnTv/q9y9997LtGnTAOdC/IgRI6hYsSLVq1enfv36zJkz54pjeeWVV6hQoQKVK1dm3rx5iZZ57rnnKFGiBCEhIYSEhDB79uzLWj61WYvCw/EfF7N0+Ew6Rr5JlSqVOfj1Nh5oalVkTEY3ZcoUmjRpwtSpU3nuued8WmbUqFHs37+f8PBwcuXKxcGDB1m4cOEVxREZGcnUqVOJiIhg3759tGnThm3bthEU9N+Hlg0ePJihQ4emePnUZEdBgJMn2d5tBBXmfURlyvHykBEMebkouXJZ9RiTWgYNgvXrU3edISHw7rvey5w6dYolS5awYMECbrnlFp8SxZkzZ/jkk0/YuXMnudyB2ooVK0b37t2vKN6ZM2fSs2dPcuXKRbly5ahQoQIrV66kYcOGabJ8SmX5rqejk+cQXawa188bw+RrBnFq6SaeessG8TMms5gxYwbt27enUqVKXH311axduzbZZbZv307p0qUpWLBgsmUHDx78TxeR5+vVV1/9T9m9e/dSqlSpf6ZLlizJ3r17E13vhx9+SM2aNbn//vs5duzYZS+fmrLsKbMqTBpzkg6P3E001zD3oaX0eu9GG5/JGD9J7szfX6ZMmcKgQYMA6NmzJ1OmTKFOnTpJ3h10uXcNvfPOOz6XVVWftjdw4EBGjRqFiDBq1CieeOIJJkyY4PPyqS3rHRZVOfjFPO6Z1JZ5vxTgnpBfGPnlDfSpbk0IYzKbI0eO8NtvvxEeHo6IEBcXh4jw+uuvU6RIkX/O1C86evQoRYsWpUKFCuzevZuTJ09SoEABr9sYPHgwCxYs+M/nPXv2ZMSIEf/6rGTJkuzZs+ef6aioKK677rr/LFus2KWbZx588MF/Lrr7unyqU9UM9apbt66mVFzUPt1es6sq6IO5PtfRo1Xj4lK8OmNMMiIjIwO6/bFjx2q/fv3+9VmzZs100aJFeu7cOS1btuw/Me7atUtLly6tf//9t6qqDhs2TO+99149f/68qqru27dPv/zyyyuKJzw8XGvWrKnnzp3THTt2aLly5TQ2NvY/5fbt2/fP+7ffflt79OhxWcsnVu/Aak3hcTdrtChU2ffSZxR4bgjXxZ1nfOXXGfnTnZQpH+jAjDH+NGXKlP+c1d9+++189dVXNG3alEmTJnHfffdx7tw5cuTIwfjx4ylUqBAAL774Is888wxVq1Yld+7c5MuXj+eff/6K4qlWrRrdu3enatWqZM+endGjR/9zx1Lfvn0ZMGAAoaGhPPnkk6xfvx4RoWzZsowbNy7Z5f1JNJE+r/QsNDRUV69e7XP5mBgIb9yf2qs+Zkn2Zhx6aTxdh1W0QfyMSQObN2+mSpUqgQ4jy0ms3kVkjaqGpmR9mbdFERfH+lUx3DcwN/nX96ZP7dp0+akfja/N8jd6GWPMZcmUR83zayPYXboxYY2e5sABGPxdU/qtHUAxSxLGGHPZMteR88IF/ur7AlK3Nnn3bSdPs3pERsJttwU6MGOyrozWvZ3R+aO+M03X0+nlm/i7812UObKJWXl7UuCz9+nfPTjQYRmTpeXOnZsjR47YUONpRN3nUeTOnbqPY84UiWLePHj1vpx8cuQMn3SeSa8pt5A/f6CjMsaULFmSqKgooqOjAx1KlnHxCXepKUMnihM/LGTpiFl0iHyLypUrc3DqVh5s5v9bxYwxvsmRI0eqPmnNBIZfr1GISHsR2Soi20VkRCLzRUTed+dvFJE6Pq34xAl2tBtIwVtaUDFyBi8OOsz69dDYkoQxxqQ6v7UoRCQIGA20BaKAVSIyS1UjPYp1ACq6rwbAGPdnkuKOHudw8WqUObuPL4OHUHPmC4xsmNc/O2GMMcavLYr6wHZV3aGqF4CpQJcEZboAX7jfMF8OFBaRa72tVHfu4uC5QkwauJSee9+iliUJY4zxK39eoygB7PGYjuK/rYXEypQA9nsWEpF+QD938nx1jQhnzI3cOyZ1A86AigKHAx1EOmF1cYnVxSVWF5dUTumC/kwUid0Ll/AGX1/KoKofAx8DiMjqlH4NPbOxurjE6uISq4tLrC4uERHfxz5KwJ9dT1FAKY/pksC+FJQxxhgTQP5MFKuAiiJSTkRyAj2BWQnKzALudu9+uhE4rqr7E67IGGNM4Pit60lVY0XkEWAeEARMUNUIERngzh8LzAY6AtuBM8B9Pqz6Yz+FnBFZXVxidXGJ1cUlVheXpLguMtww48YYY9JW5hoU0BhjTKqzRGGMMcardJso/Db8RwbkQ13c5dbBRhFZKiK1AhFnWkiuLjzK1ROROBG5Iy3jS0u+1IWItBCR9SISISIL0zrGtOLD/0ghEflBRDa4deHL9dAMR0QmiMghEQlPYn7Kjpspfdi2P184F7//BK4HcgIbgKoJynQE5uB8F+NGYEWg4w5gXTQCrnLfd8jKdeFR7jecmyXuCHTcAfy7KAxEAqXd6WsCHXcA6+Jp4DX3fTBwFMgZ6Nj9UBfNgDpAeBLzU3TcTK8tCr8M/5FBJVsXqrpUVY+5k8txvo+SGfnydwHwKPAdcCgtg0tjvtTFncD3qrobQFUza334UhcKFBDnoRj5cRJFbNqG6X+qughn35KSouNmek0USQ3tcbllMoPL3c8HcM4YMqNk60JESgC3AmPTMK5A8OXvohJwlYiEicgaEbk7zaJLW77UxYdAFZwv9G4CHlfV+LQJL11J0XEzvT6PItWG/8gEfN5PEWmJkyia+DWiwPGlLt4FhqtqXCZ/opovdZEdqAu0BvIAy0Rkuapu83dwacyXumgHrAdaAeWBn0Vksaqe8HNs6U2KjpvpNVHY8B+X+LSfIlITGA90UNUjaRRbWvOlLkKBqW6SKAp0FJFYVZ2RJhGmHV//Rw6r6mngtIgsAmoBmS1R+FIX9wGvqtNRv11EdgI3ACvTJsR0I0XHzfTa9WTDf1ySbF2ISGnge6BPJjxb9JRsXahqOVUtq6plgWnAQ5kwSYBv/yMzgaYikl1E8uKM3rw5jeNMC77UxW6clhUiUgxnJNUdaRpl+pCi42a6bFGo/4b/yHB8rIv/AUWAj9wz6VjNhCNm+lgXWYIvdaGqm0VkLrARiAfGq2qit01mZD7+XbwATBSRTTjdL8NVNdMNPy4iU4AWQFERiQKeBXLAlR03bQgPY4wxXqXXridjjDHphCUKY4wxXlmiMMYY45UlCmOMMV5ZojDGGOOVJQqTLrkjv673eJX1UvZUKmxvoojsdLe1VkQapmAd40Wkqvv+6QTzll5pjO56LtZLuDsaauFkyoeISMfU2LbJuuz2WJMuicgpVc2f2mW9rGMi8KOqThORm4A3VbXmFazvimNKbr0i8jmwTVVf8lL+XiBUVR9J7VhM1mEtCpMhiEh+EfnVPdvfJCL/GTVWRK4VkUUeZ9xN3c9vEpFl7rLfikhyB/BFQAV32SHuusJFZJD7WT4R+cl9tkG4iPRwPw8TkVAReRXI48Yx2Z13yv35tecZvtuSuV1EgkTkDRFZJc5zAvr7UC3LcAd0E5H64jyLZJ37s7L7LeXngR5uLD3c2Ce421mXWD0a8x+BHj/dXvZK7AXE4Qzith6YjjOKQEF3XlGcb5ZebBGfcn8+AYx03wcBBdyyi4B87ufDgf8lsr2JuM+uALoBK3AG1NsE5MMZmjoCqA3cDnzisWwh92cYztn7PzF5lLkY463A5+77nDgjeeYB+gHPuJ/nAlYD5RKJ85TH/n0LtHenCwLZ3fdtgO/c9/cCH3os/zLQ231fGGfcp3yB/n3bK32/0uUQHsYAZ1U15OKEiOQAXhaRZjjDUZQAigEHPJZZBUxwy85Q1fUi0hyoCixxhzfJiXMmnpg3ROQZIBpnFN7WwHR1BtVDRL4HmgJzgTdF5DWc7qrFl7Ffc4D3RSQX0B5YpKpn3e6umnLpiXyFgIrAzgTL5xGR9UBZYA3ws0f5z0WkIs5ooDmS2P5NwC0iMtSdzg2UJnOOAWVSiSUKk1HchfNksrqqGiMiu3AOcv9Q1UVuIukEfCkibwDHgJ9VtZcP2ximqtMuTohIm8QKqeo2EamLM2bOKyIyX1Wf92UnVPWciIThDHvdA5hycXPAo6o6L5lVnFXVEBEpBPwIPAy8jzOW0QJVvdW98B+WxPIC3K6qW32J1xiwaxQm4ygEHHKTREugTMICIlLGLfMJ8CnOIyGXA41F5OI1h7wiUsnHbS4CurrL5MPpNlosItcBZ1R1EvCmu52EYtyWTWKm4gzG1hRnIDvcnwMvLiMildxtJkpVjwOPAUPdZQoBe93Z93oUPYnTBXfRPOBRcZtXIlI7qW0Yc5ElCpNRTAZCRWQ1TutiSyJlWgDrRWQdznWE91Q1GufAOUVENuIkjht82aCqrsW5drES55rFeFVdB9QAVrpdQCOBFxNZ/GNg48WL2QnMx3m28S/qPLoTnGeJRAJrRSQcGEcyLX43lg04w2q/jtO6WYJz/eKiBUDVixezcVoeOdzYwt1pY7yy22ONMcZ4ZS0KY4wxXlmiMMYY45UlCmOMMV5ZojDGGOOVJQpjjDFeWaIwxhjjlSUKY4wxXv0/IE7tMRUIlCsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import sklearn.metrics as metrics\n",
    "preds = svm.predict(X_test)\n",
    "fpr, tpr, threshold = metrics.roc_curve(y_test[:,0], preds)\n",
    "roc_auc = metrics.auc(fpr, tpr)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.title('Receiver Operating Characteristic')\n",
    "plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\n",
    "plt.legend(loc = 'lower right')\n",
    "plt.plot([0, 1], [0, 1],'r--')\n",
    "plt.xlim([0, 1])\n",
    "plt.ylim([0, 1])\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Balanced train set, imbalanced evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.985\n",
      "SVM classifier accuracy - test set: 0.68\n",
      "0.4493106857879846\n",
      "0.4470988691457688\n"
     ]
    }
   ],
   "source": [
    "svm_b = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm_b.fit(Xb_train, yb_train[:,0])\n",
    "print(f'SVM classifier accuracy: {svm_b.score(Xb_train, yb_train[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm_b.score(Xb_test, yb_test[:,0])}')\n",
    "\n",
    "y_pred = svm_b.predict(X_train)\n",
    "print(f1_score(y_pred, y_train[:,0], average = \"macro\"))\n",
    "y_pred_test = svm_b.predict(X_test)\n",
    "print(f1_score(y_pred_test, y_test[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import sklearn.metrics as metrics\n",
    "preds = svm_b.predict(X_test)\n",
    "fpr, tpr, threshold = metrics.roc_curve(y_test[:,0], preds)\n",
    "roc_auc = metrics.auc(fpr, tpr)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.title('Receiver Operating Characteristic')\n",
    "plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\n",
    "plt.legend(loc = 'lower right')\n",
    "plt.plot([0, 1], [0, 1],'r--')\n",
    "plt.xlim([0, 1])\n",
    "plt.ylim([0, 1])\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imbalanced train set, balanced evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.67\n",
      "SVM classifier accuracy - test set: 0.635\n",
      "0.6268656716417911\n",
      "0.5823679167024228\n"
     ]
    }
   ],
   "source": [
    "svm = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm.fit(X_train, y_train[:,0])\n",
    "print(f'SVM classifier accuracy: {svm.score(Xb_train, yb_train[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(Xb_test, yb_test[:,0])}')\n",
    "\n",
    "y_pred = svm.predict(Xb_train)\n",
    "print(f1_score(y_pred, yb_train[:,0], average = \"macro\"))\n",
    "y_pred_test = svm.predict(Xb_test)\n",
    "print(f1_score(y_pred_test, yb_test[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA+e0lEQVR4nO3dd3gU5fbA8e+hd7gCNpCiIAoIKBHLFSxYQFFUFLFe20UsKNjg2vAnFlRQUSlSvFhBRcEuNsB2FVCUDiI1gnSUIiXJ+f1xBllislmSbGZ3cz7Pk4fs7uzM2QHm7LzlvKKqOOecc7kpEXYAzjnnEpsnCuecc1F5onDOOReVJwrnnHNReaJwzjkXlScK55xzUXmicHtFRGaLyElhx5EoROQuERkR0rFHiciDYRy7sInIpSLycT7f6/8m48wTRRITkSUi8qeIbBaR34ILR6V4HlNVm6jqpHgeYxcRKSsij4jIsuBz/iwid4iIFMXxc4jnJBFJj3xOVR9W1WvjdDwRkZtFZJaIbBGRdBF5Q0SOiMfx8ktE7heRlwuyD1V9RVVPj+FYf0uORflvsrjyRJH8zlbVSkAL4EjgP+GGs/dEpFQuL70BtAXOBCoDlwNdgYFxiEFEJNH+PwwEbgFuBvYBDgXGA2cV9oGi/B3EXZjHdjFSVf9J0h9gCXBqxOPHgPcjHh8LfANsBH4CTop4bR/gv8AKYAMwPuK1DsCPwfu+AZplPyZwIPAnsE/Ea0cCa4HSweOrgbnB/icAdSO2VeBG4GdgcQ6frS2wDTgo2/PHAJlAg+DxJOARYArwO/B2tpiinYNJwEPA18FnaQBcFcS8CVgEXBdsWzHYJgvYHPwcCNwPvBxsUy/4XP8ClgXn4u6I45UHXgjOx1zgTiA9l7/bhsHnbBXl738UMAh4P4j3O+CQiNcHAsuBP4DvgdYRr90PjAVeDl6/FmgF/C84VyuBZ4EyEe9pAnwCrAdWAXcB7YAdwM7gnPwUbFsVGBns51fgQaBk8NqVwTl/MtjXg8FzXwWvS/Da6uDvdAbQFPuSsDM43mbg3ez/D4CSQVy/BOfke7L9G/KffFxrwg7Afwrwl7fnf5DawExgYPC4FrAO+zZeAjgteFwzeP194DXgH0Bp4MTg+aOC/6DHBP/p/hUcp2wOx/wc+HdEPI8DQ4PfzwUWAocDpYB7gG8ittXgorMPUD6Hz9YPmJzL517K7gv4pOBC1BS7mL/J7gt3XudgEnZBbxLEWBr7tn5IcLE6EdgKHBVsfxLZLuzknCiGY0mhObAdODzyMwXnvDZ2AcwtUXQDlubx9z8Ku9C2CuJ/BRgT8fplQPXgtduA34ByEXHvDP6eSgTxtsQSa6ngs8wFegTbV8Yu+rcB5YLHx2Q/BxHHHg88F/yd7Isl8l1/Z1cCGUD34Fjl2TNRnIFd4KsFfw+HAwdEfOYHo/w/uAP7f9AoeG9zoHrY/1eT/Sf0APynAH959h9kM/bNSYHPgGrBa72Al7JtPwG78B+AfTP+Rw77HAL0zfbcfHYnksj/lNcCnwe/C/bttU3w+EPgmoh9lMAuunWDxwqcEuWzjYi86GV77VuCb+rYxb5fxGuNsW+cJaOdg4j3PpDHOR4P3BL8fhKxJYraEa9PAboEvy8Czoh47drs+4t47W7g2zxiGwWMiHh8JjAvyvYbgOYRcX+Rx/57AOOC3y8Gpuey3V/nIHi8H5Ygy0c8dzEwMfj9SmBZtn1cye5EcQqwAEtaJXL4zNESxXygY0H/b/nPnj+J1ibr9t65qloZu4gdBtQInq8LXCgiG3f9ACdgSeIgYL2qbshhf3WB27K97yCsmSW7scBxInIg0Aa7SH4ZsZ+BEftYjyWTWhHvXx7lc60NYs3JAcHrOe1nKXZnUIPo5yDHGESkvYh8KyLrg+3PZPc5jdVvEb9vBXYNMDgw2/Giff515P75YzkWInKbiMwVkd+Dz1KVPT9L9s9+qIi8FwyM+AN4OGL7g7DmnFjUxf4OVkac9+ewO4scjx1JVT/Hmr0GAatEZJiIVInx2HsTp4uRJ4oUoaqTsW9b/YOnlmPfpqtF/FRU1X7Ba/uISLUcdrUceCjb+yqo6ugcjrkR+BjoDFwCjNbga12wn+uy7ae8qn4TuYsoH+lT4BgROSjySRFphV0MPo94OnKbOliTyto8zsHfYhCRsljTVX9gP1WtBnyAJbi84o3FSqzJKae4s/sMqC0iafk5kIi0xu6oOmN3jtWw9v7IEWPZP88QYB7QUFWrYG39u7ZfjjXJ5ST7fpZjdxQ1Is57FVVtEuU9e+5Q9WlVbYk1Cx6KNSnl+b484nT55IkitTwFnCYiLbBOyrNF5AwRKSki5YLhnbVVdSXWNDRYRP4hIqVFpE2wj+FANxE5JhgJVFFEzhKRyrkc81XgCqBT8PsuQ4H/iEgTABGpKiIXxvpBVPVT7GL5pog0CT7DsVg7/BBV/Tli88tEpLGIVAAeAMaqama0c5DLYcsAZYE1QIaItAcih2yuAqqLSNVYP0c2r2Pn5B8iUgu4KbcNg883GBgdxFwmiL+LiPSO4ViVsX6ANUApEbkPyOtbeWWsY3uziBwGXB/x2nvA/iLSIxi2XFlEjgleWwXU2zVqLPj39TEwQESqiEgJETlERE6MIW5E5Ojg319pYAs2qCEz4lgHR3n7CKCviDQM/v02E5HqsRzX5c4TRQpR1TXAi8C9qroc6Ih9K1yDfdO6g91/55dj37znYZ3XPYJ9TAP+jd36b8A6pK+Mcth3sBE6q1T1p4hYxgGPAmOCZoxZQPu9/EidgInAR1hfzMvYSJru2bZ7Cbub+g3raL05iCGvc7AHVd0UvPd17LNfEny+Xa/PA0YDi4ImlZya46J5AEgHFmN3TGOxb965uZndTTAbsSaV84B3YzjWBOzLwAKsOW4b0Zu6AG7HPvMm7AvDa7teCM7NacDZ2Hn+GTg5ePmN4M91IvJD8PsVWOKdg53LscTWlAaW0IYH71uKNcPtulMeCTQOzv/4HN77BPb39zGW9EZineWuAGR3S4FzyUdEJmEdqaHMji4IEbke6+iO6Zu2c2HxOwrnioiIHCAi/wyaYhphQ03HhR2Xc3mJW6IQkedFZLWIzMrldRGRp0VkoYjMEJGj4hWLcwmiDDb6ZxPWGf821g/hXEKLW9NT0Dm6GXhRVZvm8PqZWFvzmdjkroGqekz27ZxzzoUrbncUqvoFNnY+Nx2xJKKq+i1QTURi7exyzjlXRMIsxlWLPUdhpAfPrcy+oYh0xeq8ULFixZaHHXZYkQTonHPJ7PffYceylVTf8RvTyVqrqjXzs58wE0VOpaJzbAdT1WHAMIC0tDSdNm1aPONyzrmktXMnvPYaPNpPWbhQuKbmO9x82Mc0/3LQ0vzuM8xRT+nsOTO1NlbJ1Dnn3F7auhWefRZaHryB7Zdfw7/XPMxLL8GQX8+h2RfPFmjfYd5RvAPcJCJjsM7s34MZnc4552K0YQMMGgQDB8IJa8fxeekb2KfEGqTbPchlhXOMuCUKERmNFaqrIbYqWB+sUBiqOhSroXMmNvN3K7YOgHPOuRisWAFPPglDh0KFzat464DutOYNaNICRr4PRxXejIO4JQpVvTiP1xVbuMY551yMFiyAxx+HF1+EjAzo0gXu77Cchte+Dw89BHfcAaVLF+oxfQlC55xLAt9/D/36wZtvQpkycOdFS7nl4Hepcf9NQBqcvgyqx6f+oScK55xLUKowcaIliE8+gSpV4D+9suhVZQhVHg6KCF/XCQ44IG5JArzWk3POJZysLHjrLTjmGGjbFmbOhEcfhfTP5vPQVydS5a6b4J//hFmzLEnEmd9ROOdcgtixA155xZLC/PlwyCHw3HNwxRVQLmsr1D0BMjNh1Ch7UnKajlb4PFE451zINm+G4cNhwAD49Vdo0QLGjIFOnaDUogVQtiFIBXjpJXtx//2LND5venLOuZCsXQt9+kCdOnDrrdCwIXz0EfzwA1zUcRul+twNjRvbbQZAu3ZFniTA7yicc67ILVsGTzxhdxFbt8K550KvXnDsscEGX38N11xj7U9XXQVnnRVmuH5H4ZxzRWXOHLjySut7GDQILrwQZs+GceMikkTfvtC6NWzbBhMmwPPPwz/+EWbYfkfhnHPx9u23NsT17behQgW48UZraqpTJ2IjVeucbtECune3yXOVKoUV8h48UTjnXByowscfW4KYNMluCvr0gZtugho1IjZcvx569oQGDeDee+Hss+0ngXjTk3POFaLMTCvzfdRR1vf888/WH7FsGdx/f7YkMXYsHH44vPqqZZYE5XcUzjlXCLZtgxdesDpMv/wCjRpZ98Kll1rJjT2sXGm3Fm+9BS1b2q1H8+ahxB0Lv6NwzrkC+OMPeOwxqF8funWDffaxekyzZ9uApb8lCbDSrxMm2My6b79N6CQBfkfhnHP5smqVrQExeLAtOXraaTbd4eSTc5kwvWQJvPuudVS3bAnLl4c+milWniicc24vLF5szUvPP28lNzp1gt697dqfo8xMGwt7111QooSNid1//6RJEuBNT845F5MZM6y/oWFDGDECLr8c5s2DN96IkiTmzoU2beCWW2xuxKxZocysLii/o3DOuSi+/NKGuH7wgU1r6NkTevSAWrXyeOPWrZYksrJslaHLLiuyIn6FzROFc85lk5VliaFfP6umUaMGPPgg3HBDDC1G8+bZkKcKFazTonlz2G+/Iok7XrzpyTnnAjt3wssv27X97LMhPR2eeQaWLoW7784jSfz5pxVsatJkdxG/009P+iQBfkfhnHNs3Qr//S/072+Dk5o0sYreF10U4/LTX3wB115rs+uuvRY6dIh3yEXK7yicc8XWhg1WUqlePZv/duCBNoJ1xgzrUogpSfzf/8GJJ0JGBnz6qZWErVYtzpEXLb+jcM4VOytWwJNPwtChtmjQmWfaENfWrfdiJ7uK+KWlWQ93375QsWLcYg6TJwrnXLHx8882i/rFF+0GoEsXuPPOvZwYvXatJYaGDeG++2ytiJDXi4g3b3pyzqW877+Hzp1tMNJLL9maQD//vHtQUkxU4fXXbcW5MWNs8lwx4XcUzrmUpAoTJ9oQ108+gSpVrHnpllvyMRBpxQobG/v229bU9Omn0KxZXOJORJ4onHMpJSvLruf9+sGUKZYUHn0UrrsOqlbN505/+w0+/9xqd/ToAaWK16WzeH1a51zK2rHDmpIefdSWmj74YOus/te/oFy5fOxw0SJ45x1LDEcdZQtKpNhoplgVn0Y251xK2rzZRjAdcghcfTWUL29dCPPn213EXieJzEzbYdOmtiTdb7/Z88U0SYDfUTjnktTatfDsszZzev16m8owYoRNhs53SaXZs62n+7vvbCTT0KFJWcSvsHmicM4llWXLbGnR4cNtRnXHjlY547jjCrjjrVst24jY0qRduiRtEb/C5onCOZcU5s61ORAvv2yPL73U5kA0blzAHc+ZY+tWV6hgbVbNm0PNmgWON5V4H4VzLqF99x2cd54lhNdfhxtvtDWpR40qYJLYuhXuuAOOOGJ39jn1VE8SOfA7CudcwlGFjz+2Ia6TJlnV1vvus1VEa9QohANMmgT//jcsXGg93uecUwg7TV1+R+GcSxiZmXbX0LIltGtns6efeML6Jf7v/wopSfTpYwtbq9rciKFDCzDBonjwROGcC922bTBsmJXYuOgiaxUaOdKmMvTsaSvLFZiq/dmqFdx2m5WIPfnkQthx6otrohCRdiIyX0QWikjvHF6vKiLvishPIjJbRK6KZzzOucTyxx/WQV2/vrUA/eMf8OabNkr16quhTJlCOMiaNXDJJfDAA/b4rLNs4YkKFQph58VD3BKFiJQEBgHtgcbAxSKSvevpRmCOqjYHTgIGiEhh/NNwziWwVavgrrugTh0b2tq0KXz2mZXcOP98KFmyEA6iasNcDz8cxo4tpKxTPMWzM7sVsFBVFwGIyBigIzAnYhsFKouIAJWA9UBGHGNyzoVo8WL7Mv/887B9O3TqZIkiLa2QD5SeDtdfD++9B8ccY+1YTZoU8kGKj3gmilrA8ojH6cAx2bZ5FngHWAFUBi5S1azsOxKRrkBXgDp16sQlWOdc/MyYYTWYXnvNqnP/6182MvXQQ+N0wDVrbHnSJ56Am28upFuU4iuefRQ5TWnUbI/PAH4EDgRaAM+KSJW/vUl1mKqmqWpaTR/j7FzS+Oor6xJo3nx3fb3Fi21WdaEniYULrUYTwJFHwvLl1hPuSaLA4pko0oGDIh7Xxu4cIl0FvKVmIbAYOCyOMTnn4kzVWnxOOMGWFp0yxVYJXbrUmp1q1SrkA2Zk2I6POMLG0K5aZc9X+dt3TpdP8UwUU4GGIlI/6KDugjUzRVoGtAUQkf2ARsCiOMbknIuTjAwr892sGZx9tn2hf+YZSxD33AP77BOHg86cCccfb+1Yp59uw6X2elUil5e49VGoaoaI3ARMAEoCz6vqbBHpFrw+FOgLjBKRmVhTVS9VXRuvmJxzhW/rVvjvf+1L/ZIl1mf84otWU6906Tgf+OSTrdNjzBhb69SL+MVFXEt4qOoHwAfZnhsa8fsK4PR4xuCci48NG2DwYBg40PqOjzsOnn7a+iTiupz0rFmWjSpUsN7x5s0Lacq2y43PzHbO7ZUVK6xqa9261qR09NE2wOjrr63JKW5JYssWuPVWa9vaVcSvbVtPEkXAiwI652Ly88+2ZPQLL1h/RJculjCaNy+Cg3/2mRXxW7wYbrjBFqFwRcYThXMuqh9+sCquuyY3X3MN3H67rUldJO69Fx58EBo2hMmToU2bIjqw28Wbnpxzf6MKEyfCGWdYJdcJE6B3bxvBNHhwESWJrGDu7fHH263LTz95kgiJ31E45/6SlQVvv213EFOm2EjTfv2gW7cirMS9erXNpm7UyOZFtG9vPy40fkfhnGPHDhvi2qSJFeVbu9aWaViyxGoxFUmSULVO6sMPh3HjvLprAvE7CueKsc2bYcQIGDDA6ug1b25TEjp1glJFeXVYvtxuWz74wMbZjhhRCIthu8LiicK5YmjdOps1/cwzsH49nHii1V8644yQ5qytW2fjawcOtEWxvT5TQvFE4Vwxsny53T0MH24Tmzt2tKal444LIZgFC6xS4O23Q4sWFlzlyiEE4vLifRTOFQNz58JVV9lopUGD4IILrCzS+PEhJImMDKs53qwZPPTQ7iJ+niQSlicK51LYd9/BeedZc/9rr9lctYULbdJcKF0AP/1kCwn17g1nnglz5ngRvyTgTU/OpRhV+OQTG9Y6caKtQ33ffdC9e8jVLrZutZIbpUrZ7L1OnUIMxu0NTxTOpYjMTHjzTUsQ06fbug9PPGGVLypVCjGwGTNsrYgKFeCNN2xoVVxqjrt48aYn55Lc9u0wbBgcdhhcdJHVzhs5En75xRZ4Cy1JbN4Mt9xiHdUvvWTPnXyyJ4kk5HcUziWpP/6A556z1T9XroS0NLuj6NgxAUaXfvIJdO1qM/Zuusk6SlzS8kThXJJZvdqmGwwaBL//Dqeeal/YTzklQdbtuftuePhhK8Hx5Ze2JqpLajEnChGpqKpb4hmMcy53ixfbKnLPP2/NTZ062RyItLSwIwtkZdliFCecAP/5j/WglysXdlSuEOTZRyEix4vIHGBu8Li5iAyOe2TOOcCWhb7sMquyPXw4XHopzJtn/cIJkSR++80mZtx/vz1u397uKDxJpIxYOrOfBM4A1gGo6k+A1/p1Ls6++go6dLB5aW+/DT162F3FiBFw6KFhR4eNwx01yiZkvPceVKkSdkQuTmJqelLV5bJn42dmfMJxrnhThffftyGuX39t8x769rWJcgk1WGjpUuus/vhja2oaMcL6JFxKiiVRLBeR4wEVkTLAzQTNUM65wpGRYTOn+/WDWbOgTh14+mlbTS4hq21v3AhTp8Kzz8L118dxoWyXCGJJFN2AgUAtIB34GLghnkE5V1z8+ad1TvfvbyNJmzSBF1+09ahLlw47umzmz7cifnfcYZPmli0LeSafKyqxfA1opKqXqup+qrqvql4GHB7vwJxLZRs3Wn9v3bo2zeCAA+waPGMGXH55giWJnTvhkUcsOfTrZ+NzwZNEMRJLongmxuecc3lYscKWf65Tx6YbpKXB5MnWH3H22QnYgjN9uhXxu+suC3DOHNh337CjckUs16YnETkOOB6oKSK3RrxUBQh73qdzSeXnn+Hxx61qa0aGldro1cu+pCesrVvhtNPs9ubNN22NVFcsReujKANUCraJLBT/B3BBPINyLlX88IMtvTB2rF1vr7nG1uk5+OCwI4ti+nSrz1ShggXevLmVoHXFVq6JQlUnA5NFZJSqLi3CmJxLaqowaZI153/8sU0vuPNOq4+3//5hRxfFpk02o3rQILv1ueIKOOmksKNyCSCWUU9bReRxoAnw11RLVT0lblE5l4SysqxD+pFHYMoUW4+nXz/o1g2qVg07ujx89BFcd50tR3rLLd7M5PYQS9fZK8A8oD7wf8ASYGocY3IuqezYYROUmzSxIqlr18LQoTbctVevJEgS//mPld2oWNF61Z96ykc0uT3EckdRXVVHisgtEc1Rk+MdmHOJbvNmm5A8YACkp1tT/ujRVvaoVDLUZc7MtHrkJ51kAd9zD5QtG3ZULgHF8s95Z/DnShE5C1gB1I5fSM4ltnXrbELy00/D+vVw4olWrO+MMxKkzHdeVq6EG2+0W6C+fS3wM84IOyqXwGJJFA+KSFXgNmz+RBWgRzyDci4RLV9uS4sOG2YjR885B3r3huOOCzuyGO0q4nfrrbBtm68T4WKWZ6JQ1feCX38HTgYQkX/GMyjnEsncufDYY/Dyy/b4kktsFFOTJuHGtVeWLLHFsz/9FFq3TqAStC4ZRJtwVxLojNV4+khVZ4lIB+AuoDxwZNGE6Fw4vvvO5kCMH29LK9xwg30Zr1s37Mjy4fffbVLH4ME2uinhpoC7RBbtjmIkcBAwBXhaRJYCxwG9VXV8LDsXkXZYQcGSwAhV7ZfDNicBTwGlgbWqemLs4TtXuFRtued+/WDiRJtnds890L071KwZdnR7ac4cG6/bu/fuIn4VK4YdlUtC0RJFGtBMVbNEpBywFmigqr/FsuPgjmQQcBpWdXaqiLyjqnMitqkGDAbaqeoyEfEiMi4UmZlWpaJfP5uYfOCBNprp3/+GypXzfn9C2bHD2sr69rXgr77a6jN5knD5FO3+c4eqZgGo6jZgQaxJItAKWKiqi1R1BzAG6Jhtm0uAt1R1WXCc1Xuxf+cKbPt2G7F02GFWf2nLFhg5EhYtsmampEsS06bB0UfDvffapDkv4ucKQbQ7isNEZEbwuwCHBI8FUFVtlse+awHLIx6nA8dk2+ZQoLSITMLqSQ1U1Rez70hEugJdAerUqZPHYZ3L2x9/wHPPwZNP2mjRli2trNG559rUgqS0ZYsNcy1XztZOPeecsCNyKSJaoijomhM5jSjXHI7fEmiLdZD/T0S+VdUFe7xJdRgwDCAtLS37PpyL2erVMHCglTP6/Xc49VR46SU45ZQkmQORkx9+sCJ+FSvCuHG2yHa1amFH5VJItKKABS0EmI51hu9SG5usl32btaq6BdgiIl8AzYEFOFeIFi+2PoeRI6256fzzrY83LS3syArgjz/sQwwZsruIX5s2YUflUlA8x8hNBRqKSP1gre0uwDvZtnkbaC0ipUSkAtY05etxu0IzcyZcdhk0bGgT5S691OZFjB2b5Enigw9sIsdzz1lnSqdOYUfkUljcKtKoaoaI3ARMwIbHPq+qs0WkW/D6UFWdKyIfATOALGwI7ax4xeSKj6+/tiqu779vLTI9ekDPnlCrVtiRFYJevWxUU+PGlvGOyd7151zhiilRiEh5oI6qzt+bnavqB8AH2Z4bmu3x48Dje7Nf53Kial+0+/WDr76C6tXhgQesrNE++4QdXQGpWh3zkiWhbVvrsL7rLi/i54pEnk1PInI28CPwUfC4hYhkb0JyLjQZGfDKKzanrEMHm1f29NOwdKmNEk36JPHrrzYcq08fe3z66fB//+dJwhWZWPoo7sfmRGwEUNUfgXrxCsi5WP35p1WkaNjQ+iEyM+HFF2HhQptJnfTzy1RtkkfjxrZUXo0aYUfkiqlYmp4yVPV3Sdqxgy7VbNxoCeKpp2DNGjj2WBvy2qFDCpUwWrzYFtieONHWixg+HBo0CDsqV0zFkihmicglQEkRaQjcDHwT37Cc+7uVK22C3NChtrxz+/Y2OrR16ySeA5GbzZthxgwb1XTttSmUAV0yiuVfX3dsveztwKtYufEecYzJuT0sXGgFT+vVs7kQHTrAjz9ax3WbNimUJGbNgocftt+POMI6W7p29SThQhfLHUUjVb0buDvewTgX6YcfrMz32LFQurTVtrv9djjkkLAjK2Q7dthY3ocesgW2r73W6jNVqBB2ZM4Bsd1RPCEi80Skr4gk01ItLgmpWrP8GWdY/aWPPrJFgpYssQnIKZckpk61D3r//XDhhV7EzyWkWFa4O1lE9scWMRomIlWA11T1wbhH54qNrCxbOqFfP1swaL/97Pdu3exLdkrasgXatYPy5e3Dn3122BE5l6OYGj9V9TdVfRrohs2puC+eQbniY8cOW8a5SRM47zwbxTRkiA366dUrRZPEtGmWGStWtCqvs2d7knAJLZYJd4eLyP0iMgt4FhvxVDvukbmUtmWLDWlt0ACuusrmjo0eDfPn211E+fJhRxgHv/9uvfJHH717Ae4TTkjRbOhSSSyd2f8FRgOnq2r26q/O7ZV16+DZZ23m9Pr1Nmpp2DDrk0iZ0Us5efddy4C//WY98hdcEHZEzsUslj6KY4siEJfali+HJ56wpLB1q62p06sXHH982JEVgTvugP79bcjr+PF2R+FcEsk1UYjI66raWURmsueCQ7GucOcc8+ZZodOXX7Zm+UsvtVFMTVJ9/Jyq1RQpVcpqM1WpYpmxTJmwI3Nur0W7o7gl+LNDUQTiUsuUKTZqafx4K3TarRvcdhvUrRt2ZEUgPR2uv95WmnvoITjtNPtxLknl2pmtqiuDX29Q1aWRP8ANRROeSyaqVrvulFNsiYRJk+Cee6yK69NPF4MkkZVlJTcaN4bPP4f99w87IucKRSzDY3P6KtS+sANxySszE954w1aMO+MMG7k0YIAliAcegJo1w46wCCxaZBmyWzdo1cqW1uvePeyonCsU0foorsfuHA4WkRkRL1UGvo53YC7xbd9uZb0fe8zqMR16KIwYYSW/i91SCVu22KzqESOs1khKD+FyxU20PopXgQ+BR4DeEc9vUtX1cY3KJbQ//rAWlieftIquLVtaPaZzz7UF2IqNmTNtwtw999iIpqVLU3QCiCvuojU9qaouAW4ENkX8ICLJvmaYy4fVq+2aWLeujVxq3Bg+/dTKFXXqVIySxPbtcN99cNRR1vmyerU970nCpai87ig6AN9jw2Mj76UVODiOcbkEsmSJTQMYOdKukeefbyM9i+V0gG+/tQWF5syByy+326rq1cOOyrm4yjVRqGqH4M/6RReOSyQzZ1qZ7zFjbEmEK66wuWONGoUdWUi2bIGzzrIaTR98YCsnOVcMxFLr6Z8iUjH4/TIReUJE6sQ/NBeWr7+2GnXNmtk8iFtusSJ9I0YU0yTx3Xe7i/i9+64V8fMk4YqRWIbHDgG2ikhz4E5gKfBSXKNyRU4V3n/flhU94QT43/9saOuyZTbUtVatsCMMwcaNtojQscfuLuJ3/PFQuXKoYTlX1GJJFBmqqkBHYKCqDsSGyLoUkJEBr74KzZvbEqPLlln/7NKlcO+9sE9xHbYwfrz11o8aZR0yF14YdkTOhSaW6rGbROQ/wOVAaxEpCZSOb1gu3v78E/77X3j8ceusbtwYXngBLr7Ylh0t1m691Tqpmze3pqaWLcOOyLlQxZIoLgIuAa5W1d+C/onH4xuWi5eNG2HwYHjqKVsk6NhjbV2IDh2sw7rYiizid+aZNpLpzjs9azoHiLUq5bGRyH7ArsGQU1R1dVyjiiItLU2nTZsW1uGT1sqVlhyGDIFNm6wvtndv65Mo9pOIly2z0htHHmlF/JxLQSLyvaqm5ee9sYx66gxMAS7E1s3+TkR81ZUksXChLapWr57NhTjrLJg+3UZ3tmlTzJNEVpbdXjVpApMnw4EHhh2Rcwkplqanu4Gjd91FiEhN4FNgbDwDcwUzfbqV+R471lpPrr7aFlY75JCwI0sQCxfaSfnySysBPmyYZVPn3N/EkihKZGtqWkdso6VcEVO1L8b9+sGECbZWzp132jwIr3idzbZtsGCB9ej/61/F/NbKuehiSRQficgEbN1ssM7tD+IXkttbWVnwzjuWIL77DvbdFx55xNbOqVo17OgSyI8/WhG/Pn2gaVMb7lWuXNhROZfw8rwzUNU7gOeAZkBzYJiq9op3YC5vO3bYMP8mTeC882wU05Ahdv3r3duTxF+2bYO777YFM4YM2V3Ez5OEczGJth5FQ6A/cAgwE7hdVX8tqsBc7rZssXIaAwbA8uU23H/0aLjgAhvd6SJ8840V8Zs3z5qYnniiGM8idC5/ol1WngdeBL4AzgaeAc4viqBcztatg2eftZnT69fbqKXnnoN27byJPUdbtljRqkqV4KOPbPk959xei5YoKqvq8OD3+SLyQ1EE5P4uPd2+CA8bZte+c86xqhLHHx92ZAnqf/+zRbsrVoT33rP+CK/P5Fy+ReujKCciR4rIUSJyFFA+2+M8iUg7EZkvIgtFpHeU7Y4WkUyfn7GnefNsBOfBB9tdxPnnw6xZ1h/rSSIHGzbYCTv+eHgpqFt53HGeJJwroGh3FCuBJyIe/xbxWIFTou04qAk1CDgNSAemisg7qjonh+0eBSbsXeipa8oUG8E0frz1t3brBrfdZivLuVy89RbceKP16P/nP3DRRWFH5FzKiLZw0ckF3HcrYKGqLgIQkTFYBdo52bbrDrzJ7hIhxZKqLSvarx98/jlUq2bLjnbvDjVrhh1dguvZ0+qTtGhhU86PPDLsiJxLKfEcI1MLWB7xOB04JnIDEakFnIfdneSaKESkK9AVoE6d1FozKTPTvgz36wc//GBVJPr3h65dvcUkqsgifh062OSR22/3In7OxUE8Z1jnNA4newXCp4BeqpoZbUeqOkxV01Q1rWaKfL3evh2GD4fDDoPOnWHzZhvyumiRNTN5kohiyRIb6nXvvfa4bVtrbvIk4VxcxPOOIh04KOJxbWBFtm3SgDFiYztrAGeKSIaqjo9jXKHatMmGtD7xhFV0bdnS6jGdey6ULBl2dAkuKwsGDbKkIGKzDJ1zcZdnohC7il8KHKyqDwTrUeyvqlPyeOtUoKGI1Ad+Bbpg61r8RVXrRxxnFPBeqiaJ1att5NKgQbYmRNu28OKL9qfPgYjBzz/DVVfZgt7t2sHQod6771wRieWOYjCQhfUjPABsIobOZ1XNEJGbsNFMJYHnVXW2iHQLXh9akMCTxZIl1ucwcqQ1N51/vs2BOLpYd93nw44d8Msvll0vu8yzq3NFKJZEcYyqHiUi0wFUdYOIlIll56r6AdkKCOaWIFT1ylj2mSxmzoTHHrPSGiVKwOWXWyXXRo3CjiyJTJ9uk0buv98KWi1ZAmXLhh2Vc8VOLJ3ZO4O5Dgp/rUeRFdeoktjXX1vViGbNYNw4K/G9aJHdUXiSiNG2bdYPcfTR1qGzZo0970nCuVDEkiieBsYB+4rIQ8BXwMNxjSrJqNrw/dat4YQTrILEAw/YCpsDBkDt2mFHmES++sqqHPbrB1dcAXPm+EQS50KWZ9OTqr4iIt8DbbEhr+eq6ty4R5YEMjLg9dftmjZzJhx0EAwcaMVKK1YMO7oktHkzdOxoKy59/LGtPOecC10so57qAFuBdyOfU9Vl8Qwskf35py2M9vjj1mzeuDG88AJcfLEP5c+Xr76y+kyVKsH771sRv0qVwo7KOReIpenpfeC94M/PgEXAh/EMKlFt3Ggrx9WrZ2WF9t/f+lpnzrRWEk8Se2ndOjtxrVvvLuJ37LGeJJxLMLE0PR0R+TioHHtd3CJKQCtXWimhIUNswly7draCXJs2PkozX1RtluFNN9nCGvfeC126hB2Vcy4Xez0zW1V/EJFiMQtg4UJrXho1yvojOne2ORAtWoQdWZLr2dM6c1q2tL6I5s3Djsg5F0UsfRS3RjwsARwFrIlbRAlg+nR49FF44w1rTrr6aqs3d8ghYUeWxFQt25YubSsvHXgg3Hqrr93qXBKI5X9pZHm6DKyv4s34hBMeVZg82UYwTZhgRfnuuMPmQRxwQNjRJbnFi60cbsuWdoJPOcV+nHNJIWqiCCbaVVLVO4ooniKXlQXvvGPXr+++s2rVjzxiiwVVqxZ2dEkuM9MW+b7rLqt4eOGFYUfknMuHXBOFiJQK6jXFtOxpstm5E1591ZqY5s6F+vWts/pf/4Ly5cOOLgUsWABXXmmzD9u3txnWBx2U59ucc4kn2h3FFKw/4kcReQd4A9iy60VVfSvOscXFli227sOAAbB8uZXaePVV+7LrzeWFKCMDli6Fl1+GSy7x4WHOJbFYLo37AOuw6rGKzc5WIKkSxbp11gryzDP2e5s29iW3XTu/hhWaadNsYknfvjYLcdEir8/kXAqIlij2DUY8zWJ3gtgl+0p1CSs93RYJGjbM7ibOPtvmQBx/fNiRpZA//4Q+few2bf/94eabrT6TJwnnUkK0RFESqERsS5omnHnzrMz3yy9bh/Ull1iZ76ZNw44sxUyeDNdea5NO/v1vO+k+CsC5lBItUaxU1QeKLJJCMnWqjWAaNw7KlbPRS7feamU3XCHbvNlWYqpWDT77zIe8OpeioiWKpGm5V4VPP7UE8fnndt26++7dLSCukH35Jfzzn1aT6cMPbVEhL5frXMqKVhSwbZFFkU+ZmTZ7Oi0NTj/dmpv697d1IPr29SRR6NautWVI27TZXcSvVStPEs6luFzvKFR1fVEGsje2b7fr1GOPwc8/Q8OGNuT1ssu8/zQuVG3hje7dYcMG67j2In7OFRtJN3Ng1SqbHLdypVWEeOMNOO88m/jr4uSWW2xc8dFHW1/EEUfk/R7nXMpIukSRng5t28KLL9qfPgciTlRt+nqZMpaJ69aFHj08IztXDIlqwo903UPJkmmamTkt7DBS2y+/2FDXtDRr33POJT0R+V5V0/Lz3lhWuHPFRWamzU484gj4/nto1CjsiJxzCSDpmp5cnMybZxURp0yx6etDhkCtWmFH5ZxLAJ4onMnKghUrYPRouOgi7/xxzv3FE0VxNmWKFfF76CEr4vfLL9Z57ZxzEbyPojjautXWdj3uOHjhBVgTrGzrScI5lwNPFMXNxInWWT1ggI1smj3bp7A756LypqfiZPNmW6GpWjVLGCedFHZEzrkk4HcUxcGkSdZZvauI34wZniScczHzRJHK1qyBiy+Gk0+2hTnAynBUqBBuXM65pOJNT6lI1Ya53nwzbNpkpXS9iJ9zLp88UaSi7t1h0CA49lgYOdKGvjrnXD55okgVWVmQkWFDXC+4ABo0sIThRfyccwUU1z4KEWknIvNFZKGI9M7h9UtFZEbw842INI9nPCnr559tGdK777bHJ53klV6dc4UmbolCREoCg4D2QGPgYhHJ3gayGDhRVZsBfYFh8YonJWVk2JJ+zZrBjz/C4YeHHZFzLgXFs+mpFbBQVRcBiMgYoCMwZ9cGqvpNxPbfArXjGE9qmTsXrrgCpk2Djh1h8GA48MCwo3LOpaB4Nj3VApZHPE4PnsvNNcCHOb0gIl1FZJqITEu29TPiatUqeO01GDfOk4RzLm7ieUeRU/nRHK/yInIylihOyOl1VR1G0CxVsmRa8c0U335rRfweecSamX75BUqXDjsq51yKi+cdRTpwUMTj2sCK7BuJSDNgBNBRVdfFMZ7ktWUL9OwJxx8Pr7yyu4ifJwnnXBGIZ6KYCjQUkfoiUgboArwTuYGI1AHeAi5X1QVxjCV5ffopNG0KTz0FN9zgRfycc0Uubk1PqpohIjcBE4CSwPOqOltEugWvDwXuA6oDg8UWysnI75quKWnzZptRvc8+8MUX0Lp12BE554ohSbbO4ZIl0zQzc1rYYcTX55/DiSfaPIjvv7eZ1eXLhx2Vcy6Jicj3+f0i7kUBE8mqVdC5M7Rtu7uIX8uWniScc6HyRJEIVOGll+zOYdfSpJdcEnZUzjkHeK2nxHDjjTBkiC1NOnKkz7B2ziUUTxRhycqCnTuhbFm46CJLDjfc4PWZnHMJx5uewjB/vnVW7yrid+KJXunVOZewPFEUpZ07oV8/aN4cZs2CI44IOyLnnMuTNz0Vldmz4fLLYfp0OP98W1ho//3Djso55/LkiaKolCwJ69fD2LHQqVPY0TjnXMy86SmevvkGevWy3w87DBYu9CThnEs6nijiYfNmuPlmOOEEKwO+dq09X8pv4JxzyccTRWH7+GMr4vfss3DTTdZpXaNG2FE551y++VfcwrR5M1x6KVSvDl9+Cf/8Z9gROedcgfkdRWH45BPIzIRKleyO4scfPUk451KGJ4qCWLnSOqdPP90WFAI48kgoVy7cuJxzrhB5osgPVRg1yor4vf++TaLzIn7OuRTlfRT5cf318NxzNqppxAho1CjsiJxLSDt37iQ9PZ1t27aFHUqxUa5cOWrXrk3pQlwq2RNFrCKL+F1yCTRrBt26QQm/KXMuN+np6VSuXJl69eoRrGLp4khVWbduHenp6dSvX7/Q9utXuVjMnWvLkN51lz1u08YqvXqScC6qbdu2Ub16dU8SRUREqF69eqHfwfmVLpqdO+Hhh6FFC5g3zzqqnXN7xZNE0YrH+famp9zMng2XXWZDXS+8EJ55BvbbL+yonHOuyPkdRW5KlYLff4e33oLXX/ck4VwSGzduHCLCvHnz/npu0qRJdOjQYY/trrzySsaOHQtYR3zv3r1p2LAhTZs2pVWrVnz44YcFjuWRRx6hQYMGNGrUiAkTJuS63TPPPEOjRo1o0qQJd9555x6vLVu2jEqVKtG/f/8CxxMLv6OI9OWXtmZ1//42kmnBAq/P5FwKGD16NCeccAJjxozh/vvvj+k99957LytXrmTWrFmULVuWVatWMXny5ALFMWfOHMaMGcPs2bNZsWIFp556KgsWLKBktkXLJk6cyNtvv82MGTMoW7Ysq1ev3uP1nj170r59+wLFsjf8KgiwaRP07g2DB0P9+vZ7jRqeJJwrRD16WEtuYWrRAp56Kvo2mzdv5uuvv2bixImcc845MSWKrVu3Mnz4cBYvXkzZsmUB2G+//ejcuXOB4n377bfp0qULZcuWpX79+jRo0IApU6Zw3HHH7bHdkCFD6N2791/H3nffff96bfz48Rx88MFUrFixQLHsDW96+vBDaNIEhgyxf8kzZ3oRP+dSyPjx42nXrh2HHnoo++yzDz/88EOe71m4cCF16tShSpUqeW7bs2dPWrRo8beffv36/W3bX3/9lYMOOuivx7Vr1+bXX3/923YLFizgyy+/5JhjjuHEE09k6tSpAGzZsoVHH32UPn365BlXYSreX5k3bYIrroB997W1I449NuyInEtZeX3zj5fRo0fTo0cPALp06cLo0aM56qijch0dtLejhp588smYt1XVmI6XkZHBhg0b+Pbbb5k6dSqdO3dm0aJF9OnTh549e1KpUqW9irGgil+iUIUJE+C006ByZfj0U1tUKLjFc86ljnXr1vH5558za9YsRITMzExEhMcee4zq1auzYcOGPbZfv349NWrUoEGDBixbtoxNmzZRuXLlqMfo2bMnEydO/NvzXbp0oXfv3ns8V7t2bZYvX/7X4/T0dA488MC/vbd27dqcf/75iAitWrWiRIkSrF27lu+++46xY8dy5513snHjRkqUKEG5cuW46aab9ua07D1VTaqfEiVaar6tWKF67rmqoPrCC/nfj3MuJnPmzAn1+EOHDtWuXbvu8VybNm30iy++0G3btmm9evX+inHJkiVap04d3bhxo6qq3nHHHXrllVfq9u3bVVV1xYoV+tJLLxUonlmzZmmzZs1027ZtumjRIq1fv75mZGT8bbshQ4bovffeq6qq8+fP19q1a2tWVtYe2/Tp00cff/zxHI+T03kHpml+r7vxTUMJQhWefx4OPxw++ggee8yL+DlXDIwePZrzzjtvj+c6derEq6++StmyZXn55Ze56qqraNGiBRdccAEjRoygatWqADz44IPUrFmTxo0b07RpU84991xq1qxZoHiaNGlC586dady4Me3atWPQoEF/jXi69tprmTZtGgBXX301ixYtomnTpnTp0oUXXngh1ImLojm0mSWykiXTNDNz2t696brrYNgwK70xYgQ0bBif4Jxze5g7dy6HH3542GEUOzmddxH5XlXT8rO/1O2jyMy0EhzlytkM6yOPhK5dvT6Tc87tpdS8as6ebSvM7Sri17q1V3p1zrl8Sq0r544d0Lev3T0sXAhHHx12RM4Ve8nWvJ3s4nG+U6fpaeZMuPRS+7NLF3j6aShgx5NzrmDKlSvHunXrvNR4EdFgPYpyhbwcc+okijJlYOtWq9V0zjlhR+Ocw+YDpKens2bNmrBDKTZ2rXBXmJJ71NPkyfDOOzBggD3OzIRsxbWcc84VbNRTXPsoRKSdiMwXkYUi0juH10VEng5enyEiR8W04z/+sHWrTzoJxo+HtWvteU8SzjlX6OKWKESkJDAIaA80Bi4WkcbZNmsPNAx+ugJD8tpvFf3divgNGwa33upF/JxzLs7ieUfRClioqotUdQcwBuiYbZuOwIvBDPNvgWoickC0ndbVJVC1qhXxGzAAKlSIS/DOOedMPDuzawHLIx6nA8fEsE0tYGXkRiLSFbvjANgus2fP8kqvANQA1oYdRILwc7Gbn4vd/Fzs1ii/b4xnoshpLFz2nvNYtkFVhwHDAERkWn47ZFKNn4vd/Fzs5udiNz8Xu4nIXtY+2i2eTU/pwEERj2sDK/KxjXPOuRDFM1FMBRqKSH0RKQN0Ad7Jts07wBXB6Kdjgd9VdWX2HTnnnAtP3JqeVDVDRG4CJgAlgedVdbaIdAteHwp8AJwJLAS2AlfFsOthcQo5Gfm52M3PxW5+Lnbzc7Fbvs9F0k24c845V7RSqyigc865QueJwjnnXFQJmyjiVv4jCcVwLi4NzsEMEflGRJqHEWdRyOtcRGx3tIhkisgFRRlfUYrlXIjISSLyo4jMFpHJRR1jUYnh/0hVEXlXRH4KzkUs/aFJR0SeF5HVIjIrl9fzd93M72Lb8fzBOr9/AQ4GygA/AY2zbXMm8CE2F+NY4Luw4w7xXBwP/CP4vX1xPhcR232ODZa4IOy4Q/x3UQ2YA9QJHu8bdtwhnou7gEeD32sC64EyYcceh3PRBjgKmJXL6/m6bibqHUVcyn8kqTzPhap+o6obgoffYvNRUlEs/y4AugNvAquLMrgiFsu5uAR4S1WXAahqqp6PWM6FApXFFsWohCWKjKINM/5U9Qvss+UmX9fNRE0UuZX22NttUsHefs5rsG8MqSjPcyEitYDzgKFFGFcYYvl3cSjwDxGZJCLfi8gVRRZd0YrlXDwLHI5N6J0J3KKqWUUTXkLJ13UzURcuKrTyHykg5s8pIidjieKEuEYUnljOxVNAL1XNTPEV1WI5F6WAlkBboDzwPxH5VlUXxDu4IhbLuTgD+BE4BTgE+EREvlTVP+IcW6LJ13UzUROFl//YLabPKSLNgBFAe1VdV0SxFbVYzkUaMCZIEjWAM0UkQ1XHF0mERSfW/yNrVXULsEVEvgCaA6mWKGI5F1cB/dQa6heKyGLgMGBK0YSYMPJ13UzUpicv/7FbnudCROoAbwGXp+C3xUh5ngtVra+q9VS1HjAWuCEFkwTE9n/kbaC1iJQSkQpY9ea5RRxnUYjlXCzD7qwQkf2wSqqLijTKxJCv62ZC3lFo/Mp/JJ0Yz8V9QHVgcPBNOkNTsGJmjOeiWIjlXKjqXBH5CJgBZAEjVDXHYZPJLMZ/F32BUSIyE2t+6aWqKVd+XERGAycBNUQkHegDlIaCXTe9hIdzzrmoErXpyTnnXILwROGccy4qTxTOOeei8kThnHMuKk8UzjnnovJE4RJSUPn1x4ifelG23VwIxxslIouDY/0gIsflYx8jRKRx8Ptd2V77pqAxBvvZdV5mBdVQq+WxfQsRObMwju2KLx8e6xKSiGxW1UqFvW2UfYwC3lPVsSJyOtBfVZsVYH8Fjimv/YrIC8ACVX0oyvZXAmmqelNhx+KKD7+jcElBRCqJyGfBt/2ZIvK3qrEicoCIfBHxjbt18PzpIvK/4L1viEheF/AvgAbBe28N9jVLRHoEz1UUkfeDtQ1michFwfOTRCRNRPoB5YM4Xgle2xz8+VrkN/zgTqaTiJQUkcdFZKrYOgHXxXBa/kdQ0E1EWomtRTI9+LNRMEv5AeCiIJaLgtifD44zPafz6NzfhF0/3X/8J6cfIBMr4vYjMA6rIlAleK0GNrN01x3x5uDP24C7g99LApWDbb8AKgbP9wLuy+F4owjWrgAuBL7DCurNBCpipalnA0cCnYDhEe+tGvw5Cfv2/ldMEdvsivE84IXg9zJYJc/yQFfgnuD5ssA0oH4OcW6O+HxvAO2Cx1WAUsHvpwJvBr9fCTwb8f6HgcuC36thdZ8qhv337T+J/ZOQJTycA/5U1Ra7HohIaeBhEWmDlaOoBewH/BbxnqnA88G241X1RxE5EWgMfB2UNymDfRPPyeMicg+wBqvC2xYYp1ZUDxF5C2gNfAT0F5FHseaqL/fic30IPC0iZYF2wBeq+mfQ3NVMdq/IVxVoCCzO9v7yIvIjUA/4HvgkYvsXRKQhVg20dC7HPx04R0RuDx6XA+qQmjWgXCHxROGSxaXYymQtVXWniCzBLnJ/UdUvgkRyFvCSiDwObAA+UdWLYzjGHao6dtcDETk1p41UdYGItMRq5jwiIh+r6gOxfAhV3SYik7Cy1xcBo3cdDuiuqhPy2MWfqtpCRKoC7wE3Ak9jtYwmqup5Qcf/pFzeL0AnVZ0fS7zOgfdRuORRFVgdJImTgbrZNxCRusE2w4GR2JKQ3wL/FJFdfQ4VROTQGI/5BXBu8J6KWLPRlyJyILBVVV8G+gfHyW5ncGeTkzFYMbbWWCE7gj+v3/UeETk0OGaOVPV34Gbg9uA9VYFfg5evjNh0E9YEt8sEoLsEt1cicmRux3BuF08ULlm8AqSJyDTs7mJeDtucBPwoItOxfoSBqroGu3COFpEZWOI4LJYDquoPWN/FFKzPYoSqTgeOAKYETUB3Aw/m8PZhwIxdndnZfIytbfyp2tKdYGuJzAF+EJFZwHPkcccfxPITVlb7Mezu5mus/2KXiUDjXZ3Z2J1H6SC2WcFj56Ly4bHOOeei8jsK55xzUXmicM45F5UnCuecc1F5onDOOReVJwrnnHNReaJwzjkXlScK55xzUf0/EZ6VaNBP5dMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import sklearn.metrics as metrics\n",
    "preds = svm.predict(Xb_test)\n",
    "fpr, tpr, threshold = metrics.roc_curve(yb_test[:,0], preds)\n",
    "roc_auc = metrics.auc(fpr, tpr)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.title('Receiver Operating Characteristic')\n",
    "plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\n",
    "plt.legend(loc = 'lower right')\n",
    "plt.plot([0, 1], [0, 1],'r--')\n",
    "plt.xlim([0, 1])\n",
    "plt.ylim([0, 1])\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Balanced train set, balanced evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM classifier accuracy: 0.67\n",
      "SVM classifier accuracy - test set: 0.635\n",
      "0.9849906191369606\n",
      "0.6791979949874686\n"
     ]
    }
   ],
   "source": [
    "svm_b = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "svm_b.fit(Xb_train, yb_train[:,0])\n",
    "print(f'SVM classifier accuracy: {svm.score(Xb_train, yb_train[:,0])}')\n",
    "print(f'SVM classifier accuracy - test set: {svm.score(Xb_test, yb_test[:,0])}')\n",
    "\n",
    "y_pred = svm_b.predict(Xb_train)\n",
    "print(f1_score(y_pred, yb_train[:,0], average = \"macro\"))\n",
    "y_pred_test = svm_b.predict(Xb_test)\n",
    "print(f1_score(y_pred_test, yb_test[:,0], average = \"macro\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/tUlEQVR4nO3dd3hUZfbA8e+hIyIoCCpFUBApAgKCDURRDK4dRey46yIWXF0bdteK9WdDENHFguCKvVAsNEUEFKSDSA0g0iEUIeT8/jg3ZggpQ5LJnZmcz/PMQ2bmzr1nbsicee/7vucVVcU555zLTamwA3DOORffPFE455zLkycK55xzefJE4ZxzLk+eKJxzzuXJE4Vzzrk8eaJw+0REZotIx7DjiBcico+IDArp2INF5NEwjl3URORyERldwNf6/8kY80SRwERkiYhsF5E0Efk9+ODYP5bHVNWmqjo2lsfIJCLlReQJEVkWvM9fReQOEZHiOH4O8XQUkdTIx1T1cVW9NkbHExG5WURmichWEUkVkfdF5JhYHK+gROQhEXmnMPtQ1SGq2jmKY+2VHIvz/2RJ5Yki8Z2jqvsDLYFjgbvDDWffiUiZXJ56H+gEnAVUBq4EegIvxCAGEZF4+3t4AfgXcDNwEHAU8DHwt6I+UB6/g5gL89guSqrqtwS9AUuA0yPuPwV8EXH/eGAisBH4BegY8dxBwH+BlcAG4OOI584Gpgevmwg0z35M4DBgO3BQxHPHAmuBssH9vwNzg/2PAg6P2FaBG4FfgcU5vLdOwA6gTrbH2wG7gQbB/bHAE8BkYBPwSbaY8joHY4HHgO+D99IAuCaIeQuwCLgu2LZSsE0GkBbcDgMeAt4JtqkXvK+rgWXBubg34ngVgTeD8zEXuBNIzeV32zB4n23z+P0PBvoBXwTx/ggcGfH8C8ByYDPwE9A+4rmHgOHAO8Hz1wJtgR+Cc7UKeBkoF/GapsBXwHpgNXAPkALsBHYF5+SXYNsqwOvBflYAjwKlg+d6BOf8/4J9PRo89l3wvATP/RH8TmcAzbAvCbuC46UBn2X/OwBKB3H9FpyTn8j2f8hvBfisCTsAvxXil7fnH0htYCbwQnC/FrAO+zZeCjgjuH9w8PwXwHvAgUBZ4JTg8VbBH2i74I/u6uA45XM45rfAPyPieRoYEPx8PrAQaAyUAe4DJkZsq8GHzkFAxRzeW19gXC7veylZH+Bjgw+iZtiH+QdkfXDndw7GYh/oTYMYy2Lf1o8MPqxOAbYBrYLtO5Ltg52cE8VrWFJoAfwJNI58T8E5r419AOaWKHoBS/P5/Q/GPmjbBvEPAYZFPH8FUC147jbgd6BCRNy7gt9TqSDe1lhiLRO8l7nALcH2lbEP/duACsH9dtnPQcSxPwZeDX4nNbBEnvk76wGkA72DY1Vkz0RxJvYBXzX4PTQGDo14z4/m8XdwB/Z30Ch4bQugWth/q4l+Cz0AvxXil2d/IGnYNycFvgGqBs/dBbydbftR2Af/odg34wNz2Gd/4JFsj80nK5FE/lFeC3wb/CzYt9cOwf0RwD8i9lEK+9A9PLivwGl5vLdBkR962Z6bRPBNHfuw7xvxXBPsG2fpvM5BxGsfzuccfwz8K/i5I9ElitoRz08Gugc/LwLOjHju2uz7i3juXmBSPrENBgZF3D8LmJfH9huAFhFxj89n/7cAHwU/XwpMy2W7v85BcL8mliArRjx2KTAm+LkHsCzbPnqQlShOAxZgSatUDu85r0QxHzivsH9bftvzFm/XZN2+O19VK2MfYkcD1YPHDwcuFpGNmTfgZCxJ1AHWq+qGHPZ3OHBbttfVwS6zZDccOEFEDgM6YB+SEyL280LEPtZjyaRWxOuX5/G+1gax5uTQ4Pmc9rMUaxlUJ+9zkGMMItJFRCaJyPpg+7PIOqfR+j3i521A5gCDw7IdL6/3v47c3380x0JEbhORuSKyKXgvVdjzvWR/70eJyOfBwIjNwOMR29fBLudE43Dsd7Aq4ry/irUscjx2JFX9Frvs1Q9YLSIDReSAKI+9L3G6KHmiSBKqOg77tvVM8NBy7Nt01YhbJVXtGzx3kIhUzWFXy4HHsr1uP1UdmsMxNwKjgW7AZcBQDb7WBfu5Ltt+KqrqxMhd5PGWvgbaiUidyAdFpC32YfBtxMOR29TFLqmszecc7BWDiJTHLl09A9RU1arAl1iCyy/eaKzCLjnlFHd23wC1RaRNQQ4kIu2xFlU3rOVYFbveHzliLPv76Q/MAxqq6gHYtf7M7Zdjl+Rykn0/y7EWRfWI836AqjbN4zV77lD1RVVtjV0WPAq7pJTv6/KJ0xWQJ4rk8jxwhoi0xDopzxGRM0WktIhUCIZ31lbVVdiloVdE5EARKSsiHYJ9vAb0EpF2wUigSiLyNxGpnMsx3wWuAroGP2caANwtIk0BRKSKiFwc7RtR1a+xD8sPRKRp8B6Ox67D91fVXyM2v0JEmojIfsDDwHBV3Z3XOcjlsOWA8sAaIF1EugCRQzZXA9VEpEq07yOb/2Hn5EARqQXclNuGwft7BRgaxFwuiL+7iPSJ4liVsX6ANUAZEXkAyO9beWWsYztNRI4Gro947nPgEBG5JRi2XFlE2gXPrQbqZY4aC/5/jQaeFZEDRKSUiBwpIqdEETciclzw/68ssBUb1LA74lhH5PHyQcAjItIw+P/bXESqRXNclztPFElEVdcAbwH3q+py4DzsW+Ea7JvWHWT9zq/EvnnPwzqvbwn2MRX4J9b034B1SPfI47CfYiN0VqvqLxGxfAQ8CQwLLmPMArrs41vqCowBRmJ9Me9gI2l6Z9vubaw19TvW0XpzEEN+52APqroleO3/sPd+WfD+Mp+fBwwFFgWXVHK6HJeXh4FUYDHWYhqOffPOzc1kXYLZiF1SuQD4LIpjjcK+DCzALsftIO9LXQC3Y+95C/aF4b3MJ4JzcwZwDnaefwVODZ5+P/h3nYj8HPx8FZZ452DncjjRXUoDS2ivBa9bil2Gy2wpvw40Cc7/xzm89jns9zcaS3qvY53lrhAk60qBc4lHRMZiHamhzI4uDBG5HuvojuqbtnNh8RaFc8VERA4VkZOCSzGNsKGmH4Udl3P5iVmiEJE3ROQPEZmVy/MiIi+KyEIRmSEirWIVi3Nxohw2+mcL1hn/CdYP4Vxci9mlp6BzNA14S1Wb5fD8Wdi15rOwyV0vqGq77Ns555wLV8xaFKo6Hhs7n5vzsCSiqjoJqCoi0XZ2OeecKyZhFuOqxZ6jMFKDx1Zl31BEemJ1XqhUqVLro48+ulgCdM65RLRjB2zeDJs2QaXNqziE35lGxlpVPbgg+wszUeRUKjrH62CqOhAYCNCmTRudOnVqLONyzrmEkpYGY8bAyJEwYgQsXgygHHWUcPspn9KZ0dT7rN/Sgu4/zESRyp4zU2tjlUydc87lQRXmzLGkMHIkTJgAO3dCpUpwzskb+OKQ26l5whEc9Oy9wLl2k34FPl6YieJT4CYRGYZ1Zm8KZnQ655zLZtMm+OabrOSQGiyh1bQp3HwzpKRAh3UfUfZfN8CaNdD5viI7dswShYgMxQrVVRdbFexBrFAYqjoAq6FzFjbzdxu2DoBzzjms1TB9uiWFkSNh4kRIT4cDDoDTT4cHH4Qzz4Q6dYDVq6F3b3j/fWjZEr74AloV3YyDmCUKVb00n+cVW7jGOeccsH49fPWVtRpGjYLfg9rAxx4Ld9xhrYYTToCyZbO9cPlySw6PPWYb7rVB4fgShM45F5KMDPjpp6zLST/+aI8deCB07gxduti/h+Y0cWDpUvjsM7jpJmjTBpYtg2qxqX/oicI554rRH3/A6NGWGEaNgrVrQcQ+6++7z1oNbdtC6dK57CAjA/r3hz5BEeGuXS2TxChJgCcK55yLqfR0mDw5q9Xw00/W/3DwwZYUUlKs1XBwNDMc5s+Ha6+F776zDopXX82luVG0PFE451wRW7nSWgsjRlifw8aNUKoUHH88PPywJYdWreyxqG3bBiefDLt3w+DBcNVV1hQpBp4onHOukHbtslFJma2GX4KVWQ49FC64wPoaTj/d+h722YIF0LAh7LcfvP22jWo65JCiDD9fniicc64Ali3LGrr69dewZQuUKWNf+vv2tVZD8+aF+NK/Ywc88gg8+aS1IK64wnYaAk8UzjkXhT//tBnQma2GOXPs8Tp14NJLrdVw2mk2z6HQvv8e/vEP65O45hr429+KYKcF54nCOedy8dtvWa2Gb7+1boJy5aBDB/scT0mBxo2LuKvgkUdsNl3dutbR0blz/q+JMU8UzjkX2LYNxo3LajX8+qs9fsQR9sU+JQVOPdVqKhU5Vcs4LVvaLOvHHoP994/BgfadJwrnXImlald3Mquujhtnl5gqVLCE0Lu3JYeGDWMYxPr1cOut0KAB3H8/nHOO3eKIJwrnXImSlmaXkTJbDUuW2ONHHw3XX299De3bQ8WKxRDM8OFw442WLO6/vxgOWDCeKJxzSU0VZs3K6muYMMGGs1aqBJ06wV132dy1+vWLMahVq6z0xocfQuvWNlW7RYtiDGDfeKJwziWdjRv3LMm9YoU9fswxcMst1mo46STrmA5F5oy8J5+Ef//bxtXGsfiOzjnnopCRsXdJ7t27bajqGWdYYjjzTKhdO8QglyyxIn69e1srYvnyAs7AK36eKJxzCWnduj1Lcq9ebY+3amWXk1JSrGRGEVfc3ne7d0O/fnDPPVaz4+KLbWZ1giQJ8EThnEsQu3fvWZJ78mRrSRx00J4luYu5ukXe5s61In4TJ1rmevXVOAswOp4onHNxa/Vq6+cdMcL+XbfOphq0bWuDhLp0sfLcuZbkDtO2bTYzLyMD3nrLSnAUUxG/ouaJwjkXN9LTYdKkrL6Gn36yx2vUgLPOssRwxhlQvXq4ceZp3jxo1MiK+A0ZYqOZatYMO6pC8UThnAvVihV7luTetMlaCCecAI8+asmhZct9LMkdhu3b4aGH4Jln4M03rQURB+U3ioInCudcsdq5c8+S3DNm2OOHHQYXXWSX8k8/HapWDTXMfTN+vPVF/Pqr/Xv22WFHVKQ8UTjnYm7p0qwyGd98Y7Ojy5a1ktxPPmmthmbNEvQS/n/+Yy2J+vWt3ninTmFHVOQ8UTjnityOHXuW5J471x6vWxcuvzyrJHflyuHGWSiZRfzatLFaTY88EqNqgeHzROGcKxILF2a1GsaMsUv25cvDKafAP/9pyaFRowRtNURau9YSQ8OG8MADtlZEyOtFxJonCudcgWzbZgkhc4TSwoX2eIMGtlZDly6WJJLmS7YqvP++1WjasMHWjCghPFE456KiaiM/M1sN48dbSe6KFe0y0r/+ZR3RDRqEHWkMrFwJN9wAn3xil5q+/trWOS0hPFE453K1ZcueJbmXLrXHGze26tgpKVaSu0KFcOOMud9/txPx9NNWVTDOi/gVtZL1bp1zeVKFmTOzWg3ff28lufff34as3n23JYfDDw870mKwaBF8+qklhlatYNmyBBuzW3Q8UThXwm3caFdSMlsNK1fa482bW59tly5w4okhluQubrt3w4svwr332hje7t2tPlMJTRLgicK5EicjA6ZNy2o1TJpkn41VqthE4pQUK8ldq1bYkYZg9mzrif/xRxvJNGBAQhbxK2qeKJwrAdau3bMk9x9/2OOtW0OfPtZqaNeuxF1639O2bTZMSwTefddaEgk/lrdolOT/Fs4lrd27YcqUrKGrkydb/0O1atZayGw11KgRdqRxYM4c653fbz8YNsyK+B18cNhRxRVPFM4lidWrs4rrjR4N69fbF+J27azCREqKtSDisiR3GLZts7kQzz0HgwfDlVdaj73biycK5xJUejr88ENWX8O0afZ4zZpwzjmWGM44w1oRLpuxY226+MKFcN11cO65YUcU1zxROJdAUlOzWg1ff51VkvvEE+Hxxy05tGiRACW5w/Tgg/Dww3DkkTY34tRTw44o7nmicC6O7dwJ332X1WqYNcser1XLll7OLMldpUq4cSaEzCJ+bdvCbbdZsthvv7CjSggxTRQikgK8AJQGBqlq32zPVwHeAeoGsTyjqv+NZUzOxbslS7ISw7ffZpXkbt8ennrKRig1beoDcqK2Zo3VF2nUyFoTJaCIX1GLWaIQkdJAP+AMIBWYIiKfquqciM1uBOao6jkicjAwX0SGqOrOWMXlXLzZsQPGjcsaoTRvnj1er571r6akWC2l/fcPNczEowpDh8LNN8PmzbZuhCuQWLYo2gILVXURgIgMA84DIhOFApVFRID9gfVAegxjci4u/PprVqth7NisktwdO0KvXpYcjjrKWw0FlpoK118Pn39uw75ef92aYa5AYpkoagHLI+6nAu2ybfMy8CmwEqgMXKKqGdl3JCI9gZ4AdevWjUmwzsXS1q17luT+7Td7vGFDG3yTkmJzvfySeRFZs8bK2z73nLUofExwocQyUeT0XUiz3T8TmA6cBhwJfCUiE1R18x4vUh0IDARo06ZN9n04F3dUbVW3yJLcO3daIjjtNPj3v23C25FHhh1pElm4ED77zApUHXssLF8OBxwQdlRJIZaJIhWoE3G/NtZyiHQN0FdVFVgoIouBo4HJMYzLuZjYvHnPktzLltnjTZpA795ZJbnLlw83zqSTng7PPw/3328n97LLbDKJJ4kiE8tEMQVoKCL1gRVAd+CybNssAzoBE0SkJtAIWBTDmJwrMqowY8aeJbnT020d6NNPt+KjKSm2TrSLkZkzrYjflCk2ae6VVyxJuCIVs0ShqukichMwChse+4aqzhaRXsHzA4BHgMEiMhO7VHWXqq6NVUzOFdaGDVZcL7OvYdUqe7xFC7j9dksMJ55ow1ldjG3bZpPlSpWyGk3dunnvf4zEdB6Fqn4JfJntsQERP68EOscyBucKIyMDfv55z5LcGRm2NEHnzjanoXNnOOywsCMtQWbNshFM++0H771nWbp69bCjSmo+M9u5bNautTIZI0fav2vW2ONt2mRdTmrbtoSX5A7D1q3WD/H88/DmmzbJpFOnsKMqEfy/uivxdu+2MtyZrYapU63/oXp1G5nUpYsV1/OS3CH65hsbR7x4MdxwA5x3XtgRlSieKFyJ9Pvve5bk3rDBLnUff7xN4M0sye3F9eLA/ffDo4/apJNx46BDh7AjKnE8UbgSYdeuPUtyT59ujx9yiH057dLFRioddFCoYbpIGRmWqU88Ee680xbVqFgx7KhKJE8ULmktX541Ounrr22eQ5ky9rnzxBNZJbl9oEyc+eMPm03dqJE177p0sZsLjScKlzT+/HPPktyzZ9vjtWvDJZfYZ81pp3lJ7rilCkOGWKXXtDQrA+7igicKl9AWL86aCf3ttzYwplw5mwF9zTXWamjSxFsNcW/5cquG+OWXcMIJMGiQ/eJcXPBE4RLK9u1ZJblHjIAFC+zx+vXh6qut1dCxo5fkTjjr1tnU9hdegBtv9CJ+ccYThYtrqnuX5N6xAypUsEm5N95orYaGDb3VkHAWLIBPP7Up7S1bWquicuWwo3I58ETh4s62bTZsPjM5LF5sjzdqBNddZ62GDh18AEzCSk+HZ5+11eYqVrSJczVrepKIY54oXFzZvNnmMsydC5UqWefzHXdYq6F+/bCjc4X2yy/w979bXZQLLoB+/byIXwLwROHihqp9hixYYCV8zjvPS3InlW3brORGmTIwfDh07Rp2RC5Knihc3HjuOfjgA3jmGSsE6pLEjBlwzDFWxO/9923yis9sTCheoMDFhfHj4a674MILbfU3lwTS0mxORMuW8Pbb9tipp3qSSEDeonChW7XKJsQdeST8978+eikpfPUV9OwJS5bATTdZf4RLWN6icKHatcuSxObNdtnJV69MAvfea4t0lC8PEybASy/5iKYEF3WiEJFKsQzElUx3322fJQMHQrNmYUfjCiUjw/49+WT7xU6fbj+7hJdvohCRE0VkDjA3uN9CRF6JeWQu6Q0fbsPpb7wRLr887Ghcgf3+O1x0kVV3BZvo8vjjNivSJYVoWhT/B5wJrANQ1V8ALwjvCmX+fBsK266djXZyCUgVBg+2mkyff+7XDZNYVJ3Zqrpc9uxh3B2bcFxJkJZmo5vKl7fRkuXKhR2R22dLl1pn9ejRdnlp0CCbOu+SUjSJYrmInAioiJQDbia4DOXcvlK1z5d582yFuTp1wo7IFcjGjTBlCrz8Mlx/vS8FmOSiSRS9gBeAWkAqMBq4IZZBueTVrx8MHQqPPWYryrkEMn++FfG74w6bNLdsmZfpLSGi+RrQSFUvV9WaqlpDVa8AGsc6MJd8fvjBJtOdfTb06RN2NC5qu3bZkoAtWkDfvrYCHXiSKEGiSRQvRfmYc7laswYuvthWm3vrLb9SkTCmTbMRB/fcA+ecA3PmQI0aYUflilmul55E5ATgROBgEYksqnAA4KuKuKjt3g2XXmpr00ycCAceGHZELirbtsEZZ0DZsjYb8sILw47IhSSvPopywP7BNpHTKjcDF8UyKJdcHnjA1pd44w049tiwo3H5mjbN6jPtt59NdmnRwrN7CZdrolDVccA4ERmsqkuLMSaXRD77zOZeXXutrWHt4tiWLTajul8/ePNNuOoqW1fWlXjRjHraJiJPA02Bv6ZaquppMYvKJYVFi2zxslatrNyPi2MjR9rygcuXW8VXv8zkIkTTpTgEmAfUB/4DLAGmxDAmlwS2b7d1aUqVsqsXXs0hjt19t5XdqFQJvv8enn/eRzS5PUTToqimqq+LyL8iLkeNi3VgLnGpwg03WE24L77wJUzj1u7dULq0XV4qUwbuu8+XFHQ5iiZR7Ar+XSUifwNWArVjF5JLdK+/biWA7r8fzjor7GjcXlatskqMTZvCI4/AmWfazblcRHPp6VERqQLcBtwODAJuiWVQLnH99JOtU9O5Mzz4YNjRuD2o2spQTZrAiBE+kslFLd8Whap+Hvy4CTgVQEROimVQLjGtX2/9EjVqwJAhdlXDxYklS+Cf/4Svv4b27a2I31FHhR2VSxB5TbgrDXTDajyNVNVZInI2cA9QEfAR8e4vGRlwxRV2VWPCBKhePeyI3B42bYKff4ZXXrHRTT413u2DvFoUrwN1gMnAiyKyFDgB6KOqH0ezcxFJwQoKlgYGqWrfHLbpCDwPlAXWquop0Yfv4sWjj9rVjP79oW3bsKNxgJXb+PRTK6yVWcSvki9U6fZdXomiDdBcVTNEpAKwFmigqr9Hs+OgRdIPOAOrOjtFRD5V1TkR21QFXgFSVHWZiHgRmQQ0apQtbnbllfZl1YVs50546inrqK5c2VaIqlHDk4QrsLzanztVNQNAVXcAC6JNEoG2wEJVXaSqO4FhwHnZtrkM+FBVlwXH+WMf9u/iwNKlcNlltt71gAGw5/pWrthNnQrHHWdDzi680Iv4uSKRV4viaBGZEfwswJHBfQFUVZvns+9awPKI+6lAu2zbHAWUFZGxWD2pF1T1rew7EpGeQE+AunXr5nNYV1z+/NMqwqanW824/fYLO6ISbutWG+ZaoQJ88gmce27YEbkkkVeiKOyaEzl9t9Qcjt8a6IR1kP8gIpNUdcEeL1IdCAwEaNOmTfZ9uJDccostcvbRR9CwYdjRlGA//2xF/CpVsl9G8+ZQtWrYUbkkkuulJ1Vdmtctin2nYp3hmWpjk/WybzNSVbeq6lpgPNBiX9+EK35vvWWXmu68E84/P+xoSqjNm20KfOvW8M479liHDp4kXJGL5Ri5KUBDEakfrLXdHfg02zafAO1FpIyI7IddmvL1uOPcjBnQq5dVfnjssbCjKaG+/NJmVr/6qi0b2LVr2BG5JBZNCY8CUdV0EbkJGIUNj31DVWeLSK/g+QGqOldERgIzgAxsCO2sWMXkCm/jRusjrVoVhg2zEkGumN11l41qatLEKi62y97151zRiurPXEQqAnVVdf6+7FxVvwS+zPbYgGz3nwae3pf9unCoQo8eNtJp7FioWTPsiEoQVZvVWLo0dOpkHdb33ONF/FyxyPfSk4icA0wHRgb3W4pI9ktIrgR4+mkbTPP003CSF3EpPitWWEdQZvGszp3hP//xJOGKTTR9FA9hcyI2AqjqdKBerAJy8WnMGFu2oFs3W9fGFQNVeO01u8Q0erTXRXGhiebSU7qqbhKfSVVirVgB3btbDblBg3xSXbFYvBj+8Q/L0B07WsJo0CDsqFwJFU2imCUilwGlRaQhcDMwMbZhuXixa5e1IrZutX6JypXDjqiESEuz4WWvvmoLjnsRPxeiaP739cbWy/4TeBcrN35LDGNyceSOO2DiRFuMqHFhp2C6vM2aBY8/bj8fc4wV8evZ05OEC100/wMbqeq9qnpccLsvqP3kktx778ELL1ifxCWXhB1NEtu50zqnW7WC//s/+CMoeeY1UVyciCZRPCci80TkERFpGvOIXFyYO9cukZ94og3ZdzEyZYrNrH7oISuc5UX8XByKZoW7U0XkEGwRo4EicgDwnqo+GvPoXCi2bLFJdZUqwf/+B+XKhR1Rktq6FVJSoGJFWzfinHPCjsi5HEV18VNVf1fVF4Fe2JyKB2IZlAuPqvWdLlhgM69r1Qo7oiQ0dapNnqtUySamzJ7tScLFtWgm3DUWkYdEZBbwMjbiqXbMI3OhePFFa0U8/jicemrY0SSZTZtsZafjjssq4nfyyVClSrhxOZePaIbH/hcYCnRW1ezVX10S+f57uP12mwR8551hR5NkPvvMKin+/rud5IsuCjsi56IWTR/F8cURiAvX6tXWl1qvHgwe7JPqitQdd8Azz9iQ148/thaFcwkk10QhIv9T1W4iMpM9FxyKdoU7lyDS023m9caNMHKkXwkpEqqwe7eV1+3cGQ44wKq++sgAl4DyalFkVvQ5uzgCceG5916bdf3mm7Y4miuk1FS4/no7mY89BmecYTfnElReK9ytCn68IYfV7W4onvBcrH30kc2T6NULrroq7GgSXEaGldxo0gS+/RYOOSTsiJwrEtEMj83pq1CXog7EFb9ff7X1Jdq0geefDzuaBLdoEZx2mmXctm1h5kzo3TvsqJwrEnn1UVyPtRyOEJEZEU9VBr6PdWAutrZts9Uzy5SxRdJ8aYNC2rrVZlUPGgR//7uPBnBJJa8+ineBEcATQJ+Ix7eo6vqYRuViStW++M6aBSNGwOGHhx1Rgpo50ybM3XefjWhautRmWTuXZPK69KSqugS4EdgScUNEDop9aC5WXn0V3n7bygudeWbY0SSgP/+EBx6wIn4vvphVxM+ThEtS+bUozgZ+wobHRralFTgihnG5GJk82arBduliX4TdPpo0yaolzpkDV15p1V6rVQs7KudiKtdEoapnB//WL75wXCytXWsTgg891CpI+DIH+2jrVvjb36xG05dfWrZ1rgSIptbTSSJSKfj5ChF5TkTqxj40V5R274bLL7cZ2B98AAf5xcPo/fhjVhG/zz6zIn6eJFwJEs13yv7ANhFpAdwJLAXejmlUrsg9/DCMHg0vv2zLH7gobNxopXSPPz6riN+JJ/p6sK7EiSZRpKuqAucBL6jqC9gQWZcgvvzSEsU119jnnovCxx/bxLnBg630xsUXhx2Rc6GJpnrsFhG5G7gSaC8ipYGysQ3LFZXFi+GKK6BFC+jXz4f3R+Xf/7ZO6hYt7FKTN8FcCRdNorgEuAz4u6r+HvRPPB3bsFxR2LHDOq8zMqxfwkdv5iGyiN9ZZ9lIpjvvhLL+nci5fC89qervwBCgioicDexQ1bdiHpkrtN694eefbc7EkUeGHU0cW7bMRjM9+KDdP/10q5ToScI5ILpRT92AycDF2LrZP4qIr7oS5954w6pJ3HOPr7KZq4wMeOUVaNoUxo2Dww4LOyLn4lI0l57uBY5T1T8ARORg4GtgeCwDcwU3bRrceCN06mSd2C4HCxdaTaYJE6wE+MCBtmqTc24v0SSKUplJIrCO6EZLuRBs2GDF/qpVg3ffhdKlw44oTu3YAQsWwH//C1df7b38zuUhmkQxUkRGYetmg3Vufxm7kFxBZWTYmhKpqTB+PNSoEXZEcWb6dCvi9+CD0KwZLFkCFSqEHZVzcS+azuw7gFeB5kALYKCq3hXrwNy+69sXPv8cnnvO5oi5wI4d1jndpg30759VxM+ThHNRyWs9iobAM8CRwEzgdlVdUVyBuX3z9ddw//1w6aXWP+ECEydaEb958+wS03PPef0S5/ZRXi2KN4DPga5YBdmXiiUit8+WL7cE0bgxvPaaX27/y9atNuRr2zYYOdJmWXuScG6f5dVHUVlVXwt+ni8iPxdHQG7f7Nxp1SV27LBJdZUqhR1RHPjhB2jXzk7G559bf4TXZ3KuwPJqUVQQkWNFpJWItAIqZrufLxFJEZH5IrJQRPrksd1xIrLb52fsu9tus+Km//0vNGoUdjQh27DBhryeeKLNMgQ44QRPEs4VUl4tilXAcxH3f4+4r8Bpee04qAnVDzgDSAWmiMinqjonh+2eBEbtW+huyBCrBnvbbVaqo0T78EPrnFmzBu6+Gy65JOyInEsaeS1cdGoh990WWKiqiwBEZBhWgXZOtu16Ax8AxxXyeCXKrFnQsye0bw9PPBF2NCG79VZ4/nlo2dJK5R57bNgROZdUoplHUVC1gOUR91OBdpEbiEgt4AKsdZJrohCRnkBPgLp1fc2kzZttUt0BB8B775XQkkSRRfzOPtsmjdx+ewk9Gc7FVixnWOc09kaz3X8euEtVd+e1I1UdqKptVLXNwQcfXFTxJSRVW1fit98sSRx6aNgRhWDJEkhJsfHAYLVK7r7bk4RzMRLLRJEK1Im4XxtYmW2bNsAwEVkCXAS8IiLnxzCmhPfcc3Y5/sknoUOHsKMpZhkZ8NJLNopp4kQ4/PCwI3KuRMj30pOICHA5cISqPhysR3GIqk7O56VTgIYiUh9YAXTH1rX4i6rWjzjOYOBzVf14n95BCTJ+vC221rWrra1Tovz6qzWlvv/eWhMDBniicK6YRNOieAU4Abg0uL8FG82UJ1VNB27CRjPNBf6nqrNFpJeI9CpgvCXWqlU2kOfII62EeImbVLdzp11ve+st67D2JOFcsYmmM7udqrYSkWkAqrpBRMpFs3NV/ZJsBQRVdUAu2/aIZp8l0a5d0K2bdWJ/9ZV1YpcI06ZZEb+HHrI1I5YsgfLlw47KuRInmhbFrmCug8Jf61FkxDQqt4e774bvvrMlE5o1CzuaYrBjh73p446DV1+1uRHgScK5kESTKF4EPgJqiMhjwHfA4zGNyv1l+HB49lmbS3b55WFHUwy++w5atLBSuFddBXPmQAkf6eZc2PK99KSqQ0TkJ6ATNuT1fFWdG/PIHPPnW0WKdu1stFPSS0uD886za2ujR9vKc8650EUz6qkusA34LPIxVV0Wy8BKurQ0uPBCu9ry/vtQLqpeoQT13XdWn2n//eGLL+z62v77hx2Vcy4QzaWnL7By418A3wCLgBGxDKqkU7XyHPPmwdChUKdO/q9JSOvW2eWl9u2zivgdf7wnCefiTDSXno6JvB9Ujr0uZhE5+vWzBPHYY3D66WFHEwOq1vly002wfr3NsO7ePeyonHO52OdaT6r6s4h4Ab8Y+eEHm0x39tnQJ9fC7Anu1lvhhRegdWvri2jRIuyInHN5iKaPInIOcCmgFbAmZhGVYGvW2CJEderYvLJSsSywUtxUIT3d6jGdey4cdphlxDKxrEvpnCsK0fyVRq76ko71VXwQm3BKrt27bTnTdeusVXHggWFHVIQWL7ZOl9atbdjraafZzTmXEPJMFMFEu/1V9Y5iiqfEeuAB+OYbK8/RsmXY0RSR3bttZaV77oHSpa255JxLOLkmChEpo6rp0S576grus8/g8cfh2mut7l1SWLAAevSw5lGXLjbDOmmHbzmX3PJqUUzG+iOmi8inwPvA1swnVfXDGMdWIvz2G1x5JbRqZRW0k0Z6OixdCu+8A5ddVgKrGDqXPKLpozgIWIetQqfY7GwFPFEU0vbtVjK8VCkbLVqhQtgRFdLUqVbE75FHoEkTWLTI6zM5lwTyShQ1ghFPs8hKEJmyr1Tn9pEq3HADzJgBn38O9evn/5q4tX07PPigFaU65BC4+Warz+RJwrmkkNcAzNLA/sGtcsTPmTdXCIMGweDBNtfsrLPCjqYQxo2D5s3h6afhH/+A2bO9iJ9zSSavFsUqVX242CIpQaZOtUnJnTvbaKeElVmQqmpVG7LlQ16dS0p5JQrvfYyB9evhoougZk0YMsRGjSacCRPgpJOsJtOIEbaoUKVKYUflnIuRvC49dSq2KEqIjAy44gpb1nT4cKhePeyI9tHatfYGOnTIKuLXtq0nCeeSXK4tClVdX5yBlASPPmpfwPv3t8/XhKEK//sf9O4NGzZYx7UX8XOuxPBCO8Vk1Chb+vnKK+G6RKu9+69/2SSP446zvohjjsn/Nc65pOGJohgsXWpzzpo1gwEDEmTumSrs2mUrJl1wARx+ONxyS4J2qjjnCiOZ6pPGpT//tBJH6enwwQew335hRxSF336DTp3gvvvs/qmnwm23eZJwroTyRBFjt9wCU6bAm29Cw4ZhR5OP3bttce5jjoGffoJGjcKOyDkXB/zSUwy99ZZdarrzTjj//LCjyce8eXD11TB5MpxzjvW416oVdlTOuTjgiSJGZsyAXr2gY0db0jTuZWTAypW2BusllyRIR4pzrjh4ooiBjRuzJiwPGxbHi7hNnmxF/B57zIr4/fabdV4751wE76MoYqq2DMPSpfD++zYDO+5s2wa33w4nnGCdJ2uClW09STjncuCJoog99ZR9SX/mGatyEXfGjLHO6mefhX/+04v4OefyFa8XRRLSmDG26me3blZpO+6kpdlY3apVLdiOHcOOyDmXALxFUURWrLCqFkcdZSXE46oveOxY66zOLOI3Y4YnCedc1DxRFIGdO60VsXUrfPghVK4cdkSBNWvg0kttwtw779hjxx2XILP+nHPxwi89FYE774SJE22EU+PGYUeD9agPHWrXv7ZssaVJvYifc66APFEU0nvvwQsvWN28Sy4JO5pA797Qrx8cfzy8/roNfXXOuQLyRFEIc+fa6p8nnmijnUKVkWEFpcqVs5WRGjSwhOH1mZxzhRTTPgoRSRGR+SKyUET65PD85SIyI7hNFJEWsYynKG3ZYpPqKlWypRpCnYLw66+2DOm999r9jh290qtzrsjELFGISGmgH9AFaAJcKiLZr4EsBk5R1ebAI8DAWMVTlFTh2mthwQLrlwitJFJ6uk3YaN4cpk+Pkw4S51yyieWlp7bAQlVdBCAiw4DzgDmZG6jqxIjtJwG1YxhPkXnxRWtF9O1rA4pCMXcuXHUVTJ0K550Hr7wChx0WUjDOuWQWy0tPtYDlEfdTg8dy8w9gRE5PiEhPEZkqIlPXZJabCMn331v1i/PPt9FOoVq92nrTP/rIk4RzLmZimShymnKmOW4ociqWKO7K6XlVHaiqbVS1zcEhlptYvdomNterB4MHhzCpbtIkuPtu+7lxYyvi161bnM3uc84lm1gmilSgTsT92sDK7BuJSHNgEHCeqq6LYTyFkp5uUxE2brSV6qpUKcaDb90Kt95qw6uGDMkq4le2bDEG4ZwrqWKZKKYADUWkvoiUA7oDn0ZuICJ1gQ+BK1V1QQxjKbR777VKGK++an3Hxebrr22x7eefhxtu8CJ+zrliF7PObFVNF5GbgFFAaeANVZ0tIr2C5wcADwDVgFfELp+kq2qbWMVUUB99ZPMkevWCK68sxgOnpVkz5qCDYPx4aN++GA/unHNGVHPsNohbbdq00alTpxbb8X79Fdq0seWjJ0yA8uWL4aDffgunnGLzIH76yWZWV6xYDAd2ziUrEfmpoF/EvShgHrZuha5drStg+PBiSBKrV1vndKdOWUX8Wrf2JOGcC5WX8MiFql1qmjXLKnPXrRvjg73zjs2mTkuzpUkvuyyGB3TOueh5osjFq6/aZ/d//gNnnhnjg914I/Tvb0uTvv66z7B2zsUVTxQ5mDzZqsF26QL33Rejg2RkwK5ddj3rkkssOdxwg9dncs7FHe+jyGbtWiu+euih1qIoFYszNH++dVZnFvE75RSv9Oqci1ueKCLs3g2XX259yh98YKNSi9SuXVYgqkUL6/w45pgiPoBzzhU9v/QU4eGHYfRoGDjQBhsVqdmzbRLGtGlWn7xfPzjkkCI+iHPOFT1PFIEvv7REcc01VkK8yJUuDevX2zjbrl1jcADnnIsNv/QELF4MV1xhV4T69SvCGnsTJ8JdQZ3Do4+GhQs9STjnEk6JTxQ7dljndUaG9UsUydy2tDS4+WY4+WQrA752rT1exhtwzrnEU+ITRe/e8PPP8PbbcOSRRbDD0aOtiN/LL8NNN1mndfXqRbBj55wLR4n+ivvGGzBoENxzD5xzThHsMC3Nhk1Vq2aFoU46qQh26pxz4SqxLYpp02xCdKdO1oldKF99ZWNr99/fWhTTp3uScM4ljRKZKDZssD7l6tVh6NBCzHNbtcp21LmzLSgEcOyxUKFCkcXqnHNhK3GXnjIy4KqrIDXVlngo0BpAqvDmm7bq3PbtNonOi/g555JUiUsUffvC55/DSy/B8ccXcCfXX29VA08+2To5GjUq0hidSxa7du0iNTWVHTt2hB1KiVGhQgVq165N2SJcKrlEJYqvv4b777cv/zfeuI8vjizid9llth5qr14xKgblXHJITU2lcuXK1KtXDymyCUouN6rKunXrSE1NpX79+kW23xLzKbd8OVx6qRVpHThwHyfVzZ1ry5Dec4/d79DBKr16knAuTzt27KBatWqeJIqJiFCtWrUib8GViE+6nTvh4ovhzz9tUl2lSlG+cNcuePxxaNkS5s2zjmrn3D7xJFG8YnG+S8Slp3//G3780cosRd2dMHu21fWYPt2yzEsvQc2asQzTOefiUtK3KIYMsfpNt922j2WWypSBTZvgww/hf//zJOFcAvvoo48QEebNm/fXY2PHjuXss8/eY7sePXowfPhwwDri+/TpQ8OGDWnWrBlt27ZlxIgRhY7liSeeoEGDBjRq1IhRo0blut1LL71Eo0aNaNq0KXfeeedfMV199dUcc8wxNG7cmCeeeKLQ8UQjqVsUs2ZBz57WvRDV+ZwwAT75BJ55xpoeCxZ4fSbnksDQoUM5+eSTGTZsGA899FBUr7n//vtZtWoVs2bNonz58qxevZpx48YVKo45c+YwbNgwZs+ezcqVKzn99NNZsGABpbNN5hozZgyffPIJM2bMoHz58vzxxx8AvP/++/z555/MnDmTbdu20aRJEy699FLq1atXqLjyk7Sfgps3WwvigAOsLl+eI8W2bIE+feCVV6B+ffu5enVPEs4VoVtusSu5RallS3j++by3SUtL4/vvv2fMmDGce+65USWKbdu28dprr7F48WLKly8PQM2aNenWrVuh4v3kk0/o3r075cuXp379+jRo0IDJkydzwgkn7LFd//796dOnz1/HrlGjBmD9D1u3biU9PZ3t27dTrlw5DjjggELFFI2kvPSkautK/PabJYlDD81j4xEjoGlT6N/f/ifPnOlF/JxLIh9//DEpKSkcddRRHHTQQfz888/5vmbhwoXUrVs3qg/hW2+9lZYtW+5169u3717brlixgjp16vx1v3bt2qxYsWKv7RYsWMCECRNo164dp5xyClOmTAHgoosuolKlShx66KHUrVuX22+/nYOKfCnOvSXlV+bnnrOuhWeesZGsudqyxaZp16hha0cUeAaecy4/+X3zj5WhQ4dyyy23ANC9e3eGDh1Kq1atch0dtK+jhv7v//4v6m1VNarjpaens2HDBiZNmsSUKVPo1q0bixYtYvLkyZQuXZqVK1eyYcMG2rdvz+mnn84RRxyxTzHvq6RLFOPH21pBXbvaaKe9qMKoUXDGGVC5ss3CO/pom0jnnEsq69at49tvv2XWrFmICLt370ZEeOqpp6hWrRobNmzYY/v169dTvXp1GjRowLJly9iyZQuVK1fO8xi33norY8aM2evx7t2706dPnz0eq127NsuXL//rfmpqKocddther61duzYXXnghIkLbtm0pVaoUa9eu5d133yUlJYWyZctSo0YNTjrpJKZOnRrzRIGqJtStdevWmpuVK1UPOUT1qKNUN23KZYPzz1cF1TffzHU/zrmiMWfOnFCPP2DAAO3Zs+cej3Xo0EHHjx+vO3bs0Hr16v0V45IlS7Ru3bq6ceNGVVW94447tEePHvrnn3+qqurKlSv17bffLlQ8s2bN0ubNm+uOHTt00aJFWr9+fU1PT99ru/79++v999+vqqrz58/X2rVra0ZGhvbt21d79OihGRkZmpaWpo0bN9Zffvllr9fndN6BqVrAz92k6aPYtQu6dbNO7A8+sE7sv6ja4hONG8PIkfDUU17Ez7kSYOjQoVxwwQV7PNa1a1feffddypcvzzvvvMM111xDy5Ytueiiixg0aBBVqlQB4NFHH+Xggw+mSZMmNGvWjPPPP5+DC1RFNEvTpk3p1q0bTZo0ISUlhX79+v014unaa69l6tSpAPz9739n0aJFNGvWjO7du/Pmm28iItx4442kpaXRrFkzjjvuOK655hqaN29eqJiiIZrDNbN41qZNG808mZFuvx2efdbmTeyVA667zup2dOhgRfwaNiyeYJ0r4ebOnUvjxo3DDqPEyem8i8hPqtqmIPtLij6K4cMtSdx0U0SS2L3bmhkVKtgM62OPtUkVXp/JOef2ScJ/as6fb0Nh27WzZAFY+Y2TTsoq4te+vVd6dc65AkroT860NLjwQms0vP8+lGMnPPKItR4WLoTjjgs7ROdKvES7vJ3oYnG+E/bSk6pdSZo3z5aprrNxJvztcpsw1707vPhiAZevc84VlQoVKrBu3TovNV5MNFiPokIRL8ecsImiXz9b7/qxx6BTJ2B+Odi2zWo1nXtu2OE557D5AKmpqaxZsybsUEqMzBXuilJCJooffrDJdH1OGMfdaz8FnrUifvPnQ7biWs658JQtW7ZIV1pz4YhpH4WIpIjIfBFZKCJ9cnheROTF4PkZItIqv32mp8M1XTfz3wrX88QPHZFPPoa1a+1JTxLOOVfkYtaiEJHSQD/gDCAVmCIin6rqnIjNugANg1s7oH/wb65WL9jElO1NqVVqpTUrHnkE9tsvNm/COedcTC89tQUWquoiABEZBpwHRCaK84C3gunlk0Skqogcqqqrcttpze1LqFSrEfLBcBsT65xzLqZimShqAcsj7qeyd2shp21qAXskChHpCfQM7v550IrZs7zSKwDVgbVhBxEn/Fxk8XORxc9FlmgXgt5LLBNFTmPhsg/wjWYbVHUgMBBARKYWdBp6svFzkcXPRRY/F1n8XGQRkb1rH0Uplp3ZqUCdiPu1gZUF2MY551yIYpkopgANRaS+iJQDugOfZtvmU+CqYPTT8cCmvPonnHPOFb+YXXpS1XQRuQkYBZQG3lDV2SLSK3h+APAlcBawENgGXBPFrgfGKORE5Ocii5+LLH4usvi5yFLgc5FwZcadc84Vr4QuCuiccy72PFE455zLU9wmiliU/0hUUZyLy4NzMENEJopIizDiLA75nYuI7Y4Tkd0iclFxxlecojkXItJRRKaLyGwRGVfcMRaXKP5GqojIZyLyS3AuoukPTTgi8oaI/CEis3J5vmCfmwVdbDuWN6zz+zfgCKAc8AvQJNs2ZwEjsLkYxwM/hh13iOfiRODA4OcuJflcRGz3LTZY4qKw4w7x/0VVrBJC3eB+jbDjDvFc3AM8Gfx8MLAeKBd27DE4Fx2AVsCsXJ4v0OdmvLYo/ir/oao7gczyH5H+Kv+hqpOAqiJyaHEHWgzyPReqOlFVNwR3J2HzUZJRNP8vAHoDHwB/FGdwxSyac3EZ8KGqLgNQ1WQ9H9GcCwUqiy2KsT+WKNKLN8zYU9Xx2HvLTYE+N+M1UeRW2mNft0kG+/o+/4F9Y0hG+Z4LEakFXAAMKMa4whDN/4ujgANFZKyI/CQiVxVbdMUrmnPxMtAYm9A7E/iXqmYUT3hxpUCfm/G6HkWRlf9IAlG/TxE5FUsUJ8c0ovBEcy6eB+5S1d1JvqJaNOeiDNAa6ARUBH4QkUmquiDWwRWzaM7FmcB04DTgSOArEZmgqptjHFu8KdDnZrwmCi//kSWq9ykizYFBQBdVXVdMsRW3aM5FG2BYkCSqA2eJSLqqflwsERafaP9G1qrqVmCriIwHWgDJliiiORfXAH3VLtQvFJHFwNHA5OIJMW4U6HMzXi89efmPLPmeCxGpC3wIXJmE3xYj5XsuVLW+qtZT1XrAcOCGJEwSEN3fyCdAexEpIyL7YdWb5xZznMUhmnOxDGtZISI1sUqqi4o1yvhQoM/NuGxRaOzKfyScKM/FA0A14JXgm3S6JmHFzCjPRYkQzblQ1bkiMhKYAWQAg1Q1x2GTiSzK/xePAINFZCZ2+eUuVU268uMiMhToCFQXkVTgQaAsFO5z00t4OOecy1O8XnpyzjkXJzxROOecy5MnCuecc3nyROGccy5Pniicc87lyROFi0tB5dfpEbd6eWybVgTHGywii4Nj/SwiJxRgH4NEpEnw8z3ZnptY2BiD/WSel1lBNdSq+WzfUkTOKopju5LLh8e6uCQiaaq6f1Fvm8c+BgOfq+pwEekMPKOqzQuxv0LHlN9+ReRNYIGqPpbH9j2ANqp6U1HH4koOb1G4hCAi+4vIN8G3/ZkislfVWBE5VETGR3zjbh883llEfghe+76I5PcBPh5oELz238G+ZonILcFjlUTki2Btg1kicknw+FgRaSMifYGKQRxDgufSgn/fi/yGH7RkuopIaRF5WkSmiK0TcF0Up+UHgoJuItJWbC2SacG/jYJZyg8DlwSxXBLE/kZwnGk5nUfn9hJ2/XS/+S2nG7AbK+I2HfgIqyJwQPBcdWxmaWaLOC349zbg3uDn0kDlYNvxQKXg8buAB3I43mCCtSuAi4EfsYJ6M4FKWGnq2cCxQFfgtYjXVgn+HYt9e/8rpohtMmO8AHgz+LkcVsmzItATuC94vDwwFaifQ5xpEe/vfSAluH8AUCb4+XTgg+DnHsDLEa9/HLgi+LkqVvepUti/b7/F9y0uS3g4B2xX1ZaZd0SkLPC4iHTAylHUAmoCv0e8ZgrwRrDtx6o6XUROAZoA3wflTcph38Rz8rSI3AeswarwdgI+Uiuqh4h8CLQHRgLPiMiT2OWqCfvwvkYAL4pIeSAFGK+q24PLXc0la0W+KkBDYHG211cUkelAPeAn4KuI7d8UkYZYNdCyuRy/M3CuiNwe3K8A1CU5a0C5IuKJwiWKy7GVyVqr6i4RWYJ9yP1FVccHieRvwNsi8jSwAfhKVS+N4hh3qOrwzDsicnpOG6nqAhFpjdXMeUJERqvqw9G8CVXdISJjsbLXlwBDMw8H9FbVUfnsYruqthSRKsDnwI3Ai1gtozGqekHQ8T82l9cL0FVV50cTr3PgfRQucVQB/giSxKnA4dk3EJHDg21eA17HloScBJwkIpl9DvuJyFFRHnM8cH7wmkrYZaMJInIYsE1V3wGeCY6T3a6gZZOTYVgxtvZYITuCf6/PfI2IHBUcM0equgm4Gbg9eE0VYEXwdI+ITbdgl+AyjQJ6S9C8EpFjczuGc5k8UbhEMQRoIyJTsdbFvBy26QhMF5FpWD/CC6q6BvvgHCoiM7DEcXQ0B1TVn7G+i8lYn8UgVZ0GHANMDi4B3Qs8msPLBwIzMjuzsxmNrW38tdrSnWBricwBfhaRWcCr5NPiD2L5BSur/RTWuvke67/INAZoktmZjbU8ygaxzQruO5cnHx7rnHMuT96icM45lydPFM455/LkicI551yePFE455zLkycK55xzefJE4ZxzLk+eKJxzzuXp/wGwzBJKrFI0tgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import sklearn.metrics as metrics\n",
    "preds = svm_b.predict(Xb_test)\n",
    "fpr, tpr, threshold = metrics.roc_curve(yb_test[:,0], preds)\n",
    "roc_auc = metrics.auc(fpr, tpr)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.title('Receiver Operating Characteristic')\n",
    "plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\n",
    "plt.legend(loc = 'lower right')\n",
    "plt.plot([0, 1], [0, 1],'r--')\n",
    "plt.xlim([0, 1])\n",
    "plt.ylim([0, 1])\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.show()"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}