{ "cells": [ { "cell_type": "code", "execution_count": 7, "id": "36ac21fc", "metadata": {}, "outputs": [], "source": [ "# Import dependencies and packages neededfrom sklearn import datasets\n", "from sklearn.svm import SVC\n", "from sklearn.model_selection import train_test_split\n", "import numpy as np\n", "import pandas as pd\n", "import seaborn as sn\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 8, "id": "3c07c748", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
PatientIdPregnanciesGlucoseBloodPressureSkinThicknessInsulinBMIDiabetesPedigreeFunctionAgeOutcome
0161487235033.60.627501
121856629026.60.351310
238183640023.30.672321
3418966239428.10.167210
450137403516843.12.288331
\n", "
" ], "text/plain": [ " PatientId Pregnancies Glucose BloodPressure SkinThickness Insulin \\\n", "0 1 6 148 72 35 0 \n", "1 2 1 85 66 29 0 \n", "2 3 8 183 64 0 0 \n", "3 4 1 89 66 23 94 \n", "4 5 0 137 40 35 168 \n", "\n", " BMI DiabetesPedigreeFunction Age Outcome \n", "0 33.6 0.627 50 1 \n", "1 26.6 0.351 31 0 \n", "2 23.3 0.672 32 1 \n", "3 28.1 0.167 21 0 \n", "4 43.1 2.288 33 1 " ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# import the dataset (stored in a variable)\n", "diabetes = pd.read_csv(\"diabetes.csv\")\n", "# Inspect the data(first five rows, or this can be changed by including how many rows within the brackets)\n", "diabetes.head()" ] }, { "cell_type": "code", "execution_count": 9, "id": "f5ce7fbc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Index: 614 entries, 60 to 102\n", "Data columns (total 10 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 PatientId 614 non-null int64 \n", " 1 Pregnancies 614 non-null int64 \n", " 2 Glucose 614 non-null int64 \n", " 3 BloodPressure 614 non-null int64 \n", " 4 SkinThickness 614 non-null int64 \n", " 5 Insulin 614 non-null int64 \n", " 6 BMI 614 non-null float64\n", " 7 DiabetesPedigreeFunction 614 non-null float64\n", " 8 Age 614 non-null int64 \n", " 9 Outcome 614 non-null int64 \n", "dtypes: float64(2), int64(8)\n", "memory usage: 52.8 KB\n" ] } ], "source": [ "# split the data into train and test using the SciKitLearn package\n", "from sklearn.model_selection import train_test_split\n", "train,test=train_test_split(diabetes,test_size=0.2,random_state=42)\n", "# view the information\n", "train.info()" ] }, { "cell_type": "code", "execution_count": 10, "id": "9c236d8a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Index: 154 entries, 668 to 462\n", "Data columns (total 8 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 Pregnancies 154 non-null int64 \n", " 1 Glucose 154 non-null int64 \n", " 2 BloodPressure 154 non-null int64 \n", " 3 SkinThickness 154 non-null int64 \n", " 4 Insulin 154 non-null int64 \n", " 5 BMI 154 non-null float64\n", " 6 DiabetesPedigreeFunction 154 non-null float64\n", " 7 Age 154 non-null int64 \n", "dtypes: float64(2), int64(6)\n", "memory usage: 10.8 KB\n" ] } ], "source": [ "# Ensure only labels are saved in y variables\n", "y_train=train['Outcome']\n", "y_test=test['Outcome']\n", "#drop the unwanted / irrelevant columns, features are stored in X variables\n", "X_train=train.drop(['PatientId','Outcome'],axis=1)\n", "X_test=test.drop(['PatientId','Outcome'],axis=1)\n", "# view the information\n", "X_test.info()" ] }, { "cell_type": "code", "execution_count": 11, "id": "cf217602", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'C': 1.0,\n", " 'break_ties': False,\n", " 'cache_size': 200,\n", " 'class_weight': None,\n", " 'coef0': 0.0,\n", " 'decision_function_shape': 'ovr',\n", " 'degree': 3,\n", " 'gamma': 'scale',\n", " 'kernel': 'rbf',\n", " 'max_iter': -1,\n", " 'probability': False,\n", " 'random_state': None,\n", " 'shrinking': True,\n", " 'tol': 0.001,\n", " 'verbose': False}" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# this step is just to demonstrate the adjustable parameters within the algorithm and not a necessary step\n", "SVC().get_params()" ] }, { "cell_type": "code", "execution_count": 1, "id": "3f4c8504", "metadata": {}, "outputs": [], "source": [ "# # this step is just to demonstrate the api methods and not a necessary step\n", "# dir(SVC)" ] }, { "cell_type": "code", "execution_count": 12, "id": "25ec0839", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
SVC()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "SVC()" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create a model for Support Vector (Machine) Classifier using default parameters\n", "model = SVC()\n", "# fit the data to the model, both features and labels to train it\n", "model.fit(X_train, y_train)" ] }, { "cell_type": "code", "execution_count": 13, "id": "59cf09a6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,\n", " 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0,\n", " 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1,\n", " 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0,\n", " 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0,\n", " 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,\n", " 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0])" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# use the model to classify the datapoints within the test set\n", "y_pred2=model.predict(X_test)\n", "# print predicted classifications\n", "y_pred2" ] }, { "cell_type": "code", "execution_count": 14, "id": "606707f8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "668 0\n", "324 0\n", "624 0\n", "690 0\n", "473 0\n", " ..\n", "355 1\n", "534 0\n", "344 0\n", "296 1\n", "462 0\n", "Name: Outcome, Length: 154, dtype: int64" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# print test labels (ground truth) that is compared to classifier\n", "y_test" ] }, { "cell_type": "code", "execution_count": 15, "id": "fb8d51eb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[87 12]\n", " [24 31]]\n", " precision recall f1-score support\n", "\n", " 0 0.784 0.879 0.829 99\n", " 1 0.721 0.564 0.633 55\n", "\n", " accuracy 0.766 154\n", " macro avg 0.752 0.721 0.731 154\n", "weighted avg 0.761 0.766 0.759 154\n", "\n" ] } ], "source": [ "# display the metrics of the model's classification through confusion matrix and classification report\n", "# (accuracy / precision / recall / f1)\n", "from sklearn import metrics\n", "print(metrics.confusion_matrix(y_test, y_pred2))\n", "\n", "\n", "print(metrics.classification_report(y_test, y_pred2, digits=3))" ] }, { "cell_type": "code", "execution_count": 16, "id": "a1096778", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Actual Predicted\n", "668 0 0\n", "324 0 0\n", "624 0 0\n", "690 0 0\n", "473 0 0\n", ".. ... ...\n", "355 1 1\n", "534 0 0\n", "344 0 0\n", "296 1 0\n", "462 0 0\n", "\n", "[154 rows x 2 columns]\n" ] } ], "source": [ "# use Pandas to create a dataframe to view the ground truth and classifications side by side\n", "data = {'Actual': y_test,\n", " 'Predicted': y_pred2}\n", "df = pd.DataFrame(data)\n", "print(df)" ] }, { "cell_type": "code", "execution_count": 12, "id": "e5d198fa", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " 0 0.784 0.879 0.829 99\n", " 1 0.721 0.564 0.633 55\n", "\n", " accuracy 0.766 154\n", " macro avg 0.752 0.721 0.731 154\n", "weighted avg 0.761 0.766 0.759 154\n", "\n" ] } ], "source": [ "# Use Seaborn to create a confusion matrix heatmap and MatPlotLib to display\n", "confusion_matrix = pd.crosstab(df['Actual'], df['Predicted'], rownames=['Actual'], colnames=['Predicted'])\n", "sn.heatmap(confusion_matrix, annot=True)\n", "plt.show()\n", "print(metrics.classification_report(y_test, y_pred2, digits=3))" ] }, { "cell_type": "markdown", "id": "ef72442e-63bb-4a75-a2ab-dd2aa8df1840", "metadata": {}, "source": [ "## Searching for the Best Hyperparameters with GridSearchCV" ] }, { "cell_type": "code", "execution_count": 17, "id": "fa40302a", "metadata": {}, "outputs": [], "source": [ "# Create an iterative grid search to tune the parameters\n", "import joblib\n", "from sklearn.model_selection import GridSearchCV" ] }, { "cell_type": "code", "execution_count": 18, "id": "06a71bed", "metadata": {}, "outputs": [], "source": [ "# Create a function to show the results of the classifier under different parameter values\n", "def print_results(results):\n", " print('Best Parameters: {}\\n'.format(results.best_params_))\n", " \n", " means = results.cv_results_['mean_test_score']\n", " stds = results.cv_results_['std_test_score']\n", " for mean, std, params in zip(means, stds, results.cv_results_['params']):\n", " print('{} (+/-{}) for {}'.format(round(mean, 3), round(std * 2, 3), params))" ] }, { "cell_type": "code", "execution_count": 19, "id": "5404a42e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best Parameters: {'C': 0.1, 'kernel': 'linear'}\n", "\n", "0.767 (+/-0.053) for {'C': 0.1, 'kernel': 'linear'}\n", "0.651 (+/-0.004) for {'C': 0.1, 'kernel': 'rbf'}\n", "0.765 (+/-0.056) for {'C': 1, 'kernel': 'linear'}\n", "0.752 (+/-0.053) for {'C': 1, 'kernel': 'rbf'}\n", "0.762 (+/-0.049) for {'C': 10, 'kernel': 'linear'}\n", "0.761 (+/-0.055) for {'C': 10, 'kernel': 'rbf'}\n" ] } ], "source": [ "# Create a model using the Support Vector Classifier / Machine algorithm\n", "svm = SVC()\n", "# Set the parameters to be tuned\n", "parameters = {\n", " 'kernel' : ['linear', 'rbf'],\n", " 'C' : [0.1, 1, 10]\n", "}\n", "# instantiate the grid search\n", "cv = GridSearchCV(svm, parameters, cv=5)\n", "# fit the training data to the model\n", "cv.fit(X_train, y_train.ravel())\n", "# display the model evaluation with the different paramter combination values (C value and kernel)\n", "print_results(cv)" ] }, { "cell_type": "code", "execution_count": 20, "id": "4bfb84c7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'C': 0.1,\n", " 'break_ties': False,\n", " 'cache_size': 200,\n", " 'class_weight': None,\n", " 'coef0': 0.0,\n", " 'decision_function_shape': 'ovr',\n", " 'degree': 3,\n", " 'gamma': 'scale',\n", " 'kernel': 'linear',\n", " 'max_iter': -1,\n", " 'probability': False,\n", " 'random_state': None,\n", " 'shrinking': True,\n", " 'tol': 0.001,\n", " 'verbose': False}" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# show the best paramters for classification (not a necesary step unless you are saving best parameter models to compare)\n", "cv.best_estimator_.get_params()" ] }, { "cell_type": "code", "execution_count": null, "id": "05d7456f", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "33f56a89-cf7c-4697-9629-c04199149a09", "metadata": {}, "source": [ "# Decision Tree" ] }, { "cell_type": "markdown", "id": "472032f5-928c-49ab-8c8d-b2454195ea2a", "metadata": {}, "source": [ "from sklearn.tree import DecissionTreeClassifier" ] }, { "cell_type": "code", "execution_count": 21, "id": "9be2e2e6-cc3e-46e1-8ece-1d74db056ff4", "metadata": {}, "outputs": [], "source": [ "from sklearn.tree import DecisionTreeClassifier" ] }, { "cell_type": "code", "execution_count": 29, "id": "714cc906-b012-4f5e-973c-39b57e9aa903", "metadata": {}, "outputs": [], "source": [ "# Create Decision Tree classifer object\n", "clf = DecisionTreeClassifier()\n", "\n", "# Train Decision Tree Classifer\n", "clf = clf.fit(X_train,y_train)\n", "\n", "#Predict the response for test dataset\n", "y_pred = clf.predict(X_test)" ] }, { "cell_type": "code", "execution_count": 30, "id": "7f34e620-79ef-4655-a898-5594adc55ecc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[79 20]\n", " [16 39]]\n", " precision recall f1-score support\n", "\n", " 0 0.832 0.798 0.814 99\n", " 1 0.661 0.709 0.684 55\n", "\n", " accuracy 0.766 154\n", " macro avg 0.746 0.754 0.749 154\n", "weighted avg 0.771 0.766 0.768 154\n", "\n" ] } ], "source": [ "# display the metrics of the model's classification through confusion matrix and classification report\n", "# (accuracy / precision / recall / f1)\n", "from sklearn import metrics\n", "print(metrics.confusion_matrix(y_test, y_pred))\n", "\n", "\n", "print(metrics.classification_report(y_test, y_pred, digits=3))" ] }, { "cell_type": "code", "execution_count": 31, "id": "7d1f2281-ead6-4947-9a92-44525fe6bc9b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Actual Predicted\n", "668 0 0\n", "324 0 0\n", "624 0 0\n", "690 0 0\n", "473 0 0\n", ".. ... ...\n", "355 1 1\n", "534 0 0\n", "344 0 1\n", "296 1 0\n", "462 0 0\n", "\n", "[154 rows x 2 columns]\n" ] } ], "source": [ "# use Pandas to create a dataframe to view the ground truth and classifications side by side\n", "data = {'Actual': y_test,\n", " 'Predicted': y_pred}\n", "df = pd.DataFrame(data)\n", "print(df)" ] }, { "cell_type": "code", "execution_count": 32, "id": "b35576de-c377-4d73-a188-ff326fa40210", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
ActualPredicted
66800
32400
62400
69000
47300
.........
35511
53400
34401
29610
46200
\n", "

154 rows × 2 columns

\n", "
" ], "text/plain": [ " Actual Predicted\n", "668 0 0\n", "324 0 0\n", "624 0 0\n", "690 0 0\n", "473 0 0\n", ".. ... ...\n", "355 1 1\n", "534 0 0\n", "344 0 1\n", "296 1 0\n", "462 0 0\n", "\n", "[154 rows x 2 columns]" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df" ] }, { "cell_type": "code", "execution_count": 33, "id": "1b5bd6e9-982f-49b4-99f7-decdf5a9ed3b", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhIAAAGwCAYAAAD8AYzHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAsZ0lEQVR4nO3deXQUZdr38V8bQpNACIKkkyhLkKAgiAxxYlA2MXlYFDKM24AKgygIKhEVJkYFHU0047AoiCwKuDDoI4voIBJcoj4ZFBhABASUsCkhIFsI2Mmk6/2D155pEiBddKWbmu/HU+fQd1VXXeHI4eK67vsuh2EYhgAAAEy4INgBAACA8xeJBAAAMI1EAgAAmEYiAQAATCORAAAAppFIAAAA00gkAACAaSQSAADAtFrBDsAK5Qe2BzsEICQ1bXljsEMAQs7ew5ssf0ag/l4Kv6hFQO4TSFQkAACAabasSAAAEFI8FcGOwDIkEgAAWM3wBDsCy5BIAABgNY99EwnmSAAAANOoSAAAYDGD1gYAADCN1gYAAEBlVCQAALAarQ0AAGCajfeRoLUBAABMoyIBAIDVaG0AAADTWLUBAABQGRUJAAAsxoZUAADAPBu3NkgkAACwmo0rEsyRAAAAplGRAADAajbekIpEAgAAq9HaAAAAqIyKBAAAVmPVBgAAMI3WBgAAQGVUJAAAsBqtDQAAYJZh2Hf5J60NAABgGhUJAACsZuPJliQSAABYjTkSAADANBtXJJgjAQAATKMiAQCA1XhpFwAAMI3WBgAAQGVUJAAAsBqrNgAAgGm0NgAAACqjIgEAgNVobQAAANNsnEjQ2gAAAKZRkQAAwGJ2fo04iQQAAFazcWuDRAIAAKux/BMAAKAyKhIAAFiN1gYAADCN1gYAAEBlVCQAALCajVsbVCQAALCa4QnM4YfmzZvL4XBUOkaOHHkyJMPQ+PHjFR8fr4iICHXr1k0bN270+0cjkQAAwIZWrVqlvXv3eo+8vDxJ0i233CJJys3N1YQJEzRlyhStWrVKsbGxSk1NVUlJiV/PIZEAAMBqHk9gDj80btxYsbGx3uODDz7QpZdeqq5du8owDE2aNElZWVnq37+/2rZtq7lz5+r48eOaN2+eX88hkQAAwGoBSiTcbreOHj3qc7jd7rM+vqysTG+++aaGDBkih8OhwsJCFRUVKS0tzXuN0+lU165dVVBQ4NePRiIBAMB5IicnR9HR0T5HTk7OWb+3ePFiHT58WIMHD5YkFRUVSZJcLpfPdS6Xy3uuuli1AQCA1QK0j0RmZqZGjx7tM+Z0Os/6vVdffVW9evVSfHy8z7jD4fD5bBhGpbGzIZEAAMBqAVr+6XQ6q5U4/KedO3dqxYoVWrhwoXcsNjZW0snKRFxcnHe8uLi4UpXibGhtAABgtSAs//zV7NmzFRMToz59+njHEhISFBsb613JIZ2cR5Gfn69OnTr5dX8qEgAA2JTH49Hs2bM1aNAg1ar177/yHQ6HMjIylJ2drcTERCUmJio7O1uRkZEaMGCAX88gkQAAwGpB2tlyxYoV2rVrl4YMGVLp3JgxY3TixAmNGDFChw4dUnJyspYvX66oqCi/nuEwDMMIVMChovzA9mCHAISkpi1vDHYIQMjZe3iT5c84sTA7IPeJ6P9YQO4TSMyRAAAAptHaAADAajZ+aReJBAAAVrNxIkFrAwAAmEZFAgAAq9lvXYMXiQQAAFajtQEAAFAZFQkAAKxm44oEiQQAAFYL0Ns/QxGJBAAAVrNxRYI5EgAAwDQqEgAAWI3lnwAAwDRaGwAAAJVRkQAAwGo2rkiQSAAAYDUbL/+ktQEAAEyjIgEAgMUMD6s2AACAWTaeI0FrAwAAmEZFAgAAq9l4siWJBAAAVmOOBAAAMI05EgAAAJVRkQAAwGo2rkiQSAAAYDUbv/2T1gYAADCNigTOWdrvB+mnouJK47f3v1GPPzxSBw4e0sSXX1PB1/9UybFSdbyqrR576D41a3JxEKIFasYDD92j3jfdoJaJLfTLL79o9dfr9My4v+qH73f4XPfwn0bqjkG3KLpBfa1d840yH3lGW7/7PjhBwzq0NoDTmz9rsjz/8Ydk2/aduifjMaV17yzDMDTqT0+rVq1aevH5J1Uvsq5ef3uhho56TO+9NV2REXWCGDlgnZRrkzR71t+07p/fqlatMP3p8VGav2iWuiTfpBPHT0iSRo66W8NGDFLGyMf0w/c7lPHIcL29aJauu7q3So8dD/JPgICy8fJPWhs4Zw0vbKCLGjX0Hvn/95WaXBynqzu0087dP2r9xu/0xCP3q13ry5TQ7BI9/vBIHT9xQkvzPgt26IBlBtw8TO/MW6yt332vTd9u0UMjs3RJk3i1v6qN95p77rtLk/86XUvfX6Etm7/XqPsyFRFZR/1vvjGIkQP+IZFAQJWXl+uD5Z/qd33S5HA4VFZeLkmqXTvce01YWJjCw2tp7TcbgxUmUOOi6kdJkg4dOiJJatrsErliGyv/0wLvNWVl5frH/61WUvJVwQgRVjI8gTlCUFATiT179igrK0vdu3dX69at1aZNG3Xv3l1ZWVnavXt3MEODSR9//g+VHDum9N6pkqSEZk0UHxujydPn6MjREpWXl2vWG+/owM+HtP/ng0GOFqg547PH6KuCNdqy+eT8hxjXRZKk/cUHfK47UHxAMTEX1Xh8sJjHCMwRgoI2R+LLL79Ur1691KRJE6WlpSktLU2GYai4uFiLFy/WSy+9pA8//FDXXnvtGe/jdrvldrt9xi5wu+V0Oq0MH6ex8IOPdN01SYpp3EiSFF6rliY++7iezJmka3vdqrCwC3RNUgd1viYpyJECNSf7L4+rzRWXqV/POyqdM05ZFuhwOCqNAaEsaInEQw89pKFDh2rixImnPZ+RkaFVq1ad8T45OTl66qmnfMYef/RBPTlmVMBiRfX8VLRPK1ev06Tsx33Gr7g8UQvmTlXJsVKVl5er4YUN9Id7MnTF5YlBihSoOc/kZimtV3f9rs9d2vvTPu948b6TlYgYV2PvryWpUeNG2r//5xqPE9YybLxqI2itjW+//VbDhw8/7flhw4bp22+/Pet9MjMzdeTIEZ9j7KjT3xfWWfT3PDW8MFpdUn5b5fmoenXV8MIG2rn7R238bpu6X3dNDUcI1Kxnc7PU+8YbdEvfIdq980efc7t27tG+ov3q0i3FOxYeHq6Ua5O0+qt1NRwpLEdrI/Di4uJUUFCgyy67rMrz//jHPxQXF3fW+zidzkptjPKyA6e5GlbxeDxa/Pc89et1g2rVCvM599EnX+jCBtGKczXWtu079NykV3R95xRdm9wxSNEC1st54Qn97pY++uOA+3XsWKka//95DyVHS/TLLyfbsTOnva4HH75Xhdt3avsPO/Xg6Ht14vgvWvjuB8EMHVYI0YmSgRC0ROKRRx7R8OHDtWbNGqWmpsrlcsnhcKioqEh5eXmaNWuWJk2aFKzw4Kd/rFqrvfuK9bs+aZXO7f/5oHJfmqGfDx5W40YN1bdnDw3/4x+CECVQcwYPPfn/+MK/v+4zPmrEY3pn3mJJ0tTJr6pORB3lvPCkd0Oq2/sPZQ8JnFccRhBn9bz99tuaOHGi1qxZo4qKCkknlwZ27NhRo0eP1q233mrqvuUHtgcyTMA2mrZkfwLgVHsPb7L8GaVPDwzIfeo++VZA7hNIQd3Z8rbbbtNtt92m8vJyHThwsh1x0UUXKTw8/CzfBADgPGLjyZYhsUV2eHh4teZDAACA0BISiQQAALYWoisuAoFEAgAAq9l41Qbv2gAAAKZRkQAAwGq0NgAAgFlskQ0AAFAFKhIAAFiN1gYAADDNxokErQ0AAKxmeAJz+OnHH3/UHXfcoUaNGikyMlJXXXWV1qxZ8++wDEPjx49XfHy8IiIi1K1bN23cuNGvZ5BIAABgQ4cOHdK1116r8PBwffjhh9q0aZP++te/qkGDBt5rcnNzNWHCBE2ZMkWrVq1SbGysUlNTVVJSUu3n0NoAAMBqQWhtPP/882rSpIlmz57tHWvevLn314ZhaNKkScrKylL//v0lSXPnzpXL5dK8efM0bNiwaj2HigQAABYzPEZADrfbraNHj/ocbre7ymcuWbJESUlJuuWWWxQTE6MOHTpo5syZ3vOFhYUqKipSWlqad8zpdKpr164qKCio9s9GIgEAwHkiJydH0dHRPkdOTk6V127fvl3Tpk1TYmKiPvroIw0fPlwPPvigXn/9dUlSUVGRJMnlcvl8z+Vyec9VB60NAACsFqDWRmZmpkaPHu0z5nQ6q36kx6OkpCRlZ2dLkjp06KCNGzdq2rRpuuuuu7zXORwOn+8ZhlFp7ExIJAAAsFqAdrZ0Op2nTRxOFRcXpzZt2viMtW7dWgsWLJAkxcbGSjpZmYiLi/NeU1xcXKlKcSa0NgAAsKFrr71WW7Zs8RnbunWrmjVrJklKSEhQbGys8vLyvOfLysqUn5+vTp06Vfs5VCQAALBaEFZtPPTQQ+rUqZOys7N166236uuvv9aMGTM0Y8YMSSdbGhkZGcrOzlZiYqISExOVnZ2tyMhIDRgwoNrPIZEAAMBqQUgkrr76ai1atEiZmZl6+umnlZCQoEmTJmngwIHea8aMGaMTJ05oxIgROnTokJKTk7V8+XJFRUVV+zkOwzBst29n+YHtwQ4BCElNW94Y7BCAkLP38CbLn1EyvGdA7hP1yrKA3CeQqEgAAGAxG/6b3YtEAgAAq9n4pV0kEgAAWM3GiQTLPwEAgGlUJAAAsJhh44oEiQQAAFazcSJBawMAAJhGRQIAAKsF5lUbIYlEAgAAi9l5jgStDQAAYBoVCQAArGbjigSJBAAAVrPxHAlaGwAAwDQqEgAAWMzOky1JJAAAsJqNWxskEgAAWMzOFQnmSAAAANOoSAAAYDVaGwAAwCzDxokErQ0AAGAaFQkAAKxm44oEiQQAABajtQEAAFAFKhIAAFjNxhUJEgkAACxm59YGiQQAABazcyLBHAkAAGAaFQkAACxm54oEiQQAAFYzHMGOwDK0NgAAgGlUJAAAsBitDQAAYJrhobUBAABQCRUJAAAsRmsDAACYZrBqAwAAoDIqEgAAWIzWBgAAMM3OqzZIJAAAsJhhBDsC6zBHAgAAmEZFAgAAi9HaAAAAptk5kaC1AQAATKMiAQCAxew82ZJEAgAAi9HaAAAAqAIVCQAALGbnd22QSAAAYLH/+i2ylyxZUu0b9u3b13QwAAAgMMaPH6+nnnrKZ8zlcqmoqEiSZBiGnnrqKc2YMUOHDh1ScnKypk6dqiuuuMKv51QrkUhPT6/WzRwOhyoqKvwKAAAAu/MEqbVxxRVXaMWKFd7PYWFh3l/n5uZqwoQJmjNnjlq1aqVnnnlGqamp2rJli6Kioqr9jGolEh6PjWsyAABYLFBzJNxut9xut8+Y0+mU0+ms8vpatWopNja2ingMTZo0SVlZWerfv78kae7cuXK5XJo3b56GDRtW7ZhYtQEAgMUMjyMgR05OjqKjo32OnJyc0z5327Ztio+PV0JCgm6//XZt375dklRYWKiioiKlpaV5r3U6neratasKCgr8+tlMTbYsLS1Vfn6+du3apbKyMp9zDz74oJlbAgCAs8jMzNTo0aN9xk5XjUhOTtbrr7+uVq1aad++fXrmmWfUqVMnbdy40TtPwuVy+XzH5XJp586dfsXkdyKxdu1a9e7dW8ePH1dpaakaNmyoAwcOKDIyUjExMSQSAACcIlA7W56pjXGqXr16eX/drl07paSk6NJLL9XcuXN1zTXXSDo5t9E3TqPS2Nn43dp46KGHdNNNN+ngwYOKiIjQypUrtXPnTnXs2FEvvPCCv7cDAMD2AtXaOBd169ZVu3bttG3bNu+8iV8rE78qLi6uVKU4G78TiXXr1unhhx9WWFiYwsLC5Ha71aRJE+Xm5uqxxx7z93YAAKAGuN1ubd68WXFxcUpISFBsbKzy8vK858vKypSfn69OnTr5dV+/E4nw8HBv2cPlcmnXrl2SpOjoaO+vAQDAv3kMR0AOfzzyyCPKz89XYWGhvvrqK9188806evSoBg0aJIfDoYyMDGVnZ2vRokX69ttvNXjwYEVGRmrAgAF+PcfvORIdOnTQ6tWr1apVK3Xv3l1PPvmkDhw4oDfeeEPt2rXz93YAANheMLbI3rNnj/7whz/owIEDaty4sa655hqtXLlSzZo1kySNGTNGJ06c0IgRI7wbUi1fvtyvPSQkyWEY/k0BWb16tUpKStS9e3ft379fgwYN0pdffqmWLVtq9uzZat++vV8BWKH8wPZghwCEpKYtbwx2CEDI2Xt4k+XP2JBwU0Du067w/YDcJ5D8rkgkJSV5f924cWMtXbo0oAEBAGA3gVq1EYp4aRcAABYL1hbZNcHvRCIhIeGMa0x/3TULAADYn9+JREZGhs/n8vJyrV27VsuWLdOjjz4aqLgAALCNYEy2rCl+JxKjRo2qcnzq1KlavXr1OQcEAIDd2HmORMBe2tWrVy8tWLAgULcDAMA2grGPRE0JWCLx7rvvqmHDhoG6HQAAOA+Y2pDqPydbGoahoqIi7d+/Xy+//HJAgzMrIr5zsEMAQtJEV/dghwD8V2KOxH/o16+fTyJxwQUXqHHjxurWrZsuv/zygAYHAIAdhGpbIhD8TiTGjx9vQRgAAOB85PccibCwMBUXF1ca//nnnxUWFhaQoAAAsBMjQEco8rsicbpXc7jdbtWuXfucAwIAwG5obUh68cUXJUkOh0OzZs1SvXr1vOcqKir0+eefM0cCAID/MtVOJCZOnCjpZEXilVde8Wlj1K5dW82bN9crr7wS+AgBADjPsWpDUmFhoSSpe/fuWrhwoS688ELLggIAwE48wQ7AQn7Pkfj000+tiAMAAJyH/F61cfPNN+u5556rNP6Xv/xFt9xyS0CCAgDATgw5AnKEIr8Tifz8fPXp06fSeM+ePfX5558HJCgAAOzEYwTmCEV+tzaOHTtW5TLP8PBwHT16NCBBAQBgJ54QrSYEgt8VibZt2+rtt9+uND5//ny1adMmIEEBAIDzg98ViSeeeEK///3v9cMPP+j666+XJH388ceaN2+e3n333YAHCADA+S5U5zcEgt+JRN++fbV48WJlZ2fr3XffVUREhNq3b69PPvlE9evXtyJGAADOayz/PEWfPn28Ey4PHz6st956SxkZGVq/fr0qKioCGiAAAAhdfs+R+NUnn3yiO+64Q/Hx8ZoyZYp69+6t1atXBzI2AABswc7LP/2qSOzZs0dz5szRa6+9ptLSUt16660qLy/XggULmGgJAMBp2Lm1Ue2KRO/evdWmTRtt2rRJL730kn766Se99NJLVsYGAABCXLUrEsuXL9eDDz6o++67T4mJiVbGBACArVCRkPTFF1+opKRESUlJSk5O1pQpU7R//34rYwMAwBbsPEei2olESkqKZs6cqb1792rYsGGaP3++Lr74Ynk8HuXl5amkpMTKOAEAQAjye9VGZGSkhgwZoi+//FIbNmzQww8/rOeee04xMTHq27evFTECAHBe8zgCc4Qi08s/Jemyyy5Tbm6u9uzZo7/97W+BigkAAFvxyBGQIxSZ2pDqVGFhYUpPT1d6enogbgcAgK2E6Is7A+KcKhIAAOC/W0AqEgAA4PTsvPyTRAIAAIt5HKE5vyEQaG0AAADTqEgAAGAxO0+2JJEAAMBidp4jQWsDAACYRkUCAACLhequlIFAIgEAgMVCdVfKQKC1AQAATKMiAQCAxVi1AQAATGOOBAAAMI3lnwAAAFWgIgEAgMXsPEeCigQAABbzOAJznIucnBw5HA5lZGR4xwzD0Pjx4xUfH6+IiAh169ZNGzdu9Ou+JBIAANjcqlWrNGPGDF155ZU+47m5uZowYYKmTJmiVatWKTY2VqmpqSopKan2vUkkAACwmCdAhxnHjh3TwIEDNXPmTF144YXeccMwNGnSJGVlZal///5q27at5s6dq+PHj2vevHnVvj+JBAAAFgtUIuF2u3X06FGfw+12n/HZI0eOVJ8+fXTDDTf4jBcWFqqoqEhpaWneMafTqa5du6qgoKDaPxuJBAAA54mcnBxFR0f7HDk5Oae9fv78+frnP/9Z5TVFRUWSJJfL5TPucrm856qDVRsAAFjMCNCGVJmZmRo9erTPmNPprPLa3bt3a9SoUVq+fLnq1Klz2ns6HL7BGYZRaexMSCQAALBYoDakcjqdp00cTrVmzRoVFxerY8eO3rGKigp9/vnnmjJlirZs2SLpZGUiLi7Oe01xcXGlKsWZ0NoAAMCGevTooQ0bNmjdunXeIykpSQMHDtS6devUokULxcbGKi8vz/udsrIy5efnq1OnTtV+DhUJAAAsFowtsqOiotS2bVufsbp166pRo0be8YyMDGVnZysxMVGJiYnKzs5WZGSkBgwYUO3nkEgAAGCxUN3ZcsyYMTpx4oRGjBihQ4cOKTk5WcuXL1dUVFS17+EwDCNUfz7TatW+ONghACFpoqt7sEMAQs4Du9+0/BmTm94RkPuM2mV9rP5ijgQAADCN1gYAABaz82vESSQAALCYnRMJWhsAAMA0KhIAAFjMdqsa/gOJBAAAFvMEaIvsUERrAwAAmEZFAgAAi9l5siWJBAAAFrPzHAlaGwAAwDQqEgAAWMxj45oEiQQAABZjjgQAADDNvvUI5kgAAIBzQEUCAACL0doAAACmsbMlAABAFahIAABgMZZ/AgAA0+ybRtDaAAAA54CKBAAAFmPVBgAAMM3OcyRobQAAANOoSAAAYDH71iNIJAAAsBxzJAAAgGnMkQAAAKgCFQkAACxm33oEiQQAAJaz8xwJWhsAAMA0KhIAAFjMsHFzg0QCAACL0doAAACoAhUJAAAsZud9JEgkAACwmH3TCFobAADgHJBI4Jx1vi5ZixfN0a4da/Svsh/Vt+//VLrm8stbatHC2fp5/2Yd+nmL/u+L99WkSXwQogVqRts7e+gPy7M1bNNMDds0UzcvHqdm3a70no+4qL5umHCv/rj6JQ3f+qr6vjFG0c1dQYwYVvLICMgRikgkcM7q1o3UN99s0oMZj1d5vkWLZsr/dLG2bPlePVJv1m+SUvVs9iT98ou7hiMFas6xvQdVkPO23u7zhN7u84T2FGxSn1dHq2GriyVJfWY9pPpNY/T3uydqfs/HVbLngNL/lqlaEc4gRw4reAJ0hCLmSOCcLfvoUy376NPTnv/z02P14bJP9KfMZ71jhYW7aiI0IGh2rFjr83ll7v+q3Z09FNuhpTzlFYrrmKi3eozVwa0/SpI+y5qtu9e9rFb9UrRp/mdBiBhWsvM+ElQkYCmHw6HevXpo27btWvrBW/ppz3oVfPl+le0PwK4cFziU2PcahUc4tfef2xTmPPlvuH+5y73XGB5DnrIKxf+2VbDCBEw57xMJt9uto0eP+hyGYd/M73wTE3ORoqLqacyjI/XR8s/Uq88ALX5vmd59Z5a6dL4m2OEBlmp0+SUa9t0sjfhhjrpn/1F/v2eSDm37SYe+36uju/er09jb5IyO1AXhYeo44ibVdTVQZEyDYIcNC9i5tRHSicTu3bs1ZMiQM16Tk5Oj6Ohon8PwlNRQhDibCy44+b/Ykvc/0uQXZ2r9+o3K/ctU/X3pCt17751Bjg6w1qEf9mp+zyz9b7/x2vDGx0qdOEwXJsbL868KLR02WQ1axOreb2fovq2v6eKU1trxyToZFaH61wXOhRGg/0JRSCcSBw8e1Ny5c894TWZmpo4cOeJzOC6IqqEIcTYHDhxUeXm5Nm/e5jP+3Xfb1LTJxUGKCqgZnvIKHdmxT8XfFOofz7+jA5t26aohPSVJ+zfs0PyeWZre5h692vF+LbkzV3UurKeju/cHOWrAP0GdbLlkyZIznt++fftZ7+F0OuV0+s5ydjgc5xQXAqe8vFyrV69Xq1aX+ownJrbQzl17ghQVECQOh3d+xK/KSk5IkqKbuxRzZQutfOHdYEQGi9m5zhTURCI9PV0Oh+OMcxpICkJf3bqRatkywfs5oXlTtW9/hQ4ePKTdu3/SCxOm6W9vTdMXX6zUZ/kF+p+0brqxT6p63HBzEKMGrJUy9lbt/HS9Sn76WbXr1VFi3xRdnNJaS+7MlSS17PNbnfi5RCU/HVCjy5uoy/g7tf2j1dr9+bdBjhxW8Nh47l5QE4m4uDhNnTpV6enpVZ5ft26dOnbsWLNBwW9JHdvr4xX//lfUX18YL0ma+/o7unvoQ3rvvWUaMfJPGjvmAU2a+LS2bN2uW267R/9XsCpIEQPWi7iovlInDVfdmAZylxzXz5t3a8mdudr9xclEITKmga57cqAiL4pWafFhfbfgS62avCjIUQP+cxhBXOLQt29fXXXVVXr66aerPL9+/Xp16NBBHo9/RaFatem9A1WZ6Ooe7BCAkPPA7jctf8YdzfoH5D5v7lwYkPsEUlArEo8++qhKS0tPe75ly5b69NPTb3QEAMD5IFS3tw6EoK7a6Ny5s3r27Hna83Xr1lXXrl1rMCIAAOxh2rRpuvLKK1W/fn3Vr19fKSkp+vDDD73nDcPQ+PHjFR8fr4iICHXr1k0bN270+zkhvfwTAAA7CMY+Epdccomee+45rV69WqtXr9b111+vfv36eZOF3NxcTZgwQVOmTNGqVasUGxur1NRUlZT4txcTiQQAABYLxs6WN910k3r37q1WrVqpVatWevbZZ1WvXj2tXLlShmFo0qRJysrKUv/+/dW2bVvNnTtXx48f17x58/x6DokEAAAWC9RrxKt6LYTbffY3KVdUVGj+/PkqLS1VSkqKCgsLVVRUpLS0NO81TqdTXbt2VUFBgV8/G4kEAADniapeC5GTk3Pa6zds2KB69erJ6XRq+PDhWrRokdq0aaOioiJJksvl8rne5XJ5z1UXrxEHAMBigXpPRmZmpkaPHu0zduruzv/psssu07p163T48GEtWLBAgwYNUn5+vvf8qZs+Gobh90aQJBIAAFgsUFtkV/VaiDOpXbu2WrZsKUlKSkrSqlWrNHnyZI0dO1aSVFRUpLi4OO/1xcXFlaoUZ0NrAwCA/xKGcXKeRUJCgmJjY5WXl+c9V1ZWpvz8fHXq1Mmve1KRAADAYsHYRPqxxx5Tr1691KRJE5WUlGj+/Pn67LPPtGzZMjkcDmVkZCg7O1uJiYlKTExUdna2IiMjNWDAAL+eQyIBAIDFgrGz5b59+3TnnXdq7969io6O1pVXXqlly5YpNTVVkjRmzBidOHFCI0aM0KFDh5ScnKzly5crKirKr+cE9V0bVuFdG0DVeNcGUFlNvGujX9MbA3Kf93Z9EJD7BBIVCQAALBaoyZahiEQCAACLBWr5Zyhi1QYAADCNigQAABaz82vESSQAALCYDdc1eJFIAABgMTtPtmSOBAAAMI2KBAAAFrPzqg0SCQAALGbnyZa0NgAAgGlUJAAAsBirNgAAgGm0NgAAAKpARQIAAIuxagMAAJjmsfEcCVobAADANCoSAABYzL71CBIJAAAsZ+dVGyQSAABYzM6JBHMkAACAaVQkAACwGDtbAgAA02htAAAAVIGKBAAAFmNnSwAAYJqd50jQ2gAAAKZRkQAAwGJ2nmxJIgEAgMVobQAAAFSBigQAABajtQEAAExj+ScAADDNwxwJAACAyqhIAABgMVobAADANFobAAAAVaAiAQCAxWhtAAAA02htAAAAVIGKBAAAFqO1AQAATKO1AQAAUAUqEgAAWIzWBgAAMM0wPMEOwTIkEgAAWMzOrxFnjgQAADCNigQAABYzbLxqg0QCAACL0doAAADnlZycHF199dWKiopSTEyM0tPTtWXLFp9rDMPQ+PHjFR8fr4iICHXr1k0bN2706zkkEgAAWMwwjIAc/sjPz9fIkSO1cuVK5eXl6V//+pfS0tJUWlrqvSY3N1cTJkzQlClTtGrVKsXGxio1NVUlJSXVfo7DsGHjplbti4MdAhCSJrq6BzsEIOQ8sPtNy58R16BNQO6zY99aud1unzGn0ymn03nW7+7fv18xMTHKz89Xly5dZBiG4uPjlZGRobFjx0qS3G63XC6Xnn/+eQ0bNqxaMVGRAADgPJGTk6Po6GifIycnp1rfPXLkiCSpYcOGkqTCwkIVFRUpLS3Ne43T6VTXrl1VUFBQ7ZiYbAkAgMUCtbNlZmamRo8e7TNWnWqEYRgaPXq0rrvuOrVt21aSVFRUJElyuVw+17pcLu3cubPaMZFIAABgsUDNIqhuG+NU999/v7755ht9+eWXlc45HA6fz4ZhVBo7E1obAADY2AMPPKAlS5bo008/1SWXXOIdj42NlfTvysSviouLK1UpzoREAgAAi3lkBOTwh2EYuv/++7Vw4UJ98sknSkhI8DmfkJCg2NhY5eXlecfKysqUn5+vTp06Vfs5tDYAALBYMBZIjhw5UvPmzdN7772nqKgob+UhOjpaERERcjgcysjIUHZ2thITE5WYmKjs7GxFRkZqwIAB1X4OiQQAABbzBCGRmDZtmiSpW7duPuOzZ8/W4MGDJUljxozRiRMnNGLECB06dEjJyclavny5oqKiqv0c9pEA/ouwjwRQWU3sI9EwKjEg9zlYsi0g9wkkKhIAAFjMhv9m9yKRAADAYry0CwAAoApUJAAAsBitDQAAYFowVm3UFFobAADANCoSAABYLFAv7QpFJBIAAFiM1gYAAEAVqEgAAGAxVm0AAADTmCMBAABMs3NFgjkSAADANCoSAABYzM4VCRIJAAAsZt80gtYGAAA4Bw7DzvUWBJXb7VZOTo4yMzPldDqDHQ4QMvizATshkYBljh49qujoaB05ckT169cPdjhAyODPBuyE1gYAADCNRAIAAJhGIgEAAEwjkYBlnE6nxo0bx2Qy4BT82YCdMNkSAACYRkUCAACYRiIBAABMI5EAAACmkUgAAADTSCRgmZdfflkJCQmqU6eOOnbsqC+++CLYIQFB9fnnn+umm25SfHy8HA6HFi9eHOyQgHNGIgFLvP3228rIyFBWVpbWrl2rzp07q1evXtq1a1ewQwOCprS0VO3bt9eUKVOCHQoQMCz/hCWSk5P1m9/8RtOmTfOOtW7dWunp6crJyQliZEBocDgcWrRokdLT04MdCnBOqEgg4MrKyrRmzRqlpaX5jKelpamgoCBIUQEArEAigYA7cOCAKioq5HK5fMZdLpeKioqCFBUAwAokErCMw+Hw+WwYRqUxAMD5jUQCAXfRRRcpLCysUvWhuLi4UpUCAHB+I5FAwNWuXVsdO3ZUXl6ez3heXp46deoUpKgAAFaoFewAYE+jR4/WnXfeqaSkJKWkpGjGjBnatWuXhg8fHuzQgKA5duyYvv/+e+/nwsJCrVu3Tg0bNlTTpk2DGBlgHss/YZmXX35Zubm52rt3r9q2bauJEyeqS5cuwQ4LCJrPPvtM3bt3rzQ+aNAgzZkzp+YDAgKARAIAAJjGHAkAAGAaiQQAADCNRAIAAJhGIgEAAEwjkQAAAKaRSAAAANNIJAAAgGkkEgAAwDQSCcCGxo8fr6uuusr7efDgwUpPT6/xOHbs2CGHw6F169bV+LMB1AwSCaAGDR48WA6HQw6HQ+Hh4WrRooUeeeQRlZaWWvrcyZMnV3sLZv7yB+APXtoF1LCePXtq9uzZKi8v1xdffKGhQ4eqtLRU06ZN87muvLxc4eHhAXlmdHR0QO4DAKeiIgHUMKfTqdjYWDVp0kQDBgzQwIEDtXjxYm874rXXXlOLFi3kdDplGIaOHDmie++9VzExMapfv76uv/56rV+/3ueezz33nFwul6KionT33Xfrl19+8Tl/amvD4/Ho+eefV8uWLeV0OtW0aVM9++yzkqSEhARJUocOHeRwONStWzfv92bPnq3WrVurTp06uvzyy/Xyyy/7POfrr79Whw4dVKdOHSUlJWnt2rUB/J0DEIqoSABBFhERofLycknS999/r3feeUcLFixQWFiYJKlPnz5q2LChli5dqujoaE2fPl09evTQ1q1b1bBhQ73zzjsaN26cpk6dqs6dO+uNN97Qiy++qBYtWpz2mZmZmZo5c6YmTpyo6667Tnv37tV3330n6WQy8Nvf/lYrVqzQFVdcodq1a0uSZs6cqXHjxmnKlCnq0KGD1q5dq3vuuUd169bVoEGDVFpaqhtvvFHXX3+93nzzTRUWFmrUqFEW/+4BCDoDQI0ZNGiQ0a9fP+/nr776ymjUqJFx6623GuPGjTPCw8ON4uJi7/mPP/7YqF+/vvHLL7/43OfSSy81pk+fbhiGYaSkpBjDhw/3OZ+cnGy0b9++yucePXrUcDqdxsyZM6uMsbCw0JBkrF271me8SZMmxrx583zG/vznPxspKSmGYRjG9OnTjYYNGxqlpaXe89OmTavyXgDsg9YGUMM++OAD1atXT3Xq1FFKSoq6dOmil156SZLUrFkzNW7c2HvtmjVrdOzYMTVq1Ej16tXzHoWFhfrhhx8kSZs3b1ZKSorPM079/J82b94st9utHj16VDvm/fv3a/fu3br77rt94njmmWd84mjfvr0iIyOrFQcAe6C1AdSw7t27a9q0aQoPD1d8fLzPhMq6dev6XOvxeBQXF6fPPvus0n0aNGhg6vkRERF+f8fj8Ug62d5ITk72OfdrC8YwDFPxADi/kUgANaxu3bpq2bJlta79zW9+o6KiItWqVUvNmzev8prWrVtr5cqVuuuuu7xjK1euPO09ExMTFRERoY8//lhDhw6tdP7XOREVFRXeMZfLpYsvvljbt2/XwIEDq7xvmzZt9MYbb+jEiRPeZOVMcQCwB1obQAi74YYblJKSovT0dH300UfasWOHCgoK9Pjjj2v16tWSpFGjRum1117Ta6+9pq1bt2rcuHHauHHjae9Zp04djR07VmPGjNHrr7+uH374QStXrtSrr74qSYqJiVFERISWLVumffv26ciRI5JObnKVk5OjyZMna+vWrdqwYYNmz56tCRMmSJIGDBigCy64QHfffbc2bdqkpUuX6oUXXrD4dwhAsJFIACHM4XBo6dKl6tKli4YMGaJWrVrp9ttv144dO+RyuSRJt912m5588kmNHTtWHTt21M6dO3Xfffed8b5PPPGEHn74YT355JNq3bq1brvtNhUXF0uSatWqpRdffFHTp09XfHy8+vXrJ0kaOnSoZs2apTlz5qhdu3bq2rWr5syZ410uWq9ePb3//vvatGmTOnTooKysLD3//PMW/u4ACAUOg8YmAAAwiYoEAAAwjUQCAACYRiIBAABMI5EAAACmkUgAAADTSCQAAIBpJBIAAMA0EgkAAGAaiQQAADCNRAIAAJhGIgEAAEz7fyFuenKE9rd/AAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " 0 0.832 0.798 0.814 99\n", " 1 0.661 0.709 0.684 55\n", "\n", " accuracy 0.766 154\n", " macro avg 0.746 0.754 0.749 154\n", "weighted avg 0.771 0.766 0.768 154\n", "\n" ] } ], "source": [ "# Use Seaborn to create a confusion matrix heatmap and MatPlotLib to display\n", "confusion_matrix = pd.crosstab(df['Actual'], df['Predicted'], rownames=['Actual'], colnames=['Predicted'])\n", "sn.heatmap(confusion_matrix, annot=True)\n", "plt.show()\n", "print(metrics.classification_report(y_test, y_pred, digits=3))" ] }, { "cell_type": "markdown", "id": "b691d410-c1f7-419e-9c3f-24f0d55545db", "metadata": {}, "source": [ "# NaiveBayes " ] }, { "cell_type": "markdown", "id": "5cb737da-8ca9-43b7-8b39-c3f0b4f02d1b", "metadata": {}, "source": [] }, { "cell_type": "code", "execution_count": null, "id": "6881fb78-9b6d-441c-88ba-91ad3a30c9b9", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "d105e676-f417-4b03-b21d-74d1b52d474b", "metadata": {}, "source": [ "# Summary and Conclusion" ] }, { "cell_type": "markdown", "id": "433777c4-445e-451c-b2de-bdc858dae981", "metadata": {}, "source": [] }, { "cell_type": "code", "execution_count": null, "id": "f1a9fe59-25f8-4528-93b1-bea00ffc9f52", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "anaconda-panel-2023.05-py310", "language": "python", "name": "conda-env-anaconda-panel-2023.05-py310-py" }, "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.11.5" } }, "nbformat": 4, "nbformat_minor": 5 }