{ "cells": [ { "cell_type": "code", "execution_count": 2, "id": "36ac21fc", "metadata": { "trusted": true }, "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": 3, "id": "3c07c748", "metadata": { "trusted": true }, "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": 3, "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": 4, "id": "f5ce7fbc", "metadata": { "trusted": true }, "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": 5, "id": "9c236d8a", "metadata": { "trusted": true }, "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": 6, "id": "cf217602", "metadata": { "trusted": true }, "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": 6, "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": 7, "id": "3f4c8504", "metadata": { "trusted": false }, "outputs": [], "source": [ "# # this step is just to demonstrate the api methods and not a necessary step\n", "# dir(SVC)" ] }, { "cell_type": "code", "execution_count": 8, "id": "25ec0839", "metadata": { "trusted": true }, "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": 8, "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": 9, "id": "59cf09a6", "metadata": { "trusted": true }, "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],\n", " dtype=int64)" ] }, "execution_count": 9, "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": 10, "id": "606707f8", "metadata": { "trusted": true }, "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": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# print test labels (ground truth) that is compared to classifier\n", "y_test" ] }, { "cell_type": "code", "execution_count": 11, "id": "fb8d51eb", "metadata": { "trusted": true }, "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": 12, "id": "a1096778", "metadata": { "trusted": true }, "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": 13, "id": "e5d198fa", "metadata": { "trusted": true }, "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": 14, "id": "fa40302a", "metadata": { "trusted": true }, "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": 15, "id": "06a71bed", "metadata": { "trusted": true }, "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": 16, "id": "5404a42e", "metadata": { "trusted": true }, "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": 17, "id": "4bfb84c7", "metadata": { "trusted": false }, "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": 17, "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": { "trusted": false }, "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": 18, "id": "9be2e2e6-cc3e-46e1-8ece-1d74db056ff4", "metadata": { "trusted": true }, "outputs": [], "source": [ "from sklearn.tree import DecisionTreeClassifier" ] }, { "cell_type": "code", "execution_count": 19, "id": "714cc906-b012-4f5e-973c-39b57e9aa903", "metadata": { "trusted": true }, "outputs": [], "source": [ "# Create Decision Tree classifer object\n", "desc_clf = DecisionTreeClassifier()\n", "\n", "# Train Decision Tree Classifer\n", "desc_clf = desc_clf.fit(X_train,y_train)\n", "\n", "#Predict the response for test dataset\n", "y_prediction = desc_clf.predict(X_test)" ] }, { "cell_type": "code", "execution_count": 20, "id": "7f34e620-79ef-4655-a898-5594adc55ecc", "metadata": { "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[77 22]\n", " [14 41]]\n", " precision recall f1-score support\n", "\n", " 0 0.846 0.778 0.811 99\n", " 1 0.651 0.745 0.695 55\n", "\n", " accuracy 0.766 154\n", " macro avg 0.748 0.762 0.753 154\n", "weighted avg 0.776 0.766 0.769 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_prediction))\n", "\n", "\n", "print(metrics.classification_report(y_test, y_prediction, digits=3))" ] }, { "cell_type": "code", "execution_count": 21, "id": "7d1f2281-ead6-4947-9a92-44525fe6bc9b", "metadata": { "trusted": true }, "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_prediction}\n", "df = pd.DataFrame(data)\n", "print(df)" ] }, { "cell_type": "code", "execution_count": 23, "id": "1b5bd6e9-982f-49b4-99f7-decdf5a9ed3b", "metadata": { "trusted": true }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhIAAAGwCAYAAAD8AYzHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAqQUlEQVR4nO3de1RVdf7/8dfhdkIREOUiJWpZolOaYSFdNI0yc0wHqu80TWHazGTkBbSMmW/Z1CTW1FhOXsoMnYoySx210jFKzAbKKJsuE5VaWHpQS0TwywE9+/dHvznTCTTO9mwO7p6P1l5LPnufvd+HtVy+e78/n892GIZhCAAAwISQYAcAAABOXCQSAADANBIJAABgGokEAAAwjUQCAACYRiIBAABMI5EAAACmkUgAAADTwoIdgBWa9m0PdghAu3TemdcHOwSg3XnP9ablzwjUv0vhXU8NyH0CiYoEAAAwzZYVCQAA2hXPkWBHYBkSCQAArGZ4gh2BZUgkAACwmse+iQRzJAAAgGlUJAAAsJhBawMAAJhGawMAAKA5KhIAAFiN1gYAADDNxvtI0NoAAACmUZEAAMBqtDYAAIBprNoAAABojooEAAAWY0MqAABgno1bGyQSAABYzcYVCeZIAAAA06hIAABgNRtvSEUiAQCA1WhtAAAANEdFAgAAq7FqAwAAmEZrAwAAoDkqEgAAWI3WBgAAMMsw7Lv8k9YGAAAwjYoEAABWs/FkSxIJAACsxhwJAABgmo0rEsyRAAAAplGRAADAary0CwAAmEZrAwAAoDkqEgAAWI1VGwAAwDRaGwAAAM2RSAAAYDWPJzCHH3r27CmHw9HsyM3NlSQ1NDQoNzdXXbp0UVRUlLKzs1VdXe33VyORAADAakFIJLZs2aLdu3d7jw0bNkiSrr76aklSXl6e1qxZo+XLl6u0tFS7du1SVlaW31+NORIAAJwg3G633G63z5jT6ZTT6Wx2bXx8vM/Ps2fP1mmnnaahQ4fqwIEDWrx4sYqLizV8+HBJUlFRkfr27avy8nINHjy41TFRkQAAwGKGcSQgR2FhoWJiYnyOwsLCH31+Y2Ojnn76aY0fP14Oh0MVFRVqampSZmam95rU1FSlpKSorKzMr+9GRQIAAKsFaPlnQUGB8vPzfcZaqkb80KpVq1RTU6Nx48ZJklwulyIiIhQbG+tzXWJiolwul18xkUgAAGC1AC3/PFob48csXrxYI0eOVHJyckDi+D4SCQAAbOzLL7/Uq6++qhUrVnjHkpKS1NjYqJqaGp+qRHV1tZKSkvy6P3MkAACwWhBWbfxHUVGREhISNGrUKO9YWlqawsPDVVJS4h2rrKxUVVWVMjIy/Lo/FQkAAKwWpJ0tPR6PioqKlJOTo7Cw//6THxMTowkTJig/P19xcXGKjo7WpEmTlJGR4deKDYlEAgAA23r11VdVVVWl8ePHNzs3Z84chYSEKDs7W263WyNGjND8+fP9fobDMAwjEMG2J037tgc7BKBdOu/M64MdAtDuvOd60/Jn/N8//P8HuiWRl90SkPsEEhUJAACsxku7AAAAmqMiAQCA1QK0IVV7RCIBAIDVbJxI0NoAAACmUZEAAMBqNp5sSSIBAIDVbNzaIJEAAMBqNq5IMEcCAACYRkUCAACr0doAAACm0doAAABojooEAABWo7UBAABMs3EiQWsDAACYRkUCAACrGUawI7AMiQQAAFajtQEAANAcFQkAAKxm44oEiQQAAFaz8YZUJBIAAFjNxhUJ5kgAAADTqEgAAGA1ln8CAADTaG0AAAA0R0UCAACr2bgiQSIBAIDVbLz8k9YGAAAwjYoEAAAWMzys2gAAAGbZeI4ErQ0AAGAaFQkAAKxm48mWJBIAAFiNORIAAMA05kgAAAA0R0UCAACr2bgiQSIBAIDVbPz2T1obAADANCoSOG6XZedol2tPs/FfZv1cN/7qKo24alyLn3vo3t9rxPCLLI4OCI7xk67X8FFD1bN3D7kb3Hp/ywd65E8L9OW2KklSdGwnTbztJg0eep6STk7U/m/2a+O6NzT//kWqO1gf5OgRcLQ2gKN77olH5PneX5LPtn+p30z9vS4bdpGSErpq4+pnfK5f/vdXVFT8oi4aPKitQwXazDkZZ2tZ0Qp9tPXfCgsN1a2//50WLJujrCHXqeFQg+KTuio+savm/PFRbf/0C3U7JVF/eOA2xSd11W03/W+ww0egsfwTOLq4zrE+Pz/x1PPqfnI3nTvwLDkcDnXtEudzvmTTPzXikovUoUNkG0YJtK1bfzXN5+eZU+7Tax+9pH79++jd8ve17ZMdmn7TH7znv/ryaz06+3Hd9+hdCg0N1ZEjR9o6ZMAU5kggoJqamrT2H6/rF6Muk8PhaHb+o08+0yefbVfWz0cEITogeKI6dZQkHaipPeo1nTpFqb6uniTCjgxPYI52KKgViX379unJJ59UWVmZXC6XJCkpKUnnn3++xo0bp/j4+GCGBxNKNpXpYF2dxl5xaYvnV6xdr1N7dtfAs/q1cWRA8DgcDk2/d4ree+u7SkRLYuNi9Jv8cXrxqdVtHB3ahI1bG0GrSGzZskVnnHGG5s6dq5iYGA0ZMkRDhgxRTEyM5s6dq9TUVL3zzjs/eh+3263a2lqfw+12t8E3QEtWrF2vCwcPUkJ8l2bnGtxuvbxhI9UI/OQUzJ6m3qmn6o6bZ7Z4vmNUB819+s/a/ukOPfbg4jaODjg+QatITJo0SVdffbUWLlzYrARuGIZuvvlmTZo0SWVlZce8T2Fhof74xz/6jP3vbZN11+1TAh4zjm2Xq1rl72zVw7Nanij2j9c36/8a3Lry8kvaODIgeGbMytdFmedrwi9ytWf33mbnO3TsoHnP/kWH6g4p/8bf6/Bh2hp2ZLBqI/Def/99LVmypMU+usPhUF5engYOHPij9ykoKFB+fr7PWMjBrwMWJ1pv5UsbFNc5RkMyzmvx/Iq16zXswvRmkzMBu5oxK1/DRw7Rb7Ju1a6q3c3Od4zqoPnPzVFjY6Om5sxQo7sxCFGiTdi4tRG0RCIpKUlvv/22UlNTWzz/9ttvKzEx8Ufv43Q65XQ6fcaaGvcFJEa0nsfj0aqXNmjMyEyFhYU2O1/11S5VbP1QCx68JwjRAW2vYPY0jfzFpcobd4fq6w6pS/x3q5fqDtbJ3dD4XRKx7GGdFOnUH3LvUceojuoY9d2EzP3f1PgsqYYNtNOJkoEQtERi+vTp+u1vf6uKigpdcskl3qShurpaJSUlWrRokR588MFghQc/lW15T7ur9+gXoy5r8fyKtf9QYkJXnX/eOW0cGRAc14zLkiQ9sXKez/hdU+7TmmUvK7V/H/VP+5kkac1bz/tcc8W52dq909U2gcLWvv76a82YMUOvvPKKDh06pN69e6uoqEiDBn23j49hGJo5c6YWLVqkmpoaXXDBBVqwYIFOP/30Vj/DYRjB2wB82bJlmjNnjioqKrzLnUJDQ5WWlqb8/Hxdc801pu7btG97IMMEbOO8M68PdghAu/Oe603Ln1F/z3UBuU/Hu5758Yv+v/3792vgwIEaNmyYJk6cqPj4eH322Wc67bTTdNppp0mS7r//fhUWFmrp0qXq1auX7rzzTn3wwQf6+OOPddJJJ7XqOUFNJP6jqalJ+/Z9147o2rWrwsPDj+9+JBJAi0gkgObaJJG4+9qA3Kfj3c+2+to77rhDb775pt54440WzxuGoeTkZE2bNk3Tp0+XJB04cECJiYlasmSJfvnLX7bqOe1iQ6rw8HB169ZN3bp1O+4kAgAAu/Jny4PVq1dr0KBBuvrqq5WQkKCBAwdq0aJF3vM7duyQy+VSZmamdywmJkbp6ek/umLy+9pFIgEAgK15jIAchYWFiomJ8TkKCwtbfOT27du98x3Wr1+viRMnavLkyVq6dKkkeTeC/OHChsTERO+51uBdGwAAWC1AqzZa2vLghysX/8Pj8WjQoEGaNWuWJGngwIH68MMPtXDhQuXk5AQkHomKBAAAJwyn06no6Gif42iJRLdu3dSvn+/rCPr27auqqu9eZZ+UlCTpu9WS31ddXe091xokEgAAWC1ArQ1/XHDBBaqsrPQZ+/TTT9WjRw9JUq9evZSUlKSSkhLv+draWr311lvKyMho9XNobQAAYLFgbJGdl5en888/X7NmzdI111yjt99+W48//rgef/xxSd/tIj116lT96U9/0umnn+5d/pmcnKyxY8e2+jkkEgAA2NC5556rlStXqqCgQPfcc4969eqlhx9+WNdd9989LW6//XbV19frt7/9rWpqanThhRdq3bp1rd5DQmon+0gEGvtIAC1jHwmgubbYR6JuRlZA7hN1/4qA3CeQqEgAAGA1XtoFAABMs/FLu1i1AQAATKMiAQCA1WhtAAAAswwbJxK0NgAAgGlUJAAAsJqNKxIkEgAAWC0IO1u2FVobAADANCoSAABYjdYGAAAwzcaJBK0NAABgGhUJAAAsZsP3Y3qRSAAAYDUbtzZIJAAAsJqNEwnmSAAAANOoSAAAYDE7v2uDRAIAAKvZOJGgtQEAAEyjIgEAgNXs+6oNEgkAAKxm5zkStDYAAIBpVCQAALCajSsSJBIAAFjNxnMkaG0AAADTqEgAAGAxO0+2JJEAAMBqNm5tkEgAAGAxO1ckmCMBAABMoyIBAIDVaG0AAACzDBsnErQ2AACAaVQkAACwmo0rEiQSAABYjNYGAABAC6hIAABgNRtXJEgkAACwmJ1bGyQSAABYzM6JBHMkAACAaVQkAACwmJ0rEiQSAABYzXAEOwLL0NoAAACmUZEAAMBitDYAAIBphofWBgAAQDNUJAAAsBitDQAAYJrBqg0AAIDmSCQAALCY4QnM4Y+7775bDofD50hNTfWeb2hoUG5urrp06aKoqChlZ2erurra7+9GIgEAgMUMjyMgh79+9rOfaffu3d5j8+bN3nN5eXlas2aNli9frtLSUu3atUtZWVl+P4M5EgAAWMwwgvPcsLAwJSUlNRs/cOCAFi9erOLiYg0fPlySVFRUpL59+6q8vFyDBw9u9TOoSAAAcIJwu92qra31Odxu91Gv/+yzz5ScnKxTTz1V1113naqqqiRJFRUVampqUmZmpvfa1NRUpaSkqKyszK+YSCQAALBYoFobhYWFiomJ8TkKCwtbfGZ6erqWLFmidevWacGCBdqxY4cuuugiHTx4UC6XSxEREYqNjfX5TGJiolwul1/fjdYGAAAWC9TOlgUFBcrPz/cZczqdLV47cuRI75/79++v9PR09ejRQ88//7wiIyMDEo9ERQIAgBOG0+lUdHS0z3G0ROKHYmNjdcYZZ+jzzz9XUlKSGhsbVVNT43NNdXV1i3MqjoVEAgAAixlGYI7jUVdXp23btqlbt25KS0tTeHi4SkpKvOcrKytVVVWljIwMv+5LawMAAIsF46Vd06dP1+jRo9WjRw/t2rVLM2fOVGhoqK699lrFxMRowoQJys/PV1xcnKKjozVp0iRlZGT4tWJDIpEAAMCWvvrqK1177bX65ptvFB8frwsvvFDl5eWKj4+XJM2ZM0chISHKzs6W2+3WiBEjNH/+fL+f4zCMYK1utU7Tvu3BDgFol8478/pghwC0O++53rT8GdvOHBGQ+5z24fqA3CeQqEgAAGCxn/zbP1evXt3qG1555ZWmgwEAACeWViUSY8eObdXNHA6Hjhw5cjzxAABgOx4bv0a8VYmEx2PjmgwAABYzfuqJBAAAMC8Yyz/biqlEor6+XqWlpaqqqlJjY6PPucmTJwckMAAA0P75nUi89957uuKKK3To0CHV19crLi5O+/btU4cOHZSQkEAiAQDAD9hvo4X/8nuL7Ly8PI0ePVr79+9XZGSkysvL9eWXXyotLU0PPvigFTECAHBCC9TbP9sjvxOJrVu3atq0aQoJCVFoaKjcbre6d++uBx54QL///e+tiBEAALRTficS4eHhCgn57mMJCQmqqqqSJMXExGjnzp2BjQ4AABvwGI6AHO2R33MkBg4cqC1btuj000/X0KFDddddd2nfvn166qmndOaZZ1oRIwAAJzQ7L//0uyIxa9YsdevWTZJ03333qXPnzpo4caL27t2rxx9/POABAgCA9svvisSgQYO8f05ISNC6desCGhAAAHZj51UbbEgFAIDF2uv8hkDwO5Ho1auXHI6j/0K2b+cV3gAA/FT4nUhMnTrV5+empia99957WrdunW677bZAxQUAgG3YebKl34nElClTWhyfN2+e3nnnneMOCAAAu7HzHAm/V20czciRI/Xiiy8G6nYAANiGnfeRCFgi8cILLyguLi5QtwMAACcAUxtSfX+ypWEYcrlc2rt3r+bPnx/Q4MyKTL4o2CEA7dLzcUODHQLwk8Qcie8ZM2aMTyIREhKi+Ph4XXzxxUpNTQ1ocAAA2EF7bUsEgt+JxN13321BGAAA4ETk9xyJ0NBQ7dmzp9n4N998o9DQ0IAEBQCAnRgBOtojvysSxlHWsLjdbkVERBx3QAAA2A2tDUlz586VJDkcDj3xxBOKiorynjty5Ig2bdrEHAkAAH5iWp1IzJkzR9J3FYmFCxf6tDEiIiLUs2dPLVy4MPARAgBwgmPVhqQdO3ZIkoYNG6YVK1aoc+fOlgUFAICdeIIdgIX8niPx+uuvWxEHAAA4Afm9aiM7O1v3339/s/EHHnhAV199dUCCAgDATgw5AnK0R34nEps2bdIVV1zRbHzkyJHatGlTQIICAMBOPEZgjvbI79ZGXV1di8s8w8PDVVtbG5CgAACwE087rSYEgt8VibPOOkvLli1rNv7cc8+pX79+AQkKAACcGPyuSNx5553KysrStm3bNHz4cElSSUmJiouL9cILLwQ8QAAATnTtdX5DIPidSIwePVqrVq3SrFmz9MILLygyMlIDBgzQa6+9xmvEAQBoAcs/f2DUqFEaNWqUJKm2tlbPPvuspk+froqKCh05ciSgAQIAgPbL7zkS/7Fp0ybl5OQoOTlZDz30kIYPH67y8vJAxgYAgC3YefmnXxUJl8ulJUuWaPHixaqtrdU111wjt9utVatWMdESAICjsHNro9UVidGjR6tPnz7617/+pYcffli7du3SX//6VytjAwAA7VyrKxKvvPKKJk+erIkTJ+r000+3MiYAAGyFioSkzZs36+DBg0pLS1N6eroeffRR7du3z8rYAACwBTvPkWh1IjF48GAtWrRIu3fv1u9+9zs999xzSk5Olsfj0YYNG3Tw4EEr4wQAAO2Q36s2OnbsqPHjx2vz5s364IMPNG3aNM2ePVsJCQm68sorrYgRAIATmscRmKM9Mr38U5L69OmjBx54QF999ZWeffbZQMUEAICteOQIyNEemdqQ6odCQ0M1duxYjR07NhC3AwDAVtrpizsD4rgqEgAA4KctIBUJAABwdHZe/kkiAQCAxTyO9jm/IRBobQAAANNIJAAAsJgRoON4zJ49Ww6HQ1OnTvWONTQ0KDc3V126dFFUVJSys7NVXV3t131JJAAAsJgnQIdZW7Zs0WOPPab+/fv7jOfl5WnNmjVavny5SktLtWvXLmVlZfl1bxIJAABOEG63W7W1tT6H2+0+5mfq6up03XXXadGiRercubN3/MCBA1q8eLH+8pe/aPjw4UpLS1NRUZH++c9/qry8vNUxkUgAAGCxQO1sWVhYqJiYGJ+jsLDwmM/Ozc3VqFGjlJmZ6TNeUVGhpqYmn/HU1FSlpKSorKys1d+NVRsAAFgsULtSFhQUKD8/32fM6XQe9frnnntO7777rrZs2dLsnMvlUkREhGJjY33GExMT5XK5Wh0TiQQAACcIp9N5zMTh+3bu3KkpU6Zow4YNOumkkyyLidYGAAAWC8aqjYqKCu3Zs0fnnHOOwsLCFBYWptLSUs2dO1dhYWFKTExUY2OjampqfD5XXV2tpKSkVj+HigQAABYLxps7L7nkEn3wwQc+YzfeeKNSU1M1Y8YMde/eXeHh4SopKVF2drYkqbKyUlVVVcrIyGj1c0gkAACwWDC2yO7UqZPOPPNMn7GOHTuqS5cu3vEJEyYoPz9fcXFxio6O1qRJk5SRkaHBgwe3+jkkEgAA/ETNmTNHISEhys7Oltvt1ogRIzR//ny/7uEwDMN2bzcNizg52CEA7dLzcUODHQLQ7mS5ii1/RtHJvw7IfW78+umA3CeQqEgAAGCxYMyRaCus2gAAAKZRkQAAwGLBmGzZVkgkAACwmJ0TCVobAADANCoSAABYzLDxZEsSCQAALEZrAwAAoAVUJAAAsJidKxIkEgAAWMx2W0h/D4kEAAAWY2dLAACAFlCRAADAYsyRAAAAptk5kaC1AQAATKMiAQCAxVi1AQAATGPVBgAAQAuoSAAAYDE7T7YkkQAAwGJ2niNBawMAAJhGRQIAAIt5bFyTIJEAAMBizJEAAACm2bcewRwJAABwHKhIAABgMVobAADANHa2BAAAaAEVCQAALMbyTwAAYJp90whaGwAA4DhQkQAAwGKs2gAAAKbZeY4ErQ0AAGAaFQkAACxm33oEiQQAAJZjjgQAADCNORIAAAAtoCIBAIDF7FuPIJEAAMBydp4jQWsDAACYRkUCAACLGTZubpBIAABgMVobAAAALaAiAQCAxey8jwSJBAAAFrNvGkFrAwAAHAcSCRy3iy5M16qVS1T1RYUON36tK68ccdRr5z06W4cbv9bkSTe1YYRA8J1x62hluYrV/57rvWM9fz1cF634X43+7AlluYoVHt0hiBHCSh4ZATn8sWDBAvXv31/R0dGKjo5WRkaGXnnlFe/5hoYG5ebmqkuXLoqKilJ2draqq6v9/m4kEjhuHTt20L/+9bEmTfnDMa8bM+Zypaefo6+/3t1GkQHtQ+ezT1WvGy5RzUdf+oyHRkao+rX3VfnI34MUGdqKJ0CHP0455RTNnj1bFRUVeueddzR8+HCNGTNGH330kSQpLy9Pa9as0fLly1VaWqpdu3YpKyvL7+/GHAkct3XrX9e69a8f85rk5CQ9MudPuuLnv9LqVX9ro8iA4Avt4NSgebl6d9oTSs0b63Nu26J1kqSu5/cNQmRoS8HYR2L06NE+P993331asGCBysvLdcopp2jx4sUqLi7W8OHDJUlFRUXq27evysvLNXjw4FY/h4oELOdwOLS0aK4e+ssCffzxp8EOB2hTZ8++Ua5X39PeNz4MdiiwAbfbrdraWp/D7Xb/6OeOHDmi5557TvX19crIyFBFRYWampqUmZnpvSY1NVUpKSkqKyvzK6YTPpFo6ZdqGHaeH3viuf22XB0+fFh/fXRxsEMB2tQpYzIUe1ZPfTRrWbBDQZAFqrVRWFiomJgYn6OwsPCoz/3ggw8UFRUlp9Opm2++WStXrlS/fv3kcrkUERGh2NhYn+sTExPlcrn8+m7tOpHYuXOnxo8ff8xrWvqlGp6DbRQhfsw5A8/SpFsnaPxNecEOBWhTkclx6v+nG7TllnnyuJuCHQ6CzAjQfwUFBTpw4IDPUVBQcNTn9unTR1u3btVbb72liRMnKicnRx9//HFAv1u7niPx7bffaunSpXryySePek1BQYHy8/N9xjp3SbU6NLTShRemKyGhq3Zse9s7FhYWpj8/cJcmT7pJvc9ofR8OOJHE9j9VJ8XHaPiGWd6xkLBQdR2cqlPHX6ZVKTdIHqqn8I/T6ZTT6Wz19REREerdu7ckKS0tTVu2bNEjjzyi//mf/1FjY6Nqamp8qhLV1dVKSkryK6agJhKrV68+5vnt27f/6D1a+qU6HI7jiguB8/QzL6rktTd8xl5e+4yeKX5RS5Y+H6SoAOvtfeNDvXrx7T5jaQ//Tgc/26VP560hifiJaS/v2vB4PHK73UpLS1N4eLhKSkqUnZ0tSaqsrFRVVZUyMjL8umdQE4mxY8fK4XAcc04DSUH717FjB/Xu3cv7c6+eKRow4Gf69tv92rlzl779dr/P9U1Nh+Vy7dWnn25r61CBNnO4vkG1n3zlO3bIrcb9dd5xZ3yMTkqIVVTPRElSdN/uOlzXoENf71NTTX2bxwzreIIwd6+goEAjR45USkqKDh48qOLiYm3cuFHr169XTEyMJkyYoPz8fMXFxSk6OlqTJk1SRkaGXys2pCAnEt26ddP8+fM1ZsyYFs9v3bpVaWlpbRwV/DUobYBKXn3B+/NDD94tSVr6t+c1gbkRwFGdmpOpvtOzvT8P/ftMSdI7UxaqatmmYIUFm9izZ49uuOEG7d69WzExMerfv7/Wr1+vSy+9VJI0Z84chYSEKDs7W263WyNGjND8+fP9fo7DCOIShyuvvFJnn3227rnnnhbPv//++xo4cKA8Hv+KQmERJwciPMB2no8bGuwQgHYny1Vs+TN+3cP/jZ5a8vSXKwJyn0AKakXitttuU3390ct3vXv31uuvH3ujIwAA2jve/mmRiy666JjnO3bsqKFD+T8oAADaq3a9/BMAADsIxhbZbYVEAgAAi7WX5Z9WIJEAAMBidp4j0a63yAYAAO0bFQkAACzGHAkAAGCanedI0NoAAACmUZEAAMBiQdxE2nIkEgAAWIxVGwAAAC2gIgEAgMXsPNmSRAIAAIvZefknrQ0AAGAaFQkAACxm58mWJBIAAFiM5Z8AAMA0O0+2ZI4EAAAwjYoEAAAWs/OqDRIJAAAsZufJlrQ2AACAaVQkAACwGKs2AACAabQ2AAAAWkBFAgAAi7FqAwAAmOax8RwJWhsAAMA0KhIAAFjMvvUIEgkAACxn51UbJBIAAFjMzokEcyQAAIBpVCQAALAYO1sCAADTaG0AAAC0gIoEAAAWY2dLAABgmp3nSNDaAAAAplGRAADAYnaebEkiAQCAxWhtAAAAtICKBAAAFqO1AQAATGP5JwAAMM3DHAkAAIDmqEgAAGAxWhsAAMA0WhsAAAAtIJEAAMBiRoD+80dhYaHOPfdcderUSQkJCRo7dqwqKyt9rmloaFBubq66dOmiqKgoZWdnq7q62q/nkEgAAGAxj2EE5PBHaWmpcnNzVV5erg0bNqipqUmXXXaZ6uvrvdfk5eVpzZo1Wr58uUpLS7Vr1y5lZWX59RyHYcN9O8MiTg52CEC79Hzc0GCHALQ7Wa5iy59xRvyggNzn073vmP7s3r17lZCQoNLSUg0ZMkQHDhxQfHy8iouLddVVV0mSPvnkE/Xt21dlZWUaPHhwq+5LRQIAAIsFqrXhdrtVW1vrc7jd7lbFcODAAUlSXFycJKmiokJNTU3KzMz0XpOamqqUlBSVlZW1+ruRSAAAYLFAtTYKCwsVExPjcxQWFv748z0eTZ06VRdccIHOPPNMSZLL5VJERIRiY2N9rk1MTJTL5Wr1d2P5JwAAJ4iCggLl5+f7jDmdzh/9XG5urj788ENt3rw54DGRSAAAYLFAbUjldDpblTh836233qq1a9dq06ZNOuWUU7zjSUlJamxsVE1NjU9Vorq6WklJSa2+P60NAAAsZhiegBz+PdPQrbfeqpUrV+q1115Tr169fM6npaUpPDxcJSUl3rHKykpVVVUpIyOj1c+hIgEAgMWC8Rrx3NxcFRcX6+9//7s6derknfcQExOjyMhIxcTEaMKECcrPz1dcXJyio6M1adIkZWRktHrFhkQiAQCALS1YsECSdPHFF/uMFxUVady4cZKkOXPmKCQkRNnZ2XK73RoxYoTmz5/v13PYRwL4CWEfCaC5tthHIiXurIDcp+rbDwJyn0CiIgEAgMWC0dpoK0y2BAAAplGRAADAYjacReBFIgEAgMX8feHWiYTWBgAAMI2KBAAAFgvUzpbtEYkEAAAWs/McCVobAADANCoSAABYzM77SJBIAABgMTu3NkgkAACwGMs/AQAAWkBFAgAAi9HaAAAAptl5siWtDQAAYBoVCQAALEZrAwAAmMaqDQAAgBZQkQAAwGK8tAsAAJhGawMAAKAFVCQAALAYqzYAAIBpzJEAAACm2bkiwRwJAABgGhUJAAAsZueKBIkEAAAWs28aQWsDAAAcB4dh53oLgsrtdquwsFAFBQVyOp3BDgdoN/i7ATshkYBlamtrFRMTowMHDig6OjrY4QDtBn83YCe0NgAAgGkkEgAAwDQSCQAAYBqJBCzjdDo1c+ZMJpMBP8DfDdgJky0BAIBpVCQAAIBpJBIAAMA0EgkAAGAaiQQAADCNRAKWmTdvnnr27KmTTjpJ6enpevvtt4MdEhBUmzZt0ujRo5WcnCyHw6FVq1YFOyTguJFIwBLLli1Tfn6+Zs6cqXfffVcDBgzQiBEjtGfPnmCHBgRNfX29BgwYoHnz5gU7FCBgWP4JS6Snp+vcc8/Vo48+KknyeDzq3r27Jk2apDvuuCPI0QHB53A4tHLlSo0dOzbYoQDHhYoEAq6xsVEVFRXKzMz0joWEhCgzM1NlZWVBjAwAEGgkEgi4ffv26ciRI0pMTPQZT0xMlMvlClJUAAArkEgAAADTSCQQcF27dlVoaKiqq6t9xqurq5WUlBSkqAAAViCRQMBFREQoLS1NJSUl3jGPx6OSkhJlZGQEMTIAQKCFBTsA2FN+fr5ycnI0aNAgnXfeeXr44YdVX1+vG2+8MdihAUFTV1enzz//3Pvzjh07tHXrVsXFxSklJSWIkQHmsfwTlnn00Uf15z//WS6XS2effbbmzp2r9PT0YIcFBM3GjRs1bNiwZuM5OTlasmRJ2wcEBACJBAAAMI05EgAAwDQSCQAAYBqJBAAAMI1EAgAAmEYiAQAATCORAAAAppFIAAAA00gkAACAaSQSgA2NGzdOY8eO9f588cUXa+rUqW0ex8aNG+VwOFRTU9PmzwbQNkgkgDY0btw4ORwOORwORUREqHfv3rrnnnt0+PBhS5+7YsUK3Xvvva26ln/8AfiDl3YBbezyyy9XUVGR3G63Xn75ZeXm5io8PFwFBQU+1zU2NioiIiIgz4yLiwvIfQDgh6hIAG3M6XQqKSlJPXr00MSJE5WZmanVq1d72xH33XefkpOT1adPH0nSzp07dc011yg2NlZxcXEaM2aMvvjiC+/9jhw5ovz8fMXGxqpLly66/fbb9cNX6PywteF2uzVjxgx1795dTqdTvXv31uLFi/XFF194XyrVuXNnORwOjRs3TtJ3r4IvLCxUr169FBkZqQEDBuiFF17wec7LL7+sM844Q5GRkRo2bJhPnADsiUQCCLLIyEg1NjZKkkpKSlRZWakNGzZo7dq1ampq0ogRI9SpUye98cYbevPNNxUVFaXLL7/c+5mHHnpIS5Ys0ZNPPqnNmzfr22+/1cqVK4/5zBtuuEHPPvus5s6dq3//+9967LHHFBUVpe7du+vFF1+UJFVWVmr37t165JFHJEmFhYX629/+poULF+qjjz5SXl6efv3rX6u0tFTSdwlPVlaWRo8era1bt+qmm27SHXfcYdWvDUB7YQBoMzk5OcaYMWMMwzAMj8djbNiwwXA6ncb06dONnJwcIzEx0XC73d7rn3rqKaNPnz6Gx+PxjrndbiMyMtJYv369YRiG0a1bN+OBBx7wnm9qajJOOeUU73MMwzCGDh1qTJkyxTAMw6isrDQkGRs2bGgxxtdff92QZOzfv9871tDQYHTo0MH45z//6XPthAkTjGuvvdYwDMMoKCgw+vXr53N+xowZze4FwF6YIwG0sbVr1yoqKkpNTU3yeDz61a9+pbvvvlu5ubk666yzfOZFvP/++/r888/VqVMnn3s0NDRo27ZtOnDggHbv3q309HTvubCwMA0aNKhZe+M/tm7dqtDQUA0dOrTVMX/++ec6dOiQLr30Up/xxsZGDRw4UJL073//2ycOScrIyGj1MwCcmEgkgDY2bNgwLViwQBEREUpOTlZY2H//Gnbs2NHn2rq6OqWlpemZZ55pdp/4+HhTz4+MjPT7M3V1dZKkl156SSeffLLPOafTaSoOAPZAIgG0sY4dO6p3796tuvacc87RsmXLlJCQoOjo6Bav6datm9566y0NGTJEknT48GFVVFTonHPOafH6s846Sx6PR6WlpcrMzGx2/j8VkSNHjnjH+vXrJ6fTqaqqqqNWMvr27avVq1f7jJWXl//4lwRwQmOyJdCOXXfdderatavGjBmjN954Qzt27NDGjRs1efJkffXVV5KkKVOmaPbs2Vq1apU++eQT3XLLLcfcA6Jnz57KycnR+PHjtWrVKu89n3/+eUlSjx495HA4tHbtWu3du1d1dXXq1KmTpk+frry8PC1dulTbtm3Tu+++q7/+9a9aunSpJOnmm2/WZ599pttuu02VlZUqLi7WkiVLrP4VAQgyEgmgHevQoYM2bdqklJQUZWVlqW/fvpowYYIaGhq8FYpp06bp+uuvV05OjjIyMtSpUyf94he/OOZ9FyxYoKuuukq33HKLUlNT9Zvf/Eb19fWSpJNPPll//OMfdccddygxMVG33nqrJOnee+/VnXfeqcLCQvXt21eXX365XnrpJfXq1UuSlJKSohdffFGrVq3SgAEDtHDhQs2aNcvC3w6A9sBhHG1GFgAAwI+gIgEAAEwjkQAAAKaRSAAAANNIJAAAgGkkEgAAwDQSCQAAYBqJBAAAMI1EAgAAmEYiAQAATCORAAAAppFIAAAA0/4fi2gI5qGPyoIAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " 0 0.846 0.778 0.811 99\n", " 1 0.651 0.745 0.695 55\n", "\n", " accuracy 0.766 154\n", " macro avg 0.748 0.762 0.753 154\n", "weighted avg 0.776 0.766 0.769 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_prediction, 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": { "trusted": false }, "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": { "trusted": false }, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.6" } }, "nbformat": 4, "nbformat_minor": 5 }