654 lines
121 KiB
Plaintext
654 lines
121 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"In this worked example, we seek to apply the k-NN algorithm to a dataset called beers.\n",
|
|
"\n",
|
|
"The dataset has already been split into two different sets: one for training (beer_training.csv) and one for testing (beer_test.csv)\n",
|
|
"\n",
|
|
"The dependent variable that we are trying to predict is style, which can be one of 3 classes: ale, lager or stout.\n",
|
|
"\n",
|
|
"In this example we will see the importance of maintaining separate training and test data, as well as how to tune the hyperparameters of a machine learning model."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 15,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
" calorific_value nitrogen turbidity style alcohol sugars bitterness \\\n",
|
|
"0 45.305310 0.459548 1.917273 ale 4.227692 16.67 12.568947 \n",
|
|
"1 43.889381 0.548977 3.186364 ale 4.289231 16.73 14.974000 \n",
|
|
"2 41.588496 0.542847 1.568182 ale 4.344615 16.48 11.848789 \n",
|
|
"3 44.553097 0.480301 1.871818 ale 4.424615 18.59 13.879632 \n",
|
|
"4 41.013274 0.441860 2.345455 ale 4.264615 16.35 12.186053 \n",
|
|
"\n",
|
|
" beer_id colour degree_of_fermentation \n",
|
|
"0 167 11.04 62.178571 \n",
|
|
"1 128 13.44 63.032857 \n",
|
|
"2 88 14.04 63.468571 \n",
|
|
"3 147 12.48 63.531429 \n",
|
|
"4 74 12.12 63.747143 \n",
|
|
"(124, 10)\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"import pandas as pd\n",
|
|
"\n",
|
|
"# details for iris dataset - this is a very simple dataset that is easy to get good results on\n",
|
|
"# training_file = \"iris_training.csv\"\n",
|
|
"# test_file = \"iris_test.csv\"\n",
|
|
"# independent_cols = [\"sepal_length\",\"sepal_width\",\"petal_length\",\"petal_width\"]\n",
|
|
"# dependent_col = \"class\"\n",
|
|
"\n",
|
|
"# details for beer dataset\n",
|
|
"training_file = \"beer_training.csv\"\n",
|
|
"test_file = \"beer_test.csv\"\n",
|
|
"independent_cols = [\"calorific_value\", \"nitrogen\", \"turbidity\", \"alcohol\", \"sugars\", \"bitterness\", \"beer_id\", \n",
|
|
" \"colour\", \"degree_of_fermentation\"]\n",
|
|
"dependent_col = \"style\"\n",
|
|
"\n",
|
|
"# Here we load our training dataset in from the training file using the pandas library\n",
|
|
"df_training = pd.read_csv(training_file)\n",
|
|
"print(df_training.head())\n",
|
|
"print(df_training.shape)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 16,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
" calorific_value nitrogen turbidity alcohol sugars bitterness \\\n",
|
|
"0 45.305310 0.459548 1.917273 4.227692 16.67 12.568947 \n",
|
|
"1 43.889381 0.548977 3.186364 4.289231 16.73 14.974000 \n",
|
|
"2 41.588496 0.542847 1.568182 4.344615 16.48 11.848789 \n",
|
|
"3 44.553097 0.480301 1.871818 4.424615 18.59 13.879632 \n",
|
|
"4 41.013274 0.441860 2.345455 4.264615 16.35 12.186053 \n",
|
|
"\n",
|
|
" beer_id colour degree_of_fermentation \n",
|
|
"0 167 11.04 62.178571 \n",
|
|
"1 128 13.44 63.032857 \n",
|
|
"2 88 14.04 63.468571 \n",
|
|
"3 147 12.48 63.531429 \n",
|
|
"4 74 12.12 63.747143 \n",
|
|
"(124, 9)\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# set up a matrix X containing the independent variables from the training data\n",
|
|
"X_training = df_training.loc[:,independent_cols]\n",
|
|
"print(X_training.head())\n",
|
|
"print(X_training.shape)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 17,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"0 ale\n",
|
|
"1 ale\n",
|
|
"2 ale\n",
|
|
"3 ale\n",
|
|
"4 ale\n",
|
|
"Name: style, dtype: object\n",
|
|
"(124,)\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# Set up a vector y containing the dependent variable / target attribute for the training data\n",
|
|
"y_training = df_training.loc[:,dependent_col]\n",
|
|
"print(y_training.head())\n",
|
|
"print(y_training.shape)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 18,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
" calorific_value nitrogen turbidity style alcohol sugars bitterness \\\n",
|
|
"0 41.721239 0.503276 2.628182 ale 4.015385 16.73 10.452789 \n",
|
|
"1 42.429204 0.525512 1.776364 ale 4.092308 16.72 10.999526 \n",
|
|
"2 45.880531 0.443233 2.628182 ale 4.276923 16.68 13.456368 \n",
|
|
"3 45.305310 0.471668 1.806364 ale 4.126154 18.84 9.202737 \n",
|
|
"4 38.977876 0.392846 2.272727 ale 4.015385 16.77 9.457895 \n",
|
|
"\n",
|
|
" beer_id colour degree_of_fermentation \n",
|
|
"0 93 13.44 55.337143 \n",
|
|
"1 103 12.24 58.380000 \n",
|
|
"2 178 10.92 58.382857 \n",
|
|
"3 166 10.92 58.525714 \n",
|
|
"4 44 10.56 58.900000 \n",
|
|
"(30, 10)\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# Next we load our test dataset in from the file iris_test.csv\n",
|
|
"df_test = pd.read_csv(test_file)\n",
|
|
"print(df_test.head())\n",
|
|
"print(df_test.shape)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 19,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
" calorific_value nitrogen turbidity alcohol sugars bitterness \\\n",
|
|
"0 41.721239 0.503276 2.628182 4.015385 16.73 10.452789 \n",
|
|
"1 42.429204 0.525512 1.776364 4.092308 16.72 10.999526 \n",
|
|
"2 45.880531 0.443233 2.628182 4.276923 16.68 13.456368 \n",
|
|
"3 45.305310 0.471668 1.806364 4.126154 18.84 9.202737 \n",
|
|
"4 38.977876 0.392846 2.272727 4.015385 16.77 9.457895 \n",
|
|
"\n",
|
|
" beer_id colour degree_of_fermentation \n",
|
|
"0 93 13.44 55.337143 \n",
|
|
"1 103 12.24 58.380000 \n",
|
|
"2 178 10.92 58.382857 \n",
|
|
"3 166 10.92 58.525714 \n",
|
|
"4 44 10.56 58.900000 \n",
|
|
"(30, 9)\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# set up a matrix X containing the independent variables from the test data\n",
|
|
"X_test = df_test.loc[:,independent_cols]\n",
|
|
"print(X_test.head())\n",
|
|
"print(X_test.shape)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 20,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"0 ale\n",
|
|
"1 ale\n",
|
|
"2 ale\n",
|
|
"3 ale\n",
|
|
"4 ale\n",
|
|
"Name: style, dtype: object\n",
|
|
"(30,)\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# Set up a vector y containing the dependent variable / target attribute for the training data\n",
|
|
"y_test = df_test.loc[:,dependent_col]\n",
|
|
"print(y_test.head())\n",
|
|
"print(y_test.shape)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"To explote the effect of hyperparameters on a simple machine learning model, let's experiment with the built-in k-NN implementation in scikit-learn.\n",
|
|
"\n",
|
|
"https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html\n",
|
|
"\n",
|
|
"First we'll create a model using the default settings"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 21,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Accuracy on training data: 0.7580645161290323\n",
|
|
"Accuracy on test data: 0.4\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"from sklearn import neighbors, metrics\n",
|
|
"\n",
|
|
"# create a model using the default settings for k-NN, n_neighbors=5, weights=uniform, p=2 (Euclidean distance)\n",
|
|
"model = neighbors.KNeighborsClassifier()\n",
|
|
"model.fit(X_training, y_training)\n",
|
|
"\n",
|
|
"# compute the predictions for the training and test sets\n",
|
|
"predictions_training = model.predict(X_training)\n",
|
|
"predictions_test = model.predict(X_test)\n",
|
|
"\n",
|
|
"# compute the accuracy on the training and test set predictions\n",
|
|
"accuracy_training = metrics.accuracy_score(y_training, predictions_training)\n",
|
|
"accuracy_test = metrics.accuracy_score(y_test, predictions_test)\n",
|
|
"print(\"Accuracy on training data:\",accuracy_training)\n",
|
|
"print(\"Accuracy on test data:\",accuracy_test)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 22,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29]\n",
|
|
"[1.0, 0.8306451612903226, 0.7580645161290323, 0.6854838709677419, 0.6370967741935484, 0.6048387096774194, 0.5806451612903226, 0.5967741935483871, 0.5645161290322581, 0.5241935483870968, 0.5161290322580645, 0.46774193548387094, 0.46774193548387094, 0.46774193548387094, 0.43548387096774194]\n",
|
|
"[0.5666666666666667, 0.4666666666666667, 0.4, 0.4, 0.4, 0.43333333333333335, 0.4, 0.3333333333333333, 0.43333333333333335, 0.4, 0.4, 0.4, 0.36666666666666664, 0.3, 0.3333333333333333]\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# Now let's evaluate the effect of using different k values\n",
|
|
"# start at k=1 and test all odd k values up to 21\n",
|
|
"k_values = list(range(1,31,2))\n",
|
|
"print(k_values)\n",
|
|
"\n",
|
|
"accuracy_training_k = []\n",
|
|
"accuracy_test_k = []\n",
|
|
"for k in k_values:\n",
|
|
" model_k = neighbors.KNeighborsClassifier(k)\n",
|
|
" model_k.fit(X_training, y_training)\n",
|
|
"\n",
|
|
" # compute the predictions for the training and test sets\n",
|
|
" predictions_training_k = model_k.predict(X_training)\n",
|
|
" predictions_test_k = model_k.predict(X_test)\n",
|
|
"\n",
|
|
" # compute the accuracy on the training and test set predictions\n",
|
|
" accuracy_training_k.append(metrics.accuracy_score(y_training, predictions_training_k))\n",
|
|
" accuracy_test_k.append(metrics.accuracy_score(y_test, predictions_test_k))\n",
|
|
"\n",
|
|
"print(accuracy_training_k)\n",
|
|
"print(accuracy_test_k)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 23,
|
|
"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": [
|
|
"# let's plot the accuracy on the training and test set\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"plt.scatter(k_values,accuracy_training_k,marker=\"x\")\n",
|
|
"plt.scatter(k_values,accuracy_test_k,marker=\"+\")\n",
|
|
"plt.xlim([0, max(k_values)+2])\n",
|
|
"plt.ylim([0.0, 1.1])\n",
|
|
"plt.xlabel(\"Value of k\")\n",
|
|
"plt.ylabel(\"Accuracy\")\n",
|
|
"legend_labels = [\"Training (Euclidian dist.)\",\"Test (Euclidian dist.)\"]\n",
|
|
"plt.legend(labels=legend_labels, loc=4, borderpad=1)\n",
|
|
"plt.title(\"Effect of k on training and test set accuracy\", fontsize=10)\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 30,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"p = 1 training [1.0, 0.8306451612903226, 0.8064516129032258, 0.75, 0.75, 0.717741935483871, 0.7016129032258065, 0.6854838709677419, 0.6451612903225806, 0.6854838709677419, 0.6451612903225806, 0.5806451612903226, 0.5564516129032258, 0.5645161290322581, 0.5645161290322581] \n",
|
|
"\n",
|
|
"p = 1 test [0.7, 0.7, 0.5333333333333333, 0.43333333333333335, 0.4666666666666667, 0.4, 0.5, 0.4666666666666667, 0.4666666666666667, 0.5, 0.4666666666666667, 0.5, 0.43333333333333335, 0.5, 0.4666666666666667] \n",
|
|
"\n",
|
|
"p = 2 training [1.0, 0.8306451612903226, 0.7580645161290323, 0.6854838709677419, 0.6370967741935484, 0.6048387096774194, 0.5806451612903226, 0.5967741935483871, 0.5645161290322581, 0.5241935483870968, 0.5161290322580645, 0.46774193548387094, 0.46774193548387094, 0.46774193548387094, 0.43548387096774194] \n",
|
|
"\n",
|
|
"p = 2 test [0.5666666666666667, 0.4666666666666667, 0.4, 0.4, 0.4, 0.43333333333333335, 0.4, 0.3333333333333333, 0.43333333333333335, 0.4, 0.4, 0.4, 0.36666666666666664, 0.3, 0.3333333333333333] \n",
|
|
"\n",
|
|
"p = 3 training [1.0, 0.8064516129032258, 0.7096774193548387, 0.6774193548387096, 0.6290322580645161, 0.6129032258064516, 0.5483870967741935, 0.5403225806451613, 0.5161290322580645, 0.49193548387096775, 0.4596774193548387, 0.43548387096774194, 0.4435483870967742, 0.4435483870967742, 0.41935483870967744] \n",
|
|
"\n",
|
|
"p = 3 test [0.5333333333333333, 0.36666666666666664, 0.4, 0.3333333333333333, 0.36666666666666664, 0.4, 0.3333333333333333, 0.3333333333333333, 0.4, 0.43333333333333335, 0.4, 0.36666666666666664, 0.3333333333333333, 0.3333333333333333, 0.3333333333333333] \n",
|
|
"\n",
|
|
"p = 4 training [1.0, 0.7983870967741935, 0.6774193548387096, 0.6532258064516129, 0.6370967741935484, 0.5887096774193549, 0.5403225806451613, 0.5080645161290323, 0.5080645161290323, 0.47580645161290325, 0.45161290322580644, 0.41935483870967744, 0.4435483870967742, 0.41935483870967744, 0.4274193548387097] \n",
|
|
"\n",
|
|
"p = 4 test [0.5333333333333333, 0.3333333333333333, 0.43333333333333335, 0.3, 0.3, 0.4, 0.3333333333333333, 0.36666666666666664, 0.4, 0.4, 0.4, 0.3333333333333333, 0.3, 0.3333333333333333, 0.3] \n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# Now let's explore the impact of using a different distance metric by changing the value of p used in the Minkowski formula\n",
|
|
"p_values = list(range(1,5))\n",
|
|
"# print(p_values)\n",
|
|
"\n",
|
|
"accuracy_training_k_p = []\n",
|
|
"accuracy_test_k_p = []\n",
|
|
"for j in range(len(p_values)):\n",
|
|
" accuracy_training_k_p.append([])\n",
|
|
" accuracy_test_k_p.append([]) \n",
|
|
"\n",
|
|
" for k in k_values:\n",
|
|
" model_k_p = neighbors.KNeighborsClassifier(n_neighbors=k, p=p_values[j])\n",
|
|
" model_k_p.fit(X_training, y_training)\n",
|
|
"\n",
|
|
" # compute the predictions for the training and test sets\n",
|
|
" predictions_training_k_p = model_k_p.predict(X_training)\n",
|
|
" predictions_test_k_p = model_k_p.predict(X_test)\n",
|
|
"\n",
|
|
" # compute the accuracy on the training and test set predictions\n",
|
|
" accuracy_training_k_p[j].append(metrics.accuracy_score(y_training, predictions_training_k_p))\n",
|
|
" accuracy_test_k_p[j].append(metrics.accuracy_score(y_test, predictions_test_k_p))\n",
|
|
"\n",
|
|
" print(\"p =\",p_values[j],\"training\",accuracy_training_k_p[j],\"\\n\")\n",
|
|
" print(\"p =\",p_values[j],\"test\",accuracy_test_k_p[j],\"\\n\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 32,
|
|
"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"
|
|
},
|
|
{
|
|
"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": [
|
|
"# let's plot the accuracy on the training set\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"plt.scatter(k_values,accuracy_training_k_p[0],marker=\"x\")\n",
|
|
"plt.scatter(k_values,accuracy_training_k_p[1],marker=\"x\")\n",
|
|
"plt.scatter(k_values,accuracy_training_k_p[2],marker=\"*\")\n",
|
|
"plt.scatter(k_values,accuracy_training_k_p[3],marker=\"s\")\n",
|
|
"plt.xlim([0, max(k_values)+2])\n",
|
|
"plt.ylim([0.0, 1.1])\n",
|
|
"plt.xlabel(\"Value of k\")\n",
|
|
"plt.ylabel(\"Accuracy\")\n",
|
|
"legend_labels = [\"Training (Manhattan, p=1)\",\"Training (Euclidian, p=2)\",\"Training (p=3)\",\"Training (p=4)\"]\n",
|
|
"plt.legend(labels=legend_labels, loc=1, borderpad=0.2)\n",
|
|
"plt.title(\"Effect of k and p on training set accuracy\", fontsize=10)\n",
|
|
"plt.show()\n",
|
|
"\n",
|
|
"# let's plot the accuracy on the test set\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"plt.scatter(k_values,accuracy_test_k_p[0],marker=\"x\")\n",
|
|
"plt.scatter(k_values,accuracy_test_k_p[1],marker=\"+\")\n",
|
|
"plt.scatter(k_values,accuracy_test_k_p[2],marker=\"*\")\n",
|
|
"plt.scatter(k_values,accuracy_test_k_p[3],marker=\"s\")\n",
|
|
"plt.xlim([0, max(k_values)+2])\n",
|
|
"plt.ylim([0.0, 1.1])\n",
|
|
"plt.xlabel(\"Value of k\")\n",
|
|
"plt.ylabel(\"Accuracy\")\n",
|
|
"legend_labels = [\"Test (Manhattan, p=1)\",\"Test (Euclidian, p=2)\",\"Training (p=3)\",\"Training (p=4)\"]\n",
|
|
"plt.legend(labels=legend_labels, loc=1, borderpad=0.2)\n",
|
|
"plt.title(\"Effect of k and p on test set accuracy\", fontsize=10)\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 33,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"w = uniform ,p = 1 training [1.0, 0.8306451612903226, 0.8064516129032258, 0.75, 0.75, 0.717741935483871, 0.7016129032258065, 0.6854838709677419, 0.6451612903225806, 0.6854838709677419, 0.6451612903225806, 0.5806451612903226, 0.5564516129032258, 0.5645161290322581, 0.5645161290322581] \n",
|
|
"\n",
|
|
"w = uniform ,p = 1 test [0.7, 0.7, 0.5333333333333333, 0.43333333333333335, 0.4666666666666667, 0.4, 0.5, 0.4666666666666667, 0.4666666666666667, 0.5, 0.4666666666666667, 0.5, 0.43333333333333335, 0.5, 0.4666666666666667] \n",
|
|
"\n",
|
|
"w = uniform ,p = 2 training [1.0, 0.8306451612903226, 0.7580645161290323, 0.6854838709677419, 0.6370967741935484, 0.6048387096774194, 0.5806451612903226, 0.5967741935483871, 0.5645161290322581, 0.5241935483870968, 0.5161290322580645, 0.46774193548387094, 0.46774193548387094, 0.46774193548387094, 0.43548387096774194] \n",
|
|
"\n",
|
|
"w = uniform ,p = 2 test [0.5666666666666667, 0.4666666666666667, 0.4, 0.4, 0.4, 0.43333333333333335, 0.4, 0.3333333333333333, 0.43333333333333335, 0.4, 0.4, 0.4, 0.36666666666666664, 0.3, 0.3333333333333333] \n",
|
|
"\n",
|
|
"w = uniform ,p = 3 training [1.0, 0.8064516129032258, 0.7096774193548387, 0.6774193548387096, 0.6290322580645161, 0.6129032258064516, 0.5483870967741935, 0.5403225806451613, 0.5161290322580645, 0.49193548387096775, 0.4596774193548387, 0.43548387096774194, 0.4435483870967742, 0.4435483870967742, 0.41935483870967744] \n",
|
|
"\n",
|
|
"w = uniform ,p = 3 test [0.5333333333333333, 0.36666666666666664, 0.4, 0.3333333333333333, 0.36666666666666664, 0.4, 0.3333333333333333, 0.3333333333333333, 0.4, 0.43333333333333335, 0.4, 0.36666666666666664, 0.3333333333333333, 0.3333333333333333, 0.3333333333333333] \n",
|
|
"\n",
|
|
"w = uniform ,p = 4 training [1.0, 0.7983870967741935, 0.6774193548387096, 0.6532258064516129, 0.6370967741935484, 0.5887096774193549, 0.5403225806451613, 0.5080645161290323, 0.5080645161290323, 0.47580645161290325, 0.45161290322580644, 0.41935483870967744, 0.4435483870967742, 0.41935483870967744, 0.4274193548387097] \n",
|
|
"\n",
|
|
"w = uniform ,p = 4 test [0.5333333333333333, 0.3333333333333333, 0.43333333333333335, 0.3, 0.3, 0.4, 0.3333333333333333, 0.36666666666666664, 0.4, 0.4, 0.4, 0.3333333333333333, 0.3, 0.3333333333333333, 0.3] \n",
|
|
"\n",
|
|
"w = distance ,p = 1 training [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] \n",
|
|
"\n",
|
|
"w = distance ,p = 1 test [0.7, 0.7333333333333333, 0.6333333333333333, 0.5, 0.5333333333333333, 0.43333333333333335, 0.4666666666666667, 0.4666666666666667, 0.4666666666666667, 0.5333333333333333, 0.4666666666666667, 0.43333333333333335, 0.4666666666666667, 0.5, 0.4666666666666667] \n",
|
|
"\n",
|
|
"w = distance ,p = 2 training [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] \n",
|
|
"\n",
|
|
"w = distance ,p = 2 test [0.5666666666666667, 0.5333333333333333, 0.5, 0.4666666666666667, 0.36666666666666664, 0.4, 0.4, 0.43333333333333335, 0.4, 0.43333333333333335, 0.43333333333333335, 0.4, 0.43333333333333335, 0.4, 0.36666666666666664] \n",
|
|
"\n",
|
|
"w = distance ,p = 3 training [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] \n",
|
|
"\n",
|
|
"w = distance ,p = 3 test [0.5333333333333333, 0.4666666666666667, 0.4666666666666667, 0.3333333333333333, 0.36666666666666664, 0.3333333333333333, 0.36666666666666664, 0.4, 0.4, 0.4, 0.36666666666666664, 0.4, 0.4, 0.4, 0.4] \n",
|
|
"\n",
|
|
"w = distance ,p = 4 training [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] \n",
|
|
"\n",
|
|
"w = distance ,p = 4 test [0.5333333333333333, 0.43333333333333335, 0.43333333333333335, 0.3, 0.3333333333333333, 0.36666666666666664, 0.36666666666666664, 0.4, 0.4, 0.36666666666666664, 0.36666666666666664, 0.36666666666666664, 0.36666666666666664, 0.4, 0.3333333333333333] \n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# Now let's explore the impact of using a different weighting scheme\n",
|
|
"w_values = [\"uniform\",\"distance\"]\n",
|
|
"accuracy_training_k_p_w = []\n",
|
|
"accuracy_test_k_p_w = []\n",
|
|
"\n",
|
|
"for i in range(len(w_values)):\n",
|
|
" accuracy_training_k_p_w.append([])\n",
|
|
" accuracy_test_k_p_w.append([])\n",
|
|
" \n",
|
|
" for j in range(len(p_values)):\n",
|
|
" accuracy_training_k_p_w[i].append([])\n",
|
|
" accuracy_test_k_p_w[i].append([]) \n",
|
|
"\n",
|
|
" for k in k_values:\n",
|
|
" model_k_p_w = neighbors.KNeighborsClassifier(n_neighbors=k, p=p_values[j], weights=w_values[i])\n",
|
|
" model_k_p_w.fit(X_training, y_training)\n",
|
|
"\n",
|
|
" # compute the predictions for the training and test sets\n",
|
|
" predictions_training_k_p_w = model_k_p_w.predict(X_training)\n",
|
|
" predictions_test_k_p_w = model_k_p_w.predict(X_test)\n",
|
|
"\n",
|
|
" # compute the accuracy on the training and test set predictions\n",
|
|
" accuracy_training_k_p_w[i][j].append(metrics.accuracy_score(y_training, predictions_training_k_p_w))\n",
|
|
" accuracy_test_k_p_w[i][j].append(metrics.accuracy_score(y_test, predictions_test_k_p_w))\n",
|
|
"\n",
|
|
" print(\"w =\",w_values[i],\",p =\",p_values[j],\"training\",accuracy_training_k_p_w[i][j],\"\\n\")\n",
|
|
" print(\"w =\",w_values[i],\",p =\",p_values[j],\"test\",accuracy_test_k_p_w[i][j],\"\\n\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 36,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEUCAYAAAAmxTHXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABAn0lEQVR4nO3de3wU1fn48c9DCILcbyoqEOgXuSQhCQmUiwQooigq3opStIAFFAEttiLaVhT9WqoogtL6VX+AFUQU1CJiFRVMQCwEJIKIiBDkVm5KAAEJ8Pz+2Nlxk2ySzWVINvu8X699sTuXM2dmwpw558w8R1QVY4wxkatKeWfAGGNM+bKCwBhjIpwVBMYYE+GsIDDGmAhnBYExxkQ4KwiMMSbCWUFQDkTktIisC/iMd6Z3F5EvnWk1RORJ5/eTJdjGgyVY59ci8pWILM0zvaeILCpuesXctufbKGL7WSLSqBy3HyMivynhup+GsMxLItKuJOmXhogMEZELz/Z2TfFULe8MRKjjqpoYZPog4K+qOhtAREYADVT1dAm28SDweDHX+R0wXFWXl2B7pnRigN8Ar+adISJVVfVUQSuqateiElfVYaXKXckNATYAu8tp+0UeP2M1ggpDRIYBA4BHRWSOiCwEagFrRORmEWksIgtEZLXz6easV0tEZorIehH5QkRuFJFJQA2nZjEnyLYGOstvEJG/OdMeAi4F/l9hNRAR6Sgin4vIL/JMjxGRdBFZ63y6OtN7isgyEZkvIpucfRNnXl9n2lrghgK2N0RE/uWk8Y2ITChguX+ISIZTg3okYHqWiDzi5Gm9iLRxpjcUkQ+c5V8CJEiavxaRp53v94jIVud7SxFZEWT5RBH5zDkPb4lIfWf6MhH5m4isEpHNItI9yC5MAro752yss98LReRj4CPnPH8UsB/9A7Z7NIRjvUxEUvzLi8j/ikimk9/znem/cH6vF5HH/Onm2ceaIvKus+4GEbnZmZ4sIp+IyBoReV9EmojITUAKMMfZrxp50hru/C1nOn/b5zrTz3eOX6bz8f8t/dY5tpki8oozbZaznWDHIl18/482OtPedvL3pfhusvzr9HWOa6ZzjKs4f2uNnflVRGSL/3elpKr2Ocsf4DSwLuBzszN9FnBTwHJHA76/ClzqfG8GfOV8/xvwTMBy9fOum2fbFwLfAY3x1Qg/Bq5z5i0DUoKs0xNYBHQF1gDNgixzLlDd+d4KyAhYNxu4GN+Nx0p8BU51YIezrACvA4uCpDsE2AM0BGrgu7sMlscGzr9Rzn60d35nAWOc73cBLznfpwEPOd/7AQo0ypPmBcBq5/t8YDVwETAYX80tbx6+AHo43yf6z4uTn6ec71cBHxZ0jPPs986A/aoK1HG+NwK2ABJ4rgs61nnPrbOv1zjfnwD+7HxfBAx0vt9JkL8h4EbgxYDfdYFo4FOgsTPtZmBGYX9TzryGAd8fCzhP84DfB5zPukAssNl/jgKOyyyC/J9xjsWPQIsgfyP+v6OG+P4f7PAvF7DMhIA8XA4sKO/rhpcfaxoqHwU1DRXmMqCdc4MHUEdEajnTb/FPVNUfikinI7BMVfcDiK/GkAq8XcR6bYEXgMtVNVg1Pxp4TkQS8RV0lwTMW6WqO53trcPXDHIU2Kaq3zjTZwMjCG6Jqh50lnsTX0GSkWeZAc5dXlWgCdAO34UZ4E3n3zX8XPNI9X9X1XdFJN9xU9X/OnfitYGm+ArjVKB7QJo4+aoL1FPVT5xJLwNvBCwSmIeYAvYzryWq+r1/E8DjIpIKnMFXIJ0P/DfPOsGOdd6mvpP4Lvr+/PRxvncBrnO+vwpMDpKn9cBT4qtJLlLVdBGJA+KAJc7fZxS+wrsocSLyGFAPX+33fWf6r4DfAqivWTRbRH4LvKGqB5zp3+dPLp9Vqrot4PfdInK9870pvpuQxkCaf7mAdGcA/wKeAW4HZoawvbBlBUH4qAJ0VtUTgRMDCgav7cF3F59E8PbescBeIAFfXgPz+VPA99MU/+8ub0CsXL9FpAXwR6Cjqv4gIrOcvObdfkm2/SkwFPgaSMd3UegC/KGY6ZQkDz8GfB+E76KVrKo5IpJF7n3Mu53CtpWjzq1uMfODqm4WkQ74ajaPichHwFvAl6raJdR0HLPw1UYzRWQIvrv44jqF08QtIlWAagHz3OMnIj3x3TR1UdVjIrKM4McPAFXdISJ7ReRXQCd8x7/Ssj6C8PEBMMb/w7nzBlgCjAqYXt/5miMi0UHSWQX0EJFGIhIFDAQ+CbJcXofwNaH81flPlVddYI+qngFuw3dXWJhNQIz83NcwsJBl+4hIA6eN+Togb/t8HXz/6bOd9u4ri9g2QBq+zllE5EqgfgHLpeMrZNKAz4FewE+qmh24kPP7B/m5/f82QjuufkeA2oXMrwvscwqBXkDzYqQdqs/wNf1AQC0zkPieADqmvgcangQ64CskG4tIF2eZaBGJdVYpbL9qA3ucv9PAC+1HwEgnrSintvUx8GsRaehMb+AsmwUkO9+vxVczDaYu8INTCLQBOgfsc6pzMxGYLsBLwGx8NZGSPLARNqwgKB/+jlz/Z1II69wNpDidZRvxteGCr221vtNxl4nvQgW+ZpwvJE9nsaruAcYDS4FMYI2q/iuUTKvqXuBqYLqI/DLP7L8Dg508tCH33WywtE7gawp6V3ydxfsKWXwVsABfU88CVc3VLKSqmfgu0pvwNWnk68gN4hF8F4Av8TURfVfAcun4mhHSnIvBDvI3tfgNBp4UkS+ARHz9BKH6AjjtdFiODTJ/Dr7zvx5fs8mmYqQdqt8D9zr5/x98/Q15xQOrnGanCcBjqnoSuAn4m3P+1+HrTwLfXf/zwTqLgb8A/8F3vgL35x6gl7Ova4B2qvol8L/AJ842nnaWfRHfjU0mvppaQX93/waqishX+DrmPwNwmkhHAG86acwLWMf/wEalbhaCnzubjKmQnCaDFFUdXd55qeycp3aOq6qKyC34Oo77F7VeZSW+p6ymqGqwp7wqFesjMMb4JePr8Bd8TYG3l292yo/4XvIcSSXvG/CzGoExxkQ46yMwxpgIZwWBMcZEuLDrI2jUqJHGxMSUdzaMMSasrFmz5oCqBg2TEXYFQUxMDBkZeV8qNcYYUxgR2V7QPGsaMsaYCGcFgTHGRDgrCIwxJsJZQWCMMRHOCgJjjIlwVhAYY0yEs4LAGGMinBUExhgT4awgMMaYCGcFgTHGRDgrCIwxJsJZQWCMMRHOCgJjjIlwVhAYY0yEq5QFQd7hN204TmOMKZhn4xGIyAzgamCfqsYFmS/AVOAq4BgwRFXXlna76xM6UPWn4/mmnzqnBvGZJUv+6+QUzvz4Y77pVWrWpPWako+NEE7pWl7DK13La3il61VeQ+VljWAW0LeQ+VcCrZzPCOAfpd2gqgYtBACq/nS8xDWDYCeosOmVMV3La3ila3kNr3S9ymuoPCsIVDUN+L6QRfoD/1Sfz4B6ItKkNNv0VTJKPt8YYyJRefYRXATsCPi905mWj4iMEJEMEcnYv3//WcmcMcZEirDoLFbVF1Q1RVVTGjcOOvayMcaYEirPgmAX0DTg98XOtBIrqg/Anh4yxpj8yrMgWAj8Vnw6A9mquqc0CYoIp86pEXTeqXNqlLiPoErNmsWaXhnTtbyGV7qW1/BK16u8hkq8uksWkblAT6ARsBeYAEQDqOrzzuOjz+F7sugYMFRVi3xOKiUlRTMyCl9MVXNd9PP+NsaYSCMia1Q1Jdg8z94jUNWBRcxXYJQX28570bdCwBhjChYWncXGGGO8YwWBMcZEOCsIjDEmwllBYIwxEc4KAmOMiXBWEBhjTISzgsAYYyKcFQTGGBPhrCAwxpgIZwWBMcZEOCsIjDEmwllBYIwxEc4KAmOMiXBWEBhjTISzgsAYYyKcFQTGGBPhrCAwxpgIZwWBMcZEOCsIjDEmwllBYIwxEc4KAmOMiXBWEBhjTISzgsAYYyKcFQTGGBPhrCAIkaoW+tsYY8JV1fLOQDiYsmQzh0/k8NCB+xAEHbKIiYs2Uqd6NGP7XFLe2TPGmFKxGkERVJXDJ3KYuSKL7QePoSgTF21k5oosDp/IsZqBMSbsWY2gCCLCQwfuY3CjY8Qc/RyOwhXbfsfgRtVpfvVSRKS8s2iMMaViNYIQCELzhufmmta84bllUghY34MxprxZQRACHbKIiY2e5LMzbfnsTFtuOfkXJjZ6stQX7SlLNjNx0UY3HVVfs9OUJZvLItvGGBMSKwiK4L84z1yRxQV1qvPLFg0Y2i2GmSuycl3ES5Kuv+/Bn471PRhjyoOnfQQi0heYCkQBL6nqpDzzmwEvA/WcZcar6mIv81RcIkKd6tEM7Rbj9gk85Fyk61SPLnHzkIjw0NXtAJi5IouZK7IAGNothoeubmd9D8aYs0a8uvMUkShgM9AH2AmsBgaq6saAZV4APlfVf4hIO2CxqsYUlm5KSopmZGR4kufCqGqui3Pe36VJt8UDP5d92/56lRUCxpgyJyJrVDUl2Dwvm4Y6AVtUdauqngReA/rnWUaBOs73usBuD/NTKnkvzmVVCExctDHXtNI0NxljTEl4WRBcBOwI+L3TmRboYeBWEdkJLAbGBEtIREaISIaIZOzfv9+LvJ51gX0CQ7vFsO2vV5VJ34MxxhRXeXcWDwRmqerFwFXAKyKSL0+q+oKqpqhqSuPGjc96Jr0Q2Pfg7xN46Op2DO0WU6q+B2OMKS4vO4t3AU0Dfl/sTAv0O6AvgKquFJHqQCNgn4f5qjDG9rkkV1+DvzCwQsAYczZ5WSNYDbQSkRYiUg24BViYZ5nvgN4AItIWqA5UjrafEHnR92CMMcXhWUGgqqeA0cD7wFfA66r6pYhMFJFrncX+AAwXkUxgLjBErXHcGGPOKk/fI3DeCVicZ9pDAd83At28zENYmNnP9+/Qd8s3H8aYiFTencXGI17EMLK4SMZUThZ9tDz5awLbl+f+XcqagTt+gtPx7H9UtTTjJ3iRpjGmYrAaQSXjRQwji4tkTOXmWYgJr5RXiAlPlXEfQeCF2q+0MYy8SNMYc/aUV4gJU04CA9r5lfaC7UWaxpiKwQqCimDou2X6xJAXMYwsLpIxlZcVBJWMFzGMvI6LZE8jGVO+7KmhSqagGEZQ8vETvEjTz55GMqb8WUFQCXkRw8iLNAOfRgJfn0NgzaOsxnwwxhTOCoJKyosYRmWdppejtHk1kJAxlZH1EZhy5cXTSFOWbM7Vd+FvbpqyZHOp8mpMZWUFgSlXZf00kr38ZkzxWdOQKTd5n0YK7COAktUMvGxu8uc5XJqcwimvpnxZjaAym9nv57eWKyCvRmnz6uW3cGpyCqe8mvJnBYEpV2P7XJLrIu2/iJfm0VGvXqgLlyancMqrqRisaagy8iiqqVfK8mkkL5qb/HnyssmpLIVTXk3FYDUCU6l41dzkTztc4i2FU15N+bMaQWXkv/Ov4DUBr3jx8hsU3ORUES+w4ZRXU/6sRmAqpbJ++c3reEtlKZzyaioGqxFUZhFWE/CSl/GWylo45dVUDDYwjTHF4NWz+V6kG055Nd6zgWmMKSNexHDy6pn/cMqrKV9WEBhTjsLpmf9wyqspniL7CETkGuBdVT1zFvJjKroIfRLJK+H0zH845dUUTyg1gpuBb0TkCRFp43WGjIk04fTMfzjl1YSuyIJAVW8FkoBvgVkislJERohIbc9zZyoOf9yi7ct9nwoexyichNN40OGUVxO6kPoIVPUwMB94DWgCXA+sFZExHubNmEovnJ75D6e8muIJpY/gWmAo8D/AP4FOqrpPRM4FNgLPeptFUyFE+NvKXgmnZ/7DKa+meIp8j0BEXgb+n6qmBZnXW1U/8ipzwdh7BOXMCgJPhNOz+eGUV/Ozwt4jCOXN4oeBPQGJ1QDOV9Wss10ImArAqwIgwgsYL57590o45dWEJpQ+gjeAwEdHTzvTiiQifUXkaxHZIiLjC1hmgIhsFJEvReTVUNI1xhhTdkKpEVRV1ZP+H6p6UkSqFbWSiEQB04E+wE5gtYgsVNWNAcu0Ah4AuqnqDyJyXrH3wIS3MBs7AQiPPBpTDKHUCPY7HcYAiEh/4EAI63UCtqjqVqcgeQ3on2eZ4cB0Vf0BQFX3hZZtY4wxZSWUGsGdwBwReQ4QYAfw2xDWu8hZ1m8n8Ms8y1wCICIrgCjgYVX9d96ERGQEMAKgWbNmIWzahI1wehopHGsvYcI6oMtXkQWBqn4LdBaRWs7vo2W8/VZAT+BiIE1E4lX1UJ48vAC8AL6nhspw+6Yyswt1WJiyZDOHT+S4j6T631eoUz26VGNXm9CFNB6BiPQDYoHq/lJaVScWsdouoGnA74udaYF2Av9R1Rxgm4hsxlcwrA4lX6YSCYeLdTjVXsJEYCA7INcY00O7xVjN4CwJ5YWy54FzgV7AS8BNwKoQ0l4NtBKRFvgKgFuA3+RZ5m1gIDBTRBrhayraGmrmjQnKmnDCRrgGsgun8SNCEUpncVdV/S3wg6o+AnTBadsvjKqeAkYD7wNfAa+r6pciMjGg8/l94KCIbASWAvep6sGS7IgxZ83Qd70pVCI0flO4BbLzYkyG8h7nIZSmoRPOv8dE5ELgIL54Q0VS1cXA4jzTHgr4rsC9zseYsmFNOGGloEB2ZVEYlPVdthdNWRWheSyUguAdEakHPAmsBRR40ctMGRNRIrgpK28gu8CLIJSuZuBFJ7QXTVkVoXms0KYhEakCfKSqh1R1AdAcaBN4V29MheVVE44pMwUFshvaLaZUgey8HE3Ni6as8m4eCyXo3OeqmnRWchMCCzpnKq0Iqgnk5VXna2DtAsrmLtuLdL3Ka6DSDl7/kYjcKBW158YYE/a8CGTnxV22F2MyVIRxHkLpI7gDX2fuKRE5ge/tYlXVOp7mzJhIE4E1AS950QntxZgMFWGchyKbhioaaxoyxhSlsE7osmoeCrf3CEo1HoGIpAabHmygGmNMBROh/Q5e32V71ZRV1mmGKpSmofsCvlfHF1V0DfArT3JkjDFlYGyfS3LdVfsLA+vuzC+UoHPXBP4WkabAM15lyBhTBrx+NyFMaho2mlpoQnlqKK+dQNuyzogxxpjyEUofwbP43iYGX8GRiO8NY2NMReVVmI0Ifgu6MguljyDwEZ1TwFxVXeFRfowxxpxloRQE84ETqnoafGMRi8i5qnrM26wZY0qtrO/ULaBfpRTSm8VAjYDfNYAPvcmOMcaYsy2UGkH1wOEpVfWoiJzrYZ6MMRWd1QQqlVBqBD+KSAf/DxFJBo57lyVjjDFnUyg1gt8Db4jIbnxxhi4AbvYyU8YYY86eUF4oWy0ibYDWzqSvncHmjTGm7HjVAR1u6ZaDIpuGRGQUUFNVN6jqBqCWiNzlfdaMMcacDaEMTLNOVRPzTCu3wWos+qgxlUzel9SaX+r7t7R32uGWrsdKOzBNVOCgNCISBVQrq8wZY4wpX6HUCJ7EN1bx/zmT7gC+U9U/epy3oKxGYEwlFW5t+WHWR1Cq8QiA+4ERwJ3O7y/wPTlkjDGmEgjlqaEzIvIf4BfAAKARsMDrjBljIoxXd9bhlm45KLAgEJFLgIHO5wAwD0BVe52drBljTIQpp+amwmoEm4B04GpV3QIgImPPSq6MMcacNYUVBDcAtwBLReTfwGv43iw2xhhTlsp5nIcCHx9V1bdV9RagDbAUX6iJ80TkHyJy+VnJnTHGGM+F0ln8I/Aq8KqI1Ad+je9Jog88zpsxxkSGch7noVhjFqvqD6r6gqr29ipDxhhjzq5Q3iMwxhhzNpTTI6nFqhEUl4j0FZGvRWSLiIwvZLkbRURFJOhbb8YYY7zjWUHgxCSaDlwJtAMGiki7IMvVBu4B/uNVXowxxhTMyxpBJ2CLqm5V1ZP4Hj/tH2S5R4G/ASc8zIsxxpgCeFkQXATsCPi905nmcobAbKqqhTaMicgIEckQkYz9+/eXfU6NMSaCedpHUBgRqQI8DfyhqGWdJ5VSVDWlcePG3mfOGGMiiJcFwS6gacDvi51pfrWBOGCZiGQBnYGF1mFsjDFnl5cFwWqglYi0EJFq+MJVLPTPVNVsVW2kqjGqGgN8BlyrqjbYgDHGnEWeFQSqegoYDbwPfAW8rqpfishEEbnWq+0aY4wpHk9fKFPVxcDiPNMeKmDZnl7mxRhjTHDl1llsjDGmYrCCwBhjIpwVBMYYE+GsIDDGmAhnBYExxkQ4KwiMMSbCWUFgjDERzgoCY4yJcFYQGGNMhLOhKo1ncnJy2LlzJydO2FATxpwt1atX5+KLLyY6OjrkdawgMJ7ZuXMntWvXJiYmBhEp7+wYU+mpKgcPHmTnzp20aNEi5PWsach45sSJEzRs2NAKAWPOEhGhYcOGxa6FW0FgPBVKIaCqhf4uroMHD5KYmEhiYiIXXHABF110kfv75MmTha6bkZHB3XffXeQ2unbtWqo8Bvr888/53e9+B8CsWbMQET788EN3/ttvv42IMH/+/BKlP2vWLEaPHl2sdZ555hmOHTvm/n788cdLtO1QxMTEcODAAaDo4+plPkpr4cKFTJo0CYD9+/fzy1/+kqSkJNLT08t0O+vXr2fIkCEFzi/RjZeqhtUnOTlZTXjYuHFjkcs8/cHX+vDCDXrmzBlVVT1z5ow+vHCDPv3B12WShwkTJuiTTz6Za1pOTk6ZpF1WbrrpJl23bp2qqs6cOVPj4+P1d7/7nTt/wIABmpCQoG+88UaJ0p85c6aOGjWqWOs0b95c9+/f7/6uWbNmibZdkm0Vxst8lKW5c+fmOoehOHXqVMjL9u7dW7dv317g/GD/94AMLeC6ajUCU25UlcMncpi5IouJizaiqkxctJGZK7I4fCKn1DWDQEOGDOHOO+/kl7/8JePGjWPVqlV06dKFpKQkunbtytdffw3AsmXLuPrqqwF4+OGHuf322+nZsyctW7Zk2rRpbnq1atVyl+/Zsyc33XQTbdq0YdCgQW6+Fy9eTJs2bUhOTubuu+920w105MgRvvjiCxISEtxp3bt3Z9WqVeTk5HD06FG2bNlCYmKiO3/ixIl07NiRuLg4RowY4W6vZ8+e3H///XTq1IlLLrkk153o7t276du3L61atWLcuHHu9JEjR5KSkkJsbCwTJkwAYNq0aezevZtevXrRq1cvxo8fz/Hjx0lMTGTQoEEAXHfddSQnJxMbG8sLL7yQ67j86U9/IiEhgc6dO7N37958+3zw4EEuv/xyYmNjGTZsWK7z7D+ue/bsITU1lcTEROLi4khPTw+aj2D27dtHcnIyAJmZmYgI3333HQC/+MUvctV0ChL4dwAwevRoZs2aBfhqMBMmTKBDhw7Ex8ezadMm4Oea17p16xg3bhz/+te/SExM5Pjx48ydO5f4+Hji4uK4//77c+3vH/7wBxISEli5ciW1atXivvvuIzY2lssuu4xVq1a5f38LF7rjenHNNdfw2muvFbkfISuohKioH6sRhI9QagT+GkDz+xe5n8AaQmn5awSDBw/Wfv36uXdd2dnZbs1gyZIlesMNN6iq6tKlS7Vfv37uul26dNETJ07o/v37tUGDBnry5ElV/fnOdOnSpVqnTh3dsWOHnj59Wjt37qzp6el6/Phxvfjii3Xr1q2qqnrLLbe46Qb6+OOP3W2r/nz3PnbsWH3nnXd09uzZ+vDDD+vgwYPdGsHBgwfd5W+99VZduHChqqr26NFD7733XlVVfffdd7V3795umi1atNBDhw7p8ePHtVmzZvrdd9/lSuvUqVPao0cPzczMVNWiawT+9Y4dO6axsbF64MABVVUF3Pzcd999+uijj+bb5zFjxugjjzyiqqqLFi1SwN2WfzuTJ0/Wxx57zM3b4cOHg+ajIO3atdPs7Gx99tlnNSUlRWfPnq1ZWVnauXNnVVWdPXu2JiQk5PvceOONqpr770BVddSoUTpz5kz32EybNk1VVadPn+7e+QfWvAK/79q1S5s2bar79u3TnJwc7dWrl7711lvu8Zo3b567HUAXL16sqqrXXXed9unTR0+ePKnr1q3ThIQEd7nly5fr1VdfXeD+F7dGYE8NmXIlIjx0dTtmrshypz10dTtPOph//etfExUVBUB2djaDBw/mm2++QUTIyckJuk6/fv0455xzOOecczjvvPPYu3cvF198ca5lOnXq5E5LTEwkKyuLWrVq0bJlS/fJjYEDB+a6c/bbs2cPjRs3zjf9lltuYdq0aWRnZ/PUU0/lahtfunQpTzzxBMeOHeP7778nNjaWa665BoAbbrgBgOTkZLKystx1evfuTd26dQFo164d27dvp2nTprz++uu88MILnDp1ij179rBx40bat29f5LGcNm0ab731FgA7duzgm2++oWHDhlSrVs29k05OTmbJkiX51k1LS+PNN990j2/9+vXzLdOxY0duv/12cnJyuO6663LViELRtWtXVqxYQVpaGg8++CD//ve/UVW6d+8OwKBBgwqtVRQl8Dj796Ugq1evpmfPnu55HjRoEGlpaVx33XVERUVx4403ustWq1aNvn37AhAfH88555xDdHQ08fHxuc7neeedx+7du0uc/7ysaciUK3WagwL5m4nKWs2aNd3vf/nLX+jVqxcbNmzgnXfeKfApi3POOcf9HhUVxalTp0q0TEFq1KgRdNudOnVi/fr1HDhwgEsuucSdfuLECe666y7mz5/P+vXrGT58eK71/XnJm49gedy2bRuTJ0/mo48+4osvvqBfv34hPW2ybNkyPvzwQ1auXElmZiZJSUnuetHR0W4hXtxjESg1NZW0tDQuuugihgwZwj//+c9ir5+ens727dvp378/mZmZLF++3C0I5syZ4z5AEPi56aabAKhatSpnzpxx08t7XAo6zsVVvXp19+YEch+/KlWquNupUqVKru2cOHGCGjVqlHi7eVlBYMqNvxCYuSKLod1i2PbXqxjaLSZXn4FXsrOzueiiiwDctt+y1Lp1a7Zu3erexc2bNy/ocm3btmXLli1B502aNCnfUzL+C1KjRo04evRoiZ8kAjh8+DA1a9akbt267N27l/fee8+dV7t2bY4cOeL+jo6OdmtN2dnZ1K9fn3PPPZdNmzbx2WefFWu7qampvPrqqwC89957/PDDD/mW2b59O+effz7Dhw9n2LBhrF27Nl8+8nrggQfcWkr37t2ZPXs2rVq1okqVKjRo0IDFixdz6aWXAr678nXr1uX7+I9n8+bN2bhxIz/99BOHDh3io48+KtY+BurUqROffPIJBw4c4PTp08ydO5cePXqUOD2AzZs3ExcXV6o0AlnTkCk3IkKd6tEM7RbjNgc9dHU7AOpUj/b0/YNx48YxePBgHnvsMfr161fm6deoUYO///3v9O3bl5o1a9KxY8egy7Vp04bs7GyOHDlC7dq1c8278sor8y1fr149hg8fTlxcHBdccEGB6YYiISGBpKQk2rRpQ9OmTenWrZs7b8SIEfTt25cLL7yQpUuXMmLECNq3b0+HDh2YMWMGzz//PG3btqV169Z07ty5WNudMGECAwcOJDY2lq5du9KsWbN8yyxbtownn3yS6OhoatWq5dYIAvMxZ84crrrqKl566SUuvPBC1q9fz7XXXgv4OnRVldTUVAAuvfRSdu7cGbQZKpimTZsyYMAA4uLiaNGiBUlJScXax0BNmjRh0qRJ9OrVC1WlX79+9O/fv8Tpga95sCz/bsXLuy4vpKSkaEZGRnlnw4Tgq6++om3btkUup6q5Lvp5f4ero0ePUqtWLVSVUaNG0apVK8aOHZtvuSlTplC7dm2GDRtWDrmsPK644gref//98s6G53766Sd69OjB8uXLqVo1+L18sP97IrJGVVOCLW9NQ6bc5b3oV4ZCAODFF18kMTGR2NhYsrOzueOOO4IuN3LkyFxt+KZkIqEQAPjuu++YNGlSgYVASViNwHgm1BqBMaZsWY3AGGNMsVhBYIwxEc4KAmOMiXBWEBhjTISzgsBUOuEehrpx48a53nbduHFjESnkFxg0LTA8cl7+IG+7d+9236otS1lZWe6LT0Ud26ysLPdFs4rooYcecsODp6enExsb6waVK0vPPfccM2bMKNM0i1RQEKKK+rGgc+EjlKBzrhlX+T5lLBzDUBc3ZHQweYOmFcTrsM7btm3T2NjYkJYNNc8VwR133KGvvPJKyMsX52/uxx9/1MTExJJky2VhqI0JIpzCUAdTWFjk1atX07VrVxISEujUqVOu0BCQe2Cabdu20aVLF+Lj4/nzn//sLhN4556VlUX37t3p0KEDHTp04NNPPy1yXwOtWbOGhIQEEhISmD59etB9+OSTT9waT1JSEkeOHGH8+PGkp6eTmJjIlClTCjwWb7zxBvfeey8AU6dOpWXLlgBs3bo119vRhXn44YeZPHmy+zsuLo6srCyysrJo27Ytw4cPJzY2lssvv9y94x8yZAjz58/npZde4vXXX+cvf/mLewzuu+8+4uLiiI+Pd8OJLFu2jO7du3PttdfSrl07li1bRo8ePejfvz8tW7Zk/PjxzJkzh06dOhEfH8+3334LwLnnnktMTAyrVq0KaV/KgqchJkSkLzAViAJeUtVJeebfCwwDTgH7gdtVdbuXeTIVzEznNfnty3P/HvpumW9q586dfPrpp0RFRXH48GHS09OpWrUqH374IQ8++CALFizIt86mTZtYunQpR44coXXr1owcOTLfoOCff/45X375JRdeeCHdunVjxYoVpKSkcMcdd5CWlkaLFi0YOHBg0DxlZGTkixkzb948li9f7v5euXJlgft08uRJbr75ZubNm0fHjh05fPhwocHI7rnnHkaOHMlvf/vbXBfpQOeddx5LliyhevXqfPPNNwwcOBD/uzvB9tUfv8dv6NChPPfcc6SmpnLfffcF3cbkyZOZPn063bp14+jRo1SvXp1JkyYxefJkFi1aVGD+wRdH6IknngB8TTQNGzZk165dpKenuyElxo4dy9KlS/Ote8sttzB+/PhC0//mm2+YO3cuL774IgMGDGDBggXceuut7vxhw4axfPlyrr76am666SYWLFjAunXryMzM5MCBA3Ts2NHNx9q1a9mwYQMtWrRg2bJlZGZm8tVXX9GgQQNatmzJsGHDWLVqFVOnTuXZZ5/lmWeeASAlJYX09HQ6depUaF7LimcFgYhEAdOBPsBOYLWILFTVwAbPz4EUVT0mIiOBJ4CbvcqTiWzhEob65ptv5rnnngtpn77++muaNGnixhyqU6dOocuvWLHCLfBuu+22XIOk+OXk5LgDrERFRbF58+ZC9zWwIDh06BCHDh1yL4S33XZbrmB2ft26dePee+9l0KBB3HDDDfmOaWEuuOACjh49ypEjR9ixYwe/+c1vSEtLIz093Q0PXViNoigtWrRww17nDecdzPLlyxk4cCBRUVGcf/759OjRg9WrV1OnTh06deqUaxD5jh070qRJE8A3SM7ll18O+EJOBxZc5513njvgzdngZY2gE7BFVbcCiMhrQH/ALQhUNbDI/gy4FRNZ/Hf+HtYE/IKFoX7rrbfIysqiZ8+eQdcprzDUeRUVFrk4igrhMWXKFM4//3wyMzM5c+YM1atXd+eVZl8DjR8/nn79+rF48WK6detW7PAQXbt2ZebMmbRu3Zru3bszY8YMVq5cyVNPPQUUXSMo7Hjm3cfSdAYH/s3lTftshpkuipd9BBcBOwJ+73SmFeR3QP5bB0BERohIhohk7N+/vwyzaCJVOIShDlRQWOTWrVuzZ88eVq9eDfj6HAq7OHfr1s0d4nDOnDlBl8nOzqZJkyZUqVKFV155hdOnTxeZP7969epRr149t2mroG18++23xMfHc//999OxY0c2bdqUL/R1Xr1792bXrl2Ar3lo8uTJpKamkpSUxNKlSznnnHPcwXemTJkSNMy0v1koJibGDW29du1atm3bFvI+5tW9e3fmzZvH6dOn2b9/P2lpaaVu0inrMNNFqRCdxSJyK5ACPBlsvqq+oKopqpoSbDQnUwkMfdfT2kBe48aN44EHHiApKalUA4sUJDAMdXJyMrVr13YvUoECw1D7zZs3L9fjo59++mmusMgDBgxwwyJXq1aNefPmMWbMGBISEujTp0+htYWpU6cyffp04uPj3YtqXnfddRcvv/wyCQkJbNq0Kd9dbVFmzpzJqFGjSExMLHBMiWeeeYa4uDjat29PdHQ0V155Je3btycqKoqEhASmTJnC7t27ueqqqwA4c+YMW7ZsoUGDBoDv4rtjxw5SU1OJioqiadOm+foqCnPjjTe6o7s999xzuQb/Ka7rr7+e9u3bk5CQwK9+9SueeOIJLrjgghKnB74mvD59+pQqjWIp6HGi0n6ALsD7Ab8fAB4IstxlwFfAeaGka4+Pho9iPT5aCR05ckRVfeMyjxw5Up9++umgyz399NP64osvns2shZ3169fr2LFjyzsbZ8XatWv11ltvLVUaFenx0dVAKxFpISLVgFuAhYELiEgS8H/Ataq6z8O8GHPWWRjqshMXF8fTTz9d3tk4Kw4cOMCjjz56VrfpaRhqEbkKeAbf46MzVPV/RWQivpJpoYh8CMQDe5xVvlPVawtL08JQhw8LQ21M+ShuGGpP3yNQ1cXA4jzTHgr4fpmX2zfGGFO0CtFZbIwxpvxYQWCMMRHOCgJjjIlwVhCYSifcw1CLiBvuGODtt99GRJg/f36J0g8MOheqZ555hmPHjrm/H3/88RJtOxQxMTEcOHAAKPq4epmPwvgDzoEv1lBhocFnzZrF7t27z1bW+OMf/8jHH39cqjSsIDAVwpGTR+j/dn+OnCz4zdJQNWzY0H2T9M4772Ts2LHu72rVqhX6AllKSkquKKMF8UfkLAuPP/54rsInPj7effsXYO7cuUVGJy1rZ7MgCFTUcS2vgiDQSy+9RLt27Qqcf7YLgjFjxhQ43kSorCAwFULazjS2Zm8lfWe6J+mHUxjq7t27s2rVKnJycjh69Chbtmxxg6ABTJw4kY4dOxIXF8eIESPc7fXs2ZP777+fTp06cckll5Ce/vOx3L17N3379qVVq1aMGzfOnT5y5EhSUlKIjY1lwoQJAEybNo3du3fTq1cvevXqxfjx4zl+/DiJiYkMGjQIgOuuu47k5GRiY2NzBdOrVasWf/rTn0hISKBz587s3bs33z4fPHiQyy+/nNjYWIYNG5br7WP/cd2zZw+pqakkJiYSFxdHenp60HwEs2/fPpKTkwHIzMxERPjuu+8AX6C3wAKuIKrK6NGjad26NZdddhn79v38mlPPnj3JyMjg9OnTDBkyxA0/PWXKFObPn09GRgaDBg1yB60p7vk6ffo0f/zjH903r5999lnAF967R48eJCcnc8UVV7Bnj++p++bNm3Pw4EH++9//Frlfhe5wOH3szeLwEcqbxfctu087zu6oCS8naNysOE14OUE7zu6o9y27r0zy4B+YZvDgwdqvXz89deqUqqpmZ2e7g4UsWbJEb7jhBlXNPTjKhAkTtEuXLnrixAndv3+/NmjQQE+ePKmqPw/osnTpUq1Tp47u2LFDT58+rZ07d9b09HQ9fvy4Xnzxxbp161ZVVb3llluCDrry8ccfu9tW/XlgmrFjx+o777yjs2fP1ocfflgHDx6sb7zxhqqqHjx40F3+1ltv1YULF6qqao8ePfTee+9VVdV3331Xe/fu7abZokULPXTokB4/flybNWum3333Xa60Tp06pT169NDMzExVVW3evLnu37/f3U7eAWz86x07dkxjY2P1wIEDqqoKuPm577779NFHH823z2PGjNFHHnlEVVUXLVqkgLst/3YmT56sjz32mJu3w4cPB81HQdq1a6fZ2dn67LPPakpKis6ePVuzsrK0c+fOqqo6e/ZsTUhIyPe58cYbVVV1wYIFetlll+mpU6d0165dWrduXff49+jRQ1evXq0ZGRl62WWXudv84Ycfcs3Pe6xUQztff//73/XGG290/z4PHjyoJ0+e1C5duui+fftUVfW1117ToUOHuukOGzZM58+f7/4u7pvFnr5HYExRRieN5usfvmb30d2cPn2a6CrRNKnZhDFJY8p8W+EShhp8UTKnTZtGdnY2Tz31VK4mkaVLl/LEE09w7NgxN17ONddcA+CGYc4bPrl3795urKN27dqxfft2mjZtyuuvv84LL7zAqVOn2LNnDxs3bqR9+/ZFHstp06bx1ltvAbBjxw6++eYbGjZsSLVq1dyaT3JyMkuWLMm3blpaGm+++aZ7fOvXr59vmY4dO3L77beTk5PDddddl6tGFIquXbuyYsUK0tLSePDBB/n3v/+NqtK9e3cABg0aVGitIi0tzQ0tfeGFF/KrX/0q3zItW7Zk69atjBkzhn79+rkhpfMq7vn68MMPufPOO6la1Xd5btCgARs2bGDDhg1u/KHTp0+74azBF7a6NM1R1jRkylWzOs0YlTiKnDM51Khag5wzOYxKHEXTOk3LfFvBwlBv2LCBd955p8BAbeUVhrpTp06sX7+eAwcO5AqIduLECe666y7mz5/P+vXrGT58eNAQynnzESyP27ZtY/LkyXz00Ud88cUX9OvXL6Tw1suWLePDDz9k5cqVZGZmkpSU5K4XHR3thrkuTZjq1NRU0tLSuOiiixgyZAj//Oc/i71+eno627dvp3///mRmZrJ8+XK3IJgzZ06uwH7+T3HGba5fvz6ZmZn07NmT559/nmHDhuVbpqTnKy9VJTY21u3rWr9+PR988EGu7ZQmbLUVBKbcvZ/1PjWq1mBU4ihqVK3BB1kfFL1SKYVDGOpJkybl6xz1X0QaNWrE0aNHS/wkEcDhw4epWbMmdevWZe/evbkGkMkbEjo6OtqtNWVnZ1O/fn3OPfdcNm3axGeffVas7aamprqD1L/33nv88MMP+ZbZvn07559/PsOHD2fYsGFuyOjAfOT1wAMPuLWU7t27M3v2bFq1akWVKlVo0KABixcvdiOUDho0KGiYav/xTE1NdUNL79mzJ+jYBgcOHODMmTPceOONPPbYY24eA49dSc5Xnz59+L//+z+3YPj+++9p3bo1+/fvd0ery8nJ4csvv3TXKW3YamsaMuVuaNxQHvjlAzSq0Yh+Lfux98f8HYxlbdy4cQwePJjHHnuMfv36lXn6gWGoa9as6Y4glldgGOratWvnmnfllVfmW75evXoMHz6cuLg4LrjgggLTDUVCQgJJSUm0adOGpk2b5hrvd8SIEfTt25cLL7yQpUuXMmLECNq3b0+HDh2YMWMGzz//PG3btqV169Z07ty5WNudMGECAwcOJDY2lq5du9KsWbN8yyxbtownn3yS6OhoatWq5dYIAvMxZ84crrrqKl566SUuvPBC1q9fz7XX+kKVxcTEoKruSGmXXnopO3fuDNoMFcz111/Pxx9/TLt27WjWrBldunTJt8yuXbsYOnSoO8DNX//6V+DnBxNq1KjBypUri32+hg0bxubNm90Q3cOHD2f06NHMnz+fu+++m+zsbE6dOsXvf/97YmNjycnJYcuWLaSkBA0jFBJPg855wYLOhY9IDzp39OhRatWqhaoyatQoWrVqxdixY/MtN2XKFGrXrh20acGE7oorrij2SGeVwVtvvcXatWtzRSwtbtA5axoyxiMWhvrsisRCAODUqVP84Q9/KFUaViMwnon0GoEx5cVqBMYYY4rFCgJjjIlwVhAYY0yEs4LAGGMinBUEptIJ9zDUjRs3zvW2a2EhjwsSGDxv4cKFBUan9Ad52717d7Heqg1VVlaW+6JTUcc2KyvLfdHsbKvIobAvu+yyoC/dlamCghBV1I8FnQsfoQSd29QhWTe2bpPvs6lD2Zxnf9C5QP5gXhXFTTfdpOvWrVPVn4POlVZg8LzChBrEraS2bdumsbGxIS0bap69kDfIXmG8PmZ5zZo1yw3AF6riBp2zGoEpV2d+/LFY00sqnMJQBxOYL4DRo0e7oTFWr15N165dSUhIoFOnTrlCQ0DugWm2bdtGly5diI+P589//rO7TOCde1ZWFt27d6dDhw506NDBHSOgsH0NtGbNGhISEkhISGD69OlB9+GTTz5xazxJSUkcOXKE8ePHk56eTmJiIlOmTCnwWLzxxhvce++9AEydOpWWLVsCsHXr1lxvRxemLENhFzck9969e7n++uvdY+Q/vrNnz6ZTp04kJiZyxx13cPr0aQCuvfZa5s6dG9J+lZQVBCZi7Ny5k08//ZSnn36aNm3akJ6ezueff87EiRN58MEHg66zadMm3n//fVatWsUjjzwSNM7N559/zjPPPMPGjRvZunUrK1as4MSJE9xxxx289957rFmzhv379wdNPyMjI1+MmHnz5uVqGjp+/HiB+3Ty5Eluvvlmpk6dSmZmJh9++GGhwcfuueceRo4cyfr163NFrwx03nnnsWTJEtauXcu8efNyNecE29e8hg4dyrPPPktmZmaB+Zg8eTLTp09n3bp1pKenU6NGDSZNmkT37t1Zt25d0Dew/bp37+7G7k9PT6dhw4bs2rWL9PR0N6TE2LFjgwaV8zeRPfLII1x66aV8+eWXXH/99e54BYFeffVVrrjiCtatW0dmZqa7fo0aNVi3bh1z5swBYMaMGaxZs4aMjAymTZvGwYMHAfjxxx/p3LkzmZmZpKam8uKLLwJw991306NHDzIzM1m7di2xsbF89dVXzJs3jxUrVrBu3TqioqLc9OvXr89PP/3kpusFizVkIka4hKG++eabee6550Lap6+//pomTZq4MWzq1KlT6PIrVqxgwYIFANx2223cf//9+ZbJyclh9OjR7gVp8+bNhe6rP5AbwKFDhzh06JB7Qb7ttttyBbPz69atG/feey+DBg3ihhtuyHdMC3PBBRdw9OhRjhw5wo4dO/jNb35DWloa6enpbljnwmoUULahsIsbkvvjjz92YydFRUVRt25dXnnlFdasWeOex+PHj3Peeee52/CHmW7YsGGoh6lYrEZgIkY4haHOq2rVqm5wMyCkdQriDxNdkClTpnD++eeTmZlJRkZGrg720uxroPHjx/PSSy9x/PhxunXrxqZNm4q1fteuXZk5cyatW7d2awgrV650m4aKqhGEIpRQ2GUVkltVGTx4sBsF9euvv+bhhx9255c2zHRRrCAwESkcwlAHat68ORs3buSnn37i0KFDfPTRR+529uzZw+rVqwFfn0NhF5xu3bq54yH7mx7yys7OpkmTJlSpUoVXXnnFbasORb169ahXrx7Lly8vdBvffvst8fHx3H///XTs2JFNmzblC32dV+/evdm1axfgax6aPHkyqampJCUlsXTpUs455xx38J0pU6YEDTM9fvx4oOxCYZckJHfv3r35xz/+AfgGmMnOzqZ3797Mnz/fHRLz+++/Z/v27YCvkPjvf/9LTExMkWmXlBUEplxVCbhLD2V6WRk3bhwPPPAASUlJJb6rLUxgGOrk5GRq167tXqQCBYah9svbR/Dpp5/StGlTBgwYQFxcHAMGDCApKQmAatWqMW/ePMaMGUNCQgJ9+vQptLYwdepUpk+fTnx8vHtRzeuuu+7i5ZdfJiEhgU2bNuWqSYVi5syZjBo1isTExKCdyQDPPPOMOyZvdHQ0V155Je3btycqKoqEhASmTJnC7t27ueqqqwA4c+YMW7ZsoUGDBoCvINixYwepqalERUXRtGnTXE1URZkwYQJpaWnExsby5ptvFhgK2x+qe968edxzzz3Az6GwBw0aRN++fTl16hRt27Zl/PjxIYXknjp1KkuXLiU+Pp7k5GQ2btxIu3bteOyxx7j88stp3749ffr0ccckXrNmDZ07d3ZHLPOCBZ0znon0oHMWhrrsbNiwgRkzZvD000+Xd1bOunvuuYdrr72W3r17h7yOBZ0zFUq43WiUJQtDXXbi4uIishAA374XpxAoyf85qxEYz2zbto3atWvTsGHDIjsojTGlp6ocPHiQI0eOuE+s+RVWI7DHR41nLr74Ynbu3FngM/TGmLJXvXr1Yj2OC1YQGA9FR0fnuysxxlQ8nvYRiEhfEflaRLaIyPgg888RkXnO/P+ISIyX+THGGJOfZwWBiEQB04ErgXbAQBFpl2ex3wE/qOr/AFOAv3mVH2OMMcF5WSPoBGxR1a2qehJ4DeifZ5n+wMvO9/lAb7FeRWOMOau87CO4CNgR8Hsn8MuCllHVUyKSDTQEDgQuJCIjgBHOz59EZIMnOS5fjciz35WE7Vd4sf0KL8XZr+YFzQiLzmJVfQF4AUBEMgp6BCqc2X6FF9uv8GL7VTgvm4Z2AU0Dfl/sTAu6jIhUBeoC3sVaNcYYk4+XBcFqoJWItBCRasAtwMI8yywEBjvfbwI+1nB7w80YY8KcZ01DTpv/aOB9IAqYoapfishEfEOmLQT+H/CKiGwBvsdXWBQlf1D3ysH2K7zYfoUX269ChF2ICWOMMWXLgs4ZY0yEs4LAGGMiXFgVBEWFrAhXIpIlIutFZJ2IhG1oVRGZISL7At/zEJEGIrJERL5x/s0/OGwFV8B+PSwiu5xztk5ErirPPJaEiDQVkaUislFEvhSRe5zpYXvOCtmnynC+qovIKhHJdPbtEWd6CydEzxYnZE+1YqcdLn0ETsiKzUAffC+nrQYGqurGcs1YGRCRLCBFVcP6hRcRSQWOAv9U1Thn2hPA96o6ySm866tq/hHTK7AC9uth4KiqTi7PvJWGiDQBmqjqWhGpDawBrgOGEKbnrJB9GkD4ny8BaqrqURGJBpYD9wD3Am+q6msi8jyQqar/KE7a4VQjCCVkhSlHqpqG7+mvQIFhRF7G958yrBSwX2FPVfeo6lrn+xHgK3xv+4ftOStkn8Ke+hx1fkY7HwV+hS9ED5TwfIVTQRAsZEWlOMH4TuYHIrLGCadRmZyvqnuc7/8Fzi/PzJSx0SLyhdN0FDbNJ8E4kX+TgP9QSc5Znn2CSnC+RCRKRNYB+4AlwLfAIVX1D7xdoutiOBUEldmlqtoBX6TWUU5TRKXjvCwYHm2RRfsH8AsgEdgDPFWuuSkFEakFLAB+r6qHA+eF6zkLsk+V4nyp6mlVTcQXqaET0KYs0g2ngiCUkBVhSVV3Of/uA97Cd4Iri71Ou62//XZfOeenTKjqXuc/5RngRcL0nDltzQuAOar6pjM5rM9ZsH2qLOfLT1UPAUuBLkA9J0QPlPC6GE4FQSghK8KOiNR0OrUQkZrA5UBliq4aGEZkMPCvcsxLmfFfKB3XE4bnzOl8/H/AV6oaODJ82J6zgvapkpyvxiJSz/leA9+DM1/hKxBuchYr0fkKm6eGAJxHvp7h55AV/1u+OSo9EWmJrxYAvpAfr4brfonIXKAnvtC4e4EJwNvA60AzYDswQFXDquO1gP3qia+ZQYEs4I6AdvWwICKXAunAeuCMM/lBfG3qYXnOCtmngYT/+WqPrzM4Ct9N/OuqOtG5hrwGNAA+B25V1Z+KlXY4FQTGGGPKXjg1DRljjPGAFQTGGBPhrCAwxpgIZwWBMcZEOCsIjDEmwllBYCKGE5XyijzTfi8iBQboEpFlIuLpoOciMtcJfTA2z/RZInJTQesZU1Y8G6rSmApoLr4XEd8PmHYLMK58sgMicgHQUVX/p7zyYIzVCEwkmQ/088drd4KSXQiki8g/RCQjMM57XiJyNOD7TSIyy/neWEQWiMhq59MtyLrVRWSm+Mad+FxEejmzPgAucmLkdy8o4yLyqFNDiCrhvhtTIKsRmIihqt+LyCp8wf3+ha828Lqqqoj8yZkfBXwkIu1V9YsQk54KTFHV5SLSDF+No22eZUb5sqDxItIGX7TZS4BrgUVOILGgRORJoDYwVO0NUOMBqxGYSONvHsL5d67zfYCIrMX3in4s0K4YaV4GPOeEB14I1HGiXwa6FJgNoKqb8IVuuCSEtP8C1FXVO60QMF6xGoGJNP8CpohIB+BcVV0jIi2AP+Jrq//BafKpHmTdwAtx4PwqQGdVPeFBflcDySLSIFzi/ZjwYzUCE1GcEZ6WAjP4uTZQB/gRyBaR8/E1HQWzV0TaikgVfBEs/T4Axvh/iEhikHXTgUHO/EvwBXT7OoQs/xuYBLzrj1JrTFmzgsBEorlAgvMvqpqJr0loE/AqsKKA9cYDi4BP8Q1u4nc3kOI8AroRuDPIun8HqojIemAeMCTUCJGq+ga+GPoLnfDDxpQpiz5qjDERzmoExhgT4awgMMaYCGcFgTHGRDgrCIwxJsJZQWCMMRHOCgJjjIlwVhAYY0yE+/+vQZAOxhn5BQAAAABJRU5ErkJggg==\n",
|
|
"text/plain": [
|
|
"<Figure size 432x288 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {
|
|
"needs_background": "light"
|
|
},
|
|
"output_type": "display_data"
|
|
},
|
|
{
|
|
"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": [
|
|
"# let's plot the accuracy on the training set\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"plt.scatter(k_values,accuracy_training_k_p_w[0][0],marker=\"x\")\n",
|
|
"plt.scatter(k_values,accuracy_training_k_p_w[0][1],marker=\"+\")\n",
|
|
"plt.scatter(k_values,accuracy_training_k_p_w[1][0],marker=\"*\")\n",
|
|
"plt.scatter(k_values,accuracy_training_k_p_w[1][1],marker=\"s\")\n",
|
|
"plt.xlim([0, max(k_values)+2])\n",
|
|
"plt.ylim([0.0, 1.1])\n",
|
|
"plt.xlabel(\"Value of k\")\n",
|
|
"plt.ylabel(\"Accuracy\")\n",
|
|
"legend_labels = [\"Training (Manhattan dist.,w=uniform)\",\"Training (Euclidian dist.,w=uniform)\",\n",
|
|
" \"Training (Manhattan dist.,w=distance)\",\"Training (Euclidian dist.,w=distance)\"]\n",
|
|
"plt.legend(labels=legend_labels, loc=4, borderpad=0.2)\n",
|
|
"plt.title(\"Effect of k and p and w on training set accuracy\", fontsize=10)\n",
|
|
"plt.show()\n",
|
|
"\n",
|
|
"# let's plot the accuracy on the test set\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"plt.scatter(k_values,accuracy_test_k_p_w[0][0],marker=\"x\")\n",
|
|
"plt.scatter(k_values,accuracy_test_k_p_w[0][1],marker=\"+\")\n",
|
|
"plt.scatter(k_values,accuracy_test_k_p_w[1][0],marker=\"*\")\n",
|
|
"plt.scatter(k_values,accuracy_test_k_p_w[1][1],marker=\"s\")\n",
|
|
"plt.xlim([0, max(k_values)+2])\n",
|
|
"plt.ylim([0.0, 1.1])\n",
|
|
"plt.xlabel(\"Value of k\")\n",
|
|
"plt.ylabel(\"Accuracy\")\n",
|
|
"legend_labels = [\"Test (Manhattan dist.,w=uniform)\",\"Test (Euclidian dist.,w=uniform)\",\n",
|
|
" \"Training (Manhattan dist.,w=distance)\",\"Training (Euclidian dist.,w=distance)\"]\n",
|
|
"plt.legend(labels=legend_labels, loc=1, borderpad=0.2)\n",
|
|
"plt.title(\"Effect of k and p and w on test set accuracy\", fontsize=10)\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 28,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Max test set accuracy: 0.7333333333333333\n",
|
|
"Index of max test set accuracy: (1, 0, 1)\n",
|
|
"Hyperparameter values: w = distance p = 1 k = 3\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# let's find the best test set accuracy, using numpy\n",
|
|
"import numpy as np\n",
|
|
"np_array = np.array(accuracy_test_k_p_w)\n",
|
|
"max_index = np.unravel_index(np_array.argmax(), np_array.shape)\n",
|
|
"print(\"Max test set accuracy:\",np_array.max())\n",
|
|
"print(\"Index of max test set accuracy:\",max_index)\n",
|
|
"print(\"Hyperparameter values: w =\",w_values[max_index[0]],\"p =\",p_values[max_index[1]],\"k =\",k_values[max_index[2]]) "
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Key take away points from this worked example:\n",
|
|
"* Distance weighting seems to work better than uniform weighting on the beer dataset\n",
|
|
"* Manhattan distance seems to work best of the 4 distance metrics tested on the beer dataset\n",
|
|
"* Lower values of k seem to work better thna higher values on the beer dataset\n",
|
|
"* It is important to look at accuracy on both the training and test sets when deciding on model parameters\n",
|
|
"* Training set accuracy is usually much higher than test set accuracy\n",
|
|
"* The best test set accuracy we found on the beer dataset was with distance weighting, Manhattan distance and k=3. This combination also achieves 100% training set accuracy\n",
|
|
"* We have manually explored hyperparameter values in this example, however scikit-learn provides a class called GridSearchCV which can automate the hyperparameter search process (we will cover this in a later lecture) "
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": []
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "Python 3 (ipykernel)",
|
|
"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.10.7"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 4
|
|
}
|