From 8ba73edad0de934d8dfd791d9beafd147a59e972 Mon Sep 17 00:00:00 2001 From: Andrew Date: Sun, 29 Sep 2024 06:45:29 +0100 Subject: [PATCH] [CT4101]: Add Topic 3 Examples --- .../CT4101_03_CodeSamples+Datasets.zip | Bin .../examples/Decision_trees_impurity.ipynb | 402 +++++++++++ .../{ => examples}/HousePrices-1NN.xlsx | Bin .../materials/topic3/examples/beer_test.csv | 31 + .../topic3/examples/beer_training.csv | 125 ++++ .../topic3/examples/college_athletes.csv | 22 + .../materials/topic3/examples/iris_test.csv | 46 ++ .../topic3/examples/iris_training.csv | 106 +++ .../examples/k-NN_hyperparameters.ipynb | 653 ++++++++++++++++++ .../materials/topic3/examples/weather.csv | 15 + 10 files changed, 1400 insertions(+) rename year4/semester1/CT4101: Machine Learning/materials/topic3/{ => examples}/CT4101_03_CodeSamples+Datasets.zip (100%) create mode 100644 year4/semester1/CT4101: Machine Learning/materials/topic3/examples/Decision_trees_impurity.ipynb rename year4/semester1/CT4101: Machine Learning/materials/topic3/{ => examples}/HousePrices-1NN.xlsx (100%) create mode 100644 year4/semester1/CT4101: Machine Learning/materials/topic3/examples/beer_test.csv create mode 100644 year4/semester1/CT4101: Machine Learning/materials/topic3/examples/beer_training.csv create mode 100644 year4/semester1/CT4101: Machine Learning/materials/topic3/examples/college_athletes.csv create mode 100644 year4/semester1/CT4101: Machine Learning/materials/topic3/examples/iris_test.csv create mode 100644 year4/semester1/CT4101: Machine Learning/materials/topic3/examples/iris_training.csv create mode 100644 year4/semester1/CT4101: Machine Learning/materials/topic3/examples/k-NN_hyperparameters.ipynb create mode 100644 year4/semester1/CT4101: Machine Learning/materials/topic3/examples/weather.csv diff --git a/year4/semester1/CT4101: Machine Learning/materials/topic3/CT4101_03_CodeSamples+Datasets.zip b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/CT4101_03_CodeSamples+Datasets.zip similarity index 100% rename from year4/semester1/CT4101: Machine Learning/materials/topic3/CT4101_03_CodeSamples+Datasets.zip rename to year4/semester1/CT4101: Machine Learning/materials/topic3/examples/CT4101_03_CodeSamples+Datasets.zip diff --git a/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/Decision_trees_impurity.ipynb b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/Decision_trees_impurity.ipynb new file mode 100644 index 00000000..4fe2d08b --- /dev/null +++ b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/Decision_trees_impurity.ipynb @@ -0,0 +1,402 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Decision tree learning & Impurity (entropy/Gini) examples\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SciPy Entropy Examples\n", + "Below are a few simple examples of calculating entropy using the built in function from scipy.stats" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# entropy of a fair coin, i.e. 50% chance of heads, 50% chance of tails\n", + "from scipy.stats import entropy\n", + "entropy([1/2, 1/2], base=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9709505944546688" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# entropy of a biased coin, e.g. 60% chance of heads, 40% chance of tails\n", + "entropy([60/100, 40/100], base=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# entropy of a coin with both sides the same, e.g. 100% chance of heads\n", + "entropy([1], base=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Scikit-learn decision tree examples" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "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 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": 67, + "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": 68, + "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": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Value counts\n", + "lager 44\n", + "ale 42\n", + "stout 38\n", + "Name: style, dtype: int64\n", + "\n", + "Normalised value counts (i.e. probabilities)\n", + "lager 0.354839\n", + "ale 0.338710\n", + "stout 0.306452\n", + "Name: style, dtype: float64\n", + "\n", + "Training set entropy: 1.5823126935513492\n" + ] + } + ], + "source": [ + "# compute the entropy of the training dataset\n", + "print(\"Value counts\")\n", + "print(df_training[\"style\"].value_counts())\n", + "print(\"\\nNormalised value counts (i.e. probabilities)\")\n", + "print(df_training[\"style\"].value_counts(normalize=True))\n", + "\n", + "training_entropy = entropy(df_training[\"style\"].value_counts(normalize=True), base=2)\n", + "print(\"\\nTraining set entropy:\",training_entropy)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy on training data: 1.0\n" + ] + }, + { + "data": { + "text/plain": [ + "[Text(243.4909090909091, 587.0880000000001, 'X[7] <= 9.42\\nentropy = 1.582\\nsamples = 124\\nvalue = [42, 44, 38]'),\n", + " Text(121.74545454545455, 456.624, 'X[5] <= 9.667\\nentropy = 0.316\\nsamples = 35\\nvalue = [0, 2, 33]'),\n", + " Text(60.872727272727275, 326.1600000000001, 'entropy = 0.0\\nsamples = 33\\nvalue = [0, 0, 33]'),\n", + " Text(182.61818181818182, 326.1600000000001, 'entropy = 0.0\\nsamples = 2\\nvalue = [0, 2, 0]'),\n", + " Text(365.23636363636365, 456.624, 'X[3] <= 3.934\\nentropy = 1.256\\nsamples = 89\\nvalue = [42, 42, 5]'),\n", + " Text(304.3636363636364, 326.1600000000001, 'entropy = 0.0\\nsamples = 38\\nvalue = [0, 38, 0]'),\n", + " Text(426.1090909090909, 326.1600000000001, 'X[5] <= 8.226\\nentropy = 0.847\\nsamples = 51\\nvalue = [42, 4, 5]'),\n", + " Text(304.3636363636364, 195.69600000000003, 'X[4] <= 17.46\\nentropy = 0.863\\nsamples = 7\\nvalue = [0, 2, 5]'),\n", + " Text(243.4909090909091, 65.23200000000008, 'entropy = 0.0\\nsamples = 2\\nvalue = [0, 2, 0]'),\n", + " Text(365.23636363636365, 65.23200000000008, 'entropy = 0.0\\nsamples = 5\\nvalue = [0, 0, 5]'),\n", + " Text(547.8545454545455, 195.69600000000003, 'X[7] <= 15.54\\nentropy = 0.267\\nsamples = 44\\nvalue = [42, 2, 0]'),\n", + " Text(486.9818181818182, 65.23200000000008, 'entropy = 0.0\\nsamples = 42\\nvalue = [42, 0, 0]'),\n", + " Text(608.7272727272727, 65.23200000000008, 'entropy = 0.0\\nsamples = 2\\nvalue = [0, 2, 0]')]" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn import tree\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "# create a model using the default settings (using Gini index)\n", + "model = DecisionTreeClassifier(criterion=\"entropy\")\n", + "model.fit(X_training, y_training)\n", + "\n", + "# compute the accuracy on the training predictions\n", + "predictions_training = model.predict(X_training)\n", + "accuracy_training = metrics.accuracy_score(y_training, predictions_training)\n", + "print(\"Accuracy on training data:\",accuracy_training)\n", + "\n", + "plt.figure(figsize=(12,12))\n", + "tree.plot_tree(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see above that the netropy at the root node is the same as the overall entropy of the training set, i.e. 1.582" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy on training data: 1.0\n" + ] + }, + { + "data": { + "text/plain": [ + "[Text(362.70000000000005, 597.96, 'X[1] <= 0.36\\ngini = 0.665\\nsamples = 124\\nvalue = [42, 44, 38]'),\n", + " Text(223.20000000000002, 489.24, 'X[7] <= 9.42\\ngini = 0.552\\nsamples = 84\\nvalue = [5, 42, 37]'),\n", + " Text(111.60000000000001, 380.52000000000004, 'X[5] <= 9.667\\ngini = 0.111\\nsamples = 34\\nvalue = [0, 2, 32]'),\n", + " Text(55.800000000000004, 271.8, 'gini = 0.0\\nsamples = 32\\nvalue = [0, 0, 32]'),\n", + " Text(167.4, 271.8, 'gini = 0.0\\nsamples = 2\\nvalue = [0, 2, 0]'),\n", + " Text(334.8, 380.52000000000004, 'X[3] <= 3.934\\ngini = 0.34\\nsamples = 50\\nvalue = [5, 40, 5]'),\n", + " Text(279.0, 271.8, 'gini = 0.0\\nsamples = 37\\nvalue = [0, 37, 0]'),\n", + " Text(390.6, 271.8, 'X[5] <= 8.714\\ngini = 0.651\\nsamples = 13\\nvalue = [5, 3, 5]'),\n", + " Text(279.0, 163.07999999999998, 'X[2] <= 1.615\\ngini = 0.408\\nsamples = 7\\nvalue = [0, 2, 5]'),\n", + " Text(223.20000000000002, 54.360000000000014, 'gini = 0.0\\nsamples = 2\\nvalue = [0, 2, 0]'),\n", + " Text(334.8, 54.360000000000014, 'gini = 0.0\\nsamples = 5\\nvalue = [0, 0, 5]'),\n", + " Text(502.20000000000005, 163.07999999999998, 'X[7] <= 14.94\\ngini = 0.278\\nsamples = 6\\nvalue = [5, 1, 0]'),\n", + " Text(446.40000000000003, 54.360000000000014, 'gini = 0.0\\nsamples = 5\\nvalue = [5, 0, 0]'),\n", + " Text(558.0, 54.360000000000014, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1, 0]'),\n", + " Text(502.20000000000005, 489.24, 'X[2] <= 0.969\\ngini = 0.141\\nsamples = 40\\nvalue = [37, 2, 1]'),\n", + " Text(446.40000000000003, 380.52000000000004, 'gini = 0.0\\nsamples = 2\\nvalue = [0, 2, 0]'),\n", + " Text(558.0, 380.52000000000004, 'X[7] <= 9.06\\ngini = 0.051\\nsamples = 38\\nvalue = [37, 0, 1]'),\n", + " Text(502.20000000000005, 271.8, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 0, 1]'),\n", + " Text(613.8000000000001, 271.8, 'gini = 0.0\\nsamples = 37\\nvalue = [37, 0, 0]')]" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn import tree\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "# create a model using the default settings (using Gini index)\n", + "model = DecisionTreeClassifier()\n", + "model.fit(X_training, y_training)\n", + "\n", + "# compute the accuracy on the training predictions\n", + "predictions_training = model.predict(X_training)\n", + "accuracy_training = metrics.accuracy_score(y_training, predictions_training)\n", + "print(\"Accuracy on training data:\",accuracy_training)\n", + "\n", + "plt.figure(figsize=(12,12))\n", + "tree.plot_tree(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ct4101", + "language": "python", + "name": "ct4101" + }, + "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 +} diff --git a/year4/semester1/CT4101: Machine Learning/materials/topic3/HousePrices-1NN.xlsx b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/HousePrices-1NN.xlsx similarity index 100% rename from year4/semester1/CT4101: Machine Learning/materials/topic3/HousePrices-1NN.xlsx rename to year4/semester1/CT4101: Machine Learning/materials/topic3/examples/HousePrices-1NN.xlsx diff --git a/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/beer_test.csv b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/beer_test.csv new file mode 100644 index 00000000..784cebfe --- /dev/null +++ b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/beer_test.csv @@ -0,0 +1,31 @@ +calorific_value,nitrogen,turbidity,style,alcohol,sugars,bitterness,beer_id,colour,degree_of_fermentation +41.72123894,0.503275756,2.628181818,ale,4.015384615,16.73,10.45278947,93,13.44,55.33714286 +42.42920354,0.52551218,1.776363636,ale,4.092307692,16.72,10.99952632,103,12.24,58.38 +45.88053097,0.443232788,2.628181818,ale,4.276923077,16.68,13.45636842,178,10.92,58.38285714 +45.30530973,0.471667792,1.806363636,ale,4.126153846,18.84,9.202736842,166,10.92,58.52571429 +38.97787611,0.392845762,2.272727273,ale,4.015384615,16.77,9.457894737,44,10.56,58.9 +41.1460177,0.396443611,0.885454545,ale,4.021538462,16.5,13.02610526,78,14.16,59.41428571 +45.39380531,0.466171648,1.980909091,ale,4.563076923,16.64,11.44852632,170,12.96,60.01857143 +38.2699115,0.472478164,2.099090909,ale,4.313846154,16.68,12.32826316,31,12.48,60.35571429 +43.53539823,0.435870902,1.342727273,ale,4.061538462,16.78,10.81915789,122,12.6,60.46571429 +37.29646018,0.367897245,2.104545455,ale,4.326153846,16.63,13.30068421,4,13.08,61.84571429 +42.29646018,0.250667315,1.019090909,lager,3.806153846,15.94,2.924894737,101,12.6,37.03428571 +44.86283186,0.185199475,2.102727273,lager,4.009230769,15.9,6.608789474,155,14.28,46.39857143 +40.88053097,0.264555015,1.06,lager,3.716923077,17.08,7.411210526,69,15.24,47.32857143 +40.52654867,0.237383712,1.767272727,lager,4.033846154,16.01,13.27905263,64,13.44,48.32857143 +41.27876106,0.31818079,1.366363636,lager,3.756923077,16.19,8.915368421,81,15.36,50.07857143 +42.5619469,0.238442508,0.774545455,lager,3.526153846,18.74,8.155894737,107,9,51.59714286 +41.58849558,0.211766681,1.461818182,lager,3.587692308,16.88,5.340684211,89,14.76,52.15428571 +39.24336283,0.156837113,0.689090909,lager,3.636923077,16.72,6.820842105,46,11.28,53.18857143 +45.0840708,0.298799689,1.331818182,lager,4.206153846,16.25,10.28584211,162,14.76,53.38285714 +43.97787611,0.271177799,1.419090909,lager,3.849230769,16.73,9.530947368,131,12.48,53.57428571 +37.96017699,0.228401767,1.559090909,stout,3.950769231,17.96,5.386315789,19,10.68,71.69857143 +37.34070796,0.221810849,1.638181818,stout,3.855384615,20.51,5.596842105,6,9.84,73.13714286 +38.13716814,0.233793401,4.762727273,stout,4.147692308,16.67,6.252105263,23,6.84,73.39428571 +41.45575221,0.260993144,1.352727273,stout,3.978461538,17.81,3.865789474,85,9.24,74.15714286 +44.02212389,0.172410662,2.191818182,stout,4.033846154,16.9,7.546947368,134,7.32,74.67857143 +39.95132743,0.272586785,5.217272727,stout,4.412307692,16.68,6.008368421,54,6.84,74.75714286 +40.03982301,0.347918901,2.859090909,stout,4.178461538,17.58,7.340842105,56,8.88,74.88714286 +43.97787611,0.266770262,3.775454545,stout,4.347692308,19.1,7.356,132,7.32,75.89428571 +45.34955752,0.255529552,1.301818182,stout,4.16,18.17,3.243578947,169,10.68,76.18285714 +41.19026549,0.283402606,2.620909091,stout,4.123076923,19.6,7.554947368,80,8.04,79.13428571 diff --git a/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/beer_training.csv b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/beer_training.csv new file mode 100644 index 00000000..c8ae9e95 --- /dev/null +++ b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/beer_training.csv @@ -0,0 +1,125 @@ +calorific_value,nitrogen,turbidity,style,alcohol,sugars,bitterness,beer_id,colour,degree_of_fermentation +45.30530973,0.459548179,1.917272727,ale,4.227692308,16.67,12.56894737,167,11.04,62.17857143 +43.88938053,0.548977011,3.186363636,ale,4.289230769,16.73,14.974,128,13.44,63.03285714 +41.58849558,0.542846961,1.568181818,ale,4.344615385,16.48,11.84878947,88,14.04,63.46857143 +44.55309735,0.480300917,1.871818182,ale,4.424615385,18.59,13.87963158,147,12.48,63.53142857 +41.01327434,0.441860465,2.345454545,ale,4.264615385,16.35,12.18605263,74,12.12,63.74714286 +42.78318584,0.360463403,1.889090909,ale,4.172307692,16.71,15.09373684,109,11.4,63.91285714 +44.77433628,0.431959526,1.141818182,ale,4.218461538,16.86,12.82273684,153,13.32,64.03428571 +44.15486726,0.493446774,2.443636364,ale,4.252307692,16.75,14.17294737,138,12.12,65.62571429 +37.60619469,0.485480107,2.554545455,ale,4.338461538,17.02,13.26252632,12,12.84,65.82857143 +45.83628319,0.520862387,1.886363636,ale,4.230769231,16.73,11.50336842,177,13.8,66.47 +44.95132743,0.586365521,2.264545455,ale,4.369230769,16.76,14.82478947,158,12.6,66.75 +40.26106195,0.609585356,2.346363636,ale,4.421538462,16.95,11.819,60,10.32,67.55714286 +37.42920354,0.429247433,2.240909091,ale,4.378461538,16.71,10.01231579,8,12.48,67.81 +44.46460177,0.363074414,1.814545455,ale,4.147692308,16.81,9.659052632,143,12.48,67.89857143 +37.73893805,0.571386474,1.659090909,ale,4.427692308,16.87,12.812,14,12.24,67.95 +43.44690265,0.573324173,2.862727273,ale,4.221538462,16.43,13.74542105,120,10.68,68.07142857 +41.67699115,0.295421137,1.814545455,ale,4.375384615,18.99,10.31873684,91,10.68,68.42714286 +44.77433628,0.450176637,1.605454545,ale,4.372307692,19.04,13.32026316,154,10.44,68.45142857 +45.21681416,0.742774319,2.853636364,ale,4.366153846,16.59,12.49878947,164,14.76,68.67428571 +37.51769912,0.435485418,1.812727273,ale,4.172307692,16.73,10.67063158,10,11.76,69.16285714 +43.09292035,0.335413804,1.754545455,ale,4.196923077,18.1,11.07721053,116,11.52,69.43428571 +42.11946903,0.391087955,1.369090909,ale,3.953846154,16.6,10.24173684,100,13.08,69.95428571 +44.06637168,0.454088014,2.124545455,ale,4.270769231,16.89,11.19389474,136,10.56,70.21571429 +45.03982301,0.532171628,1.756363636,ale,4.326153846,17.15,11.62310526,160,12.72,70.87 +40.21681416,0.505285412,1.355454545,ale,4.12,16.77,13.74557895,59,11.04,70.88285714 +38.2699115,0.489920882,1.625454545,ale,4.015384615,16.65,9.954052632,30,13.44,70.99285714 +44.02212389,0.495629469,2.28,ale,4.255384615,16.57,14.01368421,133,13.56,71.05428571 +44.42035398,0.382415425,1.09,ale,4.153846154,16.81,9.406789474,139,13.44,71.47 +38.84513274,0.562436395,2.256363636,ale,4.255384615,16.65,10.42689474,41,14.88,71.54285714 +41.45575221,0.554015714,2.251818182,ale,4.089230769,16.97,10.48668421,84,12.84,72.56 +38.18141593,0.50525286,2.132727273,ale,4.224615385,16.5,10.18026316,24,14.28,73.1 +40.65929204,0.46462286,1.187272727,ale,4.156923077,16.8,12.57984211,66,13.2,73.17857143 +39.28761062,0.551372151,1.583636364,ale,4.233846154,16.53,8.651894737,47,15,73.21428571 +44.90707965,0.475125154,1.575454545,ale,4.049230769,17.36,14.35978947,156,12.36,73.43285714 +43.62389381,0.349082206,1.446363636,ale,3.978461538,18.8,9.628894737,125,12.36,74.06428571 +44.50884956,0.575722739,2.030909091,ale,4.236923077,16.9,12.54373684,146,13.56,74.18857143 +38.18141593,0.581744854,1.984545455,ale,4.4,16.92,10.52347368,25,12.84,74.35428571 +38.04867257,0.56120456,2.814545455,ale,4.193846154,16.81,12.49468421,20,15.36,75.67142857 +39.28761062,0.383650687,1.316363636,ale,4.267692308,16.9,9.522789474,48,15,75.82857143 +38.71238938,0.308351123,1.650909091,ale,4.073846154,17.59,12.60215789,38,12.48,78.14714286 +37.96017699,0.397214579,2.142727273,ale,4.086153846,16.64,11.25536842,18,13.08,78.70857143 +41.8539823,0.312053481,1.081818182,ale,4.015384615,17.05,10.78168421,95,13.56,87.02571429 +41.94247788,0.183229909,1.411818182,lager,3.806153846,16.17,7.673684211,96,13.44,53.66857143 +38.53539823,0.257081082,1.250909091,lager,3.876923077,16.34,6.847578947,36,12.48,54.01428571 +44.55309735,0.219026799,0.939090909,lager,3.636923077,16.47,6.328421053,148,11.4,54.53 +45.52654867,0.189464469,1.750909091,lager,3.889230769,16.36,6.581526316,172,11.76,54.91142857 +45.70353982,0.137596499,0.891818182,lager,3.76,16.29,10.27136842,176,10.32,54.95142857 +39.90707965,0.107012723,0.779090909,lager,3.692307692,15.92,7.479684211,53,16.56,55.91428571 +41.58849558,0.341122392,1.469090909,lager,3.781538462,16.61,6.477789474,90,10.872,60.89857143 +42.03097345,0.282453802,1.708181818,lager,3.913846154,16.81,12.10615789,98,13.92,61.05714286 +40.34955752,0.197146734,0.629090909,lager,3.904615385,16.53,5.315473684,62,11.52,61.59142857 +44.11061947,0.206482297,1.352727273,lager,3.898461538,15.98,8.277157895,137,14.76,61.62285714 +40.17256637,0.141298858,0.690909091,lager,3.393846154,16.51,9.779631579,58,20.52,61.91428571 +38.18141593,0.169096529,1.452727273,lager,3.824615385,16.53,13.81763158,27,8.28,61.94428571 +43.53539823,0.183369712,1.58,lager,4.150769231,16.66,7.230315789,124,11.76,62.30857143 +38.53539823,0.286716054,1.259090909,lager,3.793846154,16.1,4.326368421,35,15,62.56 +38.97787611,0.167299317,0.290909091,lager,3.806153846,16.63,10.85815789,45,10.68,62.64285714 +40.74778761,0.109410604,1.541818182,lager,3.575384615,16.99,11.21652632,67,13.92,63.30285714 +42.29646018,0.12751978,1.431818182,lager,3.821538462,17.55,9.598736842,102,10.32,63.34714286 +37.87168142,0.238338684,0.672727273,lager,3.716923077,16.33,5.665842105,16,12.84,63.41428571 +44.46460177,0.205390949,0.662727273,lager,3.716923077,16.83,5.123684211,144,12.96,63.44 +37.38495575,0.176077042,1.130909091,lager,3.741538462,16.61,9.554789474,7,15.96,64.65571429 +45.0840708,0.390027104,0.847272727,lager,3.68,16.09,11.42347368,161,11.88,64.72857143 +40.0840708,0.164977505,0.534545455,lager,3.907692308,18.87,9.168157895,57,14.28,65.8 +41.94247788,0.352781138,0.772727273,lager,4.104615385,15.94,5.924736842,97,12.24,65.94857143 +41.41150442,0.202430433,0.959090909,lager,3.692307692,16.51,6.085526316,83,12.6,66.08285714 +38.80088496,0.283330649,1.265454545,lager,3.704615385,19.3,6.477631579,40,9.48,66.17428571 +41.76548673,0.143658705,1.118181818,lager,3.652307692,19.31,9.866684211,94,9,66.27285714 +38.93362832,0.194925319,0.758181818,lager,3.796923077,17.45,11.17257895,43,9.6,67.04857143 +40.96902655,0.246442412,0.701818182,lager,3.523076923,17.4,10.43847368,72,9.6,67.34 +45.26106195,0.138479515,0.864545455,lager,3.716923077,16.39,11.46742105,165,11.16,67.55714286 +43.35840708,0.31183761,0.928181818,lager,3.581538462,17.06,6.081105263,118,12,67.84857143 +41.41150442,0.19404436,0.77,lager,3.510769231,15.74,7.862578947,82,13.2,68.72857143 +42.78318584,0.28745447,0.65,lager,3.716923077,16.13,4.950631579,110,15.72,68.91285714 +43.35840708,0.144433099,1.222727273,lager,3.744615385,16.45,10.37236842,119,17.4,70.13857143 +37.34070796,0.265611069,1.202727273,lager,3.806153846,16.21,9.162368421,5,14.28,70.23428571 +39.46460177,0.197993085,0.619090909,lager,3.643076923,15.89,11.74573684,49,9.48,70.68857143 +43.04867257,0.197672705,1.229090909,lager,4.264615385,16.51,13.65547368,113,16.32,73.00428571 +37.07522124,0.396231167,0.738181818,lager,3.996923077,16.67,11.74847368,1,15.72,73.02857143 +39.90707965,0.241683999,1.155454545,lager,3.584615385,16.67,6.359421053,52,16.32,73.16857143 +38.75663717,0.25024928,0.793636364,lager,3.572307692,16.35,13.31515789,39,11.52,73.98571429 +39.59734513,0.180265967,0.856363636,lager,3.821538462,19.43,9.708263158,50,11.04,74.42428571 +38.18141593,0.196229796,0.940909091,lager,3.627692308,17.13,11.25978947,26,11.64,76.31714286 +43.49115044,0.258598004,1.139090909,lager,3.633846154,17.12,8.174263158,121,11.4,76.78 +38.09292035,0.261521856,1.731818182,lager,3.618461538,17.68,7.556157895,21,14.76,81.21142857 +45.70353982,0.22417001,2.661818182,lager,3.556923077,17.05,20.06378947,175,11.16,87.23857143 +37.65044248,0.244681179,2.413636364,stout,3.870769231,16.29,3.219052632,13,6.96,57.21428571 +38.62389381,0.293868922,3.001818182,stout,3.876923077,17.46,2.730210526,37,8.76,60.37142857 +37.42920354,0.359055102,1.194545455,stout,4.049230769,18.57,4.336578947,9,7.2,60.70714286 +44.59734513,0.394747482,2.485454545,stout,3.769230769,18.88,4.523263158,149,7.8,60.88571429 +41.01327434,0.267123194,2.012727273,stout,4.150769231,18.59,6.593263158,75,9.72,61.93 +44.02212389,0.169803078,1.311818182,stout,4.270769231,20.04,6.159263158,135,6.96,62.03857143 +43.04867257,0.2685709,3.980909091,stout,3.944615385,18.37,7.098631579,115,8.64,62.47142857 +43.93362832,0.254582118,2.451818182,stout,3.849230769,16.24,5.219052632,130,9,62.60714286 +44.42035398,0.295698685,3.503636364,stout,4.24,17.76,7.318526316,142,8.4,62.61428571 +38.35840708,0.282170771,4.255454545,stout,4.070769231,18.3,4.046684211,33,6.72,62.84571429 +44.68584071,0.185837494,2.837272727,stout,4.224615385,19.36,6.667526316,152,9.36,62.84857143 +45.57079646,0.168747709,3.989999636,stout,3.929230769,17.39,6.265210526,174,6.84,62.93142857 +44.42035398,0.331995847,3.549090909,stout,4.083076923,19.28,4.823210526,141,7.08,62.93428571 +42.47345133,0.296829438,2.902727273,stout,4.052307692,20.19,3.847736842,104,7.2,63.66857143 +45.34955752,0.280161115,1.800909091,stout,3.956923077,16.35,4.348684211,168,9.12,63.66857143 +40.92477876,0.256869323,1.65,stout,4.190769231,19.95,7.374736842,71,10.92,63.90714286 +40.03982301,0.303067424,1.686363636,stout,4.110769231,17.56,3.55,55,8.4,64.10714286 +43.13716814,0.20528644,2.611818182,stout,3.803076923,18.83,3.167789474,117,6.72,64.31714286 +42.73893805,0.259444355,2.961818182,stout,4.098461538,18.24,5.145473684,108,6.6,64.46 +43.93362832,0.248870104,2.31,stout,3.753846154,18.03,3.413736842,129,7.92,65.15428571 +42.82743363,0.205390949,3.226363636,stout,4.258461538,19.12,7.099315789,112,6.84,65.23142857 +42.82743363,0.313775309,2.36,stout,3.987692308,18.45,3.801578947,111,8.16,65.33571429 +38.44690265,0.230198978,2.308181818,stout,3.907692308,18.55,8.877894737,34,9.36,65.43428571 +44.68584071,0.334920385,3.651818182,stout,4.052307692,17.59,5.002736842,151,7.2,65.64714286 +41.1460177,0.270822126,1.742727273,stout,3.941538462,17.31,5.800052632,79,7.92,65.85714286 +41.45575221,0.262541932,3.018181818,stout,4.024615385,18.9,9.466894737,86,6.84,66.57714286 +43.04867257,0.180269393,4.047272727,stout,3.935384615,17.67,5.900210526,114,5.76,67.10285714 +43.84513274,0.31127566,3.05,stout,4.218461538,20.65,5.469947368,127,7.68,67.15 +42.03097345,0.245981545,1.543636364,stout,3.963076923,17.99,8.782,99,8.88,67.51428571 +44.95132743,0.304969144,2.744545455,stout,4.123076923,18.91,6.272368421,159,8.4,68.16 +38.18141593,0.263215244,1.828181818,stout,4.212307692,18.26,5.262315789,29,11.52,68.80857143 +40.88053097,0.292846105,3.717272727,stout,4.356923077,17.51,4.064736842,70,7.44,69.30285714 +37.51769912,0.237528312,3.121818182,stout,3.96,19.61,3.751842105,11,6.48,69.70285714 +41.05752212,0.310112356,1.44,stout,3.769230769,19.72,5.720157895,77,9,70.23714286 +41.5,0.275860828,2.229090909,stout,3.953846154,18.27,4.228421053,87,10.44,70.68857143 +43.71238938,0.233296555,2.627272727,stout,4.153846154,18.12,6.288052632,126,7.08,70.94 +38.13716814,0.328714951,3.753636364,stout,4.138461538,18.7,7.799368421,22,10.2,71.17142857 +42.51769912,0.352644077,2.937272727,stout,3.830769231,18.03,6.692736842,106,8.04,71.45142857 diff --git a/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/college_athletes.csv b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/college_athletes.csv new file mode 100644 index 00000000..324816e5 --- /dev/null +++ b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/college_athletes.csv @@ -0,0 +1,22 @@ +ID,Speed,Agility,Draft +1,2.50,6.00,no +2,3.75,8.00,no +3,2.25,5.50,no +4,3.25,8.25,no +5,2.75,7.50,no +6,4.50,5.00,no +7,3.50,5.25,no +8,3.00,3.25,no +9,4.00,4.00,no +10,4.25,3.75,no +11,2.00,2.00,no +12,5.00,2.50,no +13,8.25,8.5,no +14,5.75,8.75,yes +15,4.75,6.25,yes +16,5.50,6.75,yes +17,5.25,9.50,yes +18,7.00,4.25,yes +19,7.50,8.00,yes +20,7.25,5.75,yes +21,6.75,3.00,yes \ No newline at end of file diff --git a/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/iris_test.csv b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/iris_test.csv new file mode 100644 index 00000000..381e98be --- /dev/null +++ b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/iris_test.csv @@ -0,0 +1,46 @@ +sepal_length,sepal_width,petal_length,petal_width,class +5.1,3.5,1.4,0.2,Iris-setosa +4.9,3.0,1.4,0.2,Iris-setosa +4.7,3.2,1.3,0.2,Iris-setosa +4.6,3.1,1.5,0.2,Iris-setosa +5.0,3.6,1.4,0.2,Iris-setosa +5.4,3.9,1.7,0.4,Iris-setosa +4.6,3.4,1.4,0.3,Iris-setosa +5.0,3.4,1.5,0.2,Iris-setosa +4.4,2.9,1.4,0.2,Iris-setosa +4.9,3.1,1.5,0.1,Iris-setosa +5.4,3.7,1.5,0.2,Iris-setosa +4.8,3.4,1.6,0.2,Iris-setosa +4.8,3.0,1.4,0.1,Iris-setosa +4.3,3.0,1.1,0.1,Iris-setosa +5.8,4.0,1.2,0.2,Iris-setosa +7.0,3.2,4.7,1.4,Iris-versicolor +6.4,3.2,4.5,1.5,Iris-versicolor +6.9,3.1,4.9,1.5,Iris-versicolor +5.5,2.3,4.0,1.3,Iris-versicolor +6.5,2.8,4.6,1.5,Iris-versicolor +5.7,2.8,4.5,1.3,Iris-versicolor +6.3,3.3,4.7,1.6,Iris-versicolor +4.9,2.4,3.3,1.0,Iris-versicolor +6.6,2.9,4.6,1.3,Iris-versicolor +5.2,2.7,3.9,1.4,Iris-versicolor +5.0,2.0,3.5,1.0,Iris-versicolor +5.9,3.0,4.2,1.5,Iris-versicolor +6.0,2.2,4.0,1.0,Iris-versicolor +6.1,2.9,4.7,1.4,Iris-versicolor +5.6,2.9,3.6,1.3,Iris-versicolor +6.3,3.3,6.0,2.5,Iris-virginica +5.8,2.7,5.1,1.9,Iris-virginica +7.1,3.0,5.9,2.1,Iris-virginica +6.3,2.9,5.6,1.8,Iris-virginica +6.5,3.0,5.8,2.2,Iris-virginica +7.6,3.0,6.6,2.1,Iris-virginica +4.9,2.5,4.5,1.7,Iris-virginica +7.3,2.9,6.3,1.8,Iris-virginica +6.7,2.5,5.8,1.8,Iris-virginica +7.2,3.6,6.1,2.5,Iris-virginica +6.5,3.2,5.1,2.0,Iris-virginica +6.4,2.7,5.3,1.9,Iris-virginica +6.8,3.0,5.5,2.1,Iris-virginica +5.7,2.5,5.0,2.0,Iris-virginica +5.8,2.8,5.1,2.4,Iris-virginica \ No newline at end of file diff --git a/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/iris_training.csv b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/iris_training.csv new file mode 100644 index 00000000..1d50c62a --- /dev/null +++ b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/iris_training.csv @@ -0,0 +1,106 @@ +sepal_length,sepal_width,petal_length,petal_width,class +5.7,4.4,1.5,0.4,Iris-setosa +5.4,3.9,1.3,0.4,Iris-setosa +5.1,3.5,1.4,0.3,Iris-setosa +5.7,3.8,1.7,0.3,Iris-setosa +5.1,3.8,1.5,0.3,Iris-setosa +5.4,3.4,1.7,0.2,Iris-setosa +5.1,3.7,1.5,0.4,Iris-setosa +4.6,3.6,1.0,0.2,Iris-setosa +5.1,3.3,1.7,0.5,Iris-setosa +4.8,3.4,1.9,0.2,Iris-setosa +5.0,3.0,1.6,0.2,Iris-setosa +5.0,3.4,1.6,0.4,Iris-setosa +5.2,3.5,1.5,0.2,Iris-setosa +5.2,3.4,1.4,0.2,Iris-setosa +4.7,3.2,1.6,0.2,Iris-setosa +4.8,3.1,1.6,0.2,Iris-setosa +5.4,3.4,1.5,0.4,Iris-setosa +5.2,4.1,1.5,0.1,Iris-setosa +5.5,4.2,1.4,0.2,Iris-setosa +4.9,3.1,1.5,0.1,Iris-setosa +5.0,3.2,1.2,0.2,Iris-setosa +5.5,3.5,1.3,0.2,Iris-setosa +4.9,3.1,1.5,0.1,Iris-setosa +4.4,3.0,1.3,0.2,Iris-setosa +5.1,3.4,1.5,0.2,Iris-setosa +5.0,3.5,1.3,0.3,Iris-setosa +4.5,2.3,1.3,0.3,Iris-setosa +4.4,3.2,1.3,0.2,Iris-setosa +5.0,3.5,1.6,0.6,Iris-setosa +5.1,3.8,1.9,0.4,Iris-setosa +4.8,3.0,1.4,0.3,Iris-setosa +5.1,3.8,1.6,0.2,Iris-setosa +4.6,3.2,1.4,0.2,Iris-setosa +5.3,3.7,1.5,0.2,Iris-setosa +5.0,3.3,1.4,0.2,Iris-setosa +6.7,3.1,4.4,1.4,Iris-versicolor +5.6,3.0,4.5,1.5,Iris-versicolor +5.8,2.7,4.1,1.0,Iris-versicolor +6.2,2.2,4.5,1.5,Iris-versicolor +5.6,2.5,3.9,1.1,Iris-versicolor +5.9,3.2,4.8,1.8,Iris-versicolor +6.1,2.8,4.0,1.3,Iris-versicolor +6.3,2.5,4.9,1.5,Iris-versicolor +6.1,2.8,4.7,1.2,Iris-versicolor +6.4,2.9,4.3,1.3,Iris-versicolor +6.6,3.0,4.4,1.4,Iris-versicolor +6.8,2.8,4.8,1.4,Iris-versicolor +6.7,3.0,5.0,1.7,Iris-versicolor +6.0,2.9,4.5,1.5,Iris-versicolor +5.7,2.6,3.5,1.0,Iris-versicolor +5.5,2.4,3.8,1.1,Iris-versicolor +5.5,2.4,3.7,1.0,Iris-versicolor +5.8,2.7,3.9,1.2,Iris-versicolor +6.0,2.7,5.1,1.6,Iris-versicolor +5.4,3.0,4.5,1.5,Iris-versicolor +6.0,3.4,4.5,1.6,Iris-versicolor +6.7,3.1,4.7,1.5,Iris-versicolor +6.3,2.3,4.4,1.3,Iris-versicolor +5.6,3.0,4.1,1.3,Iris-versicolor +5.5,2.5,4.0,1.3,Iris-versicolor +5.5,2.6,4.4,1.2,Iris-versicolor +6.1,3.0,4.6,1.4,Iris-versicolor +5.8,2.6,4.0,1.2,Iris-versicolor +5.0,2.3,3.3,1.0,Iris-versicolor +5.6,2.7,4.2,1.3,Iris-versicolor +5.7,3.0,4.2,1.2,Iris-versicolor +5.7,2.9,4.2,1.3,Iris-versicolor +6.2,2.9,4.3,1.3,Iris-versicolor +5.1,2.5,3.0,1.1,Iris-versicolor +5.7,2.8,4.1,1.3,Iris-versicolor +6.4,3.2,5.3,2.3,Iris-virginica +6.5,3.0,5.5,1.8,Iris-virginica +7.7,3.8,6.7,2.2,Iris-virginica +7.7,2.6,6.9,2.3,Iris-virginica +6.0,2.2,5.0,1.5,Iris-virginica +6.9,3.2,5.7,2.3,Iris-virginica +5.6,2.8,4.9,2.0,Iris-virginica +7.7,2.8,6.7,2.0,Iris-virginica +6.3,2.7,4.9,1.8,Iris-virginica +6.7,3.3,5.7,2.1,Iris-virginica +7.2,3.2,6.0,1.8,Iris-virginica +6.2,2.8,4.8,1.8,Iris-virginica +6.1,3.0,4.9,1.8,Iris-virginica +6.4,2.8,5.6,2.1,Iris-virginica +7.2,3.0,5.8,1.6,Iris-virginica +7.4,2.8,6.1,1.9,Iris-virginica +7.9,3.8,6.4,2.0,Iris-virginica +6.4,2.8,5.6,2.2,Iris-virginica +6.3,2.8,5.1,1.5,Iris-virginica +6.1,2.6,5.6,1.4,Iris-virginica +7.7,3.0,6.1,2.3,Iris-virginica +6.3,3.4,5.6,2.4,Iris-virginica +6.4,3.1,5.5,1.8,Iris-virginica +6.0,3.0,4.8,1.8,Iris-virginica +6.9,3.1,5.4,2.1,Iris-virginica +6.7,3.1,5.6,2.4,Iris-virginica +6.9,3.1,5.1,2.3,Iris-virginica +5.8,2.7,5.1,1.9,Iris-virginica +6.8,3.2,5.9,2.3,Iris-virginica +6.7,3.3,5.7,2.5,Iris-virginica +6.7,3.0,5.2,2.3,Iris-virginica +6.3,2.5,5.0,1.9,Iris-virginica +6.5,3.0,5.2,2.0,Iris-virginica +6.2,3.4,5.4,2.3,Iris-virginica +5.9,3.0,5.1,1.8,Iris-virginica \ No newline at end of file diff --git a/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/k-NN_hyperparameters.ipynb b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/k-NN_hyperparameters.ipynb new file mode 100644 index 00000000..c7ebc525 --- /dev/null +++ b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/k-NN_hyperparameters.ipynb @@ -0,0 +1,653 @@ +{ + "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": [ + "
" + ] + }, + "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": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "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": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "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 +} diff --git a/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/weather.csv b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/weather.csv new file mode 100644 index 00000000..38041c7d --- /dev/null +++ b/year4/semester1/CT4101: Machine Learning/materials/topic3/examples/weather.csv @@ -0,0 +1,15 @@ +Play?,Outlook,Temp,Humidity,Windy +no,sunny,hot,high,false +no,sunny,hot,high,true +yes,overcast,hot,high,false +yes,rainy,mild,high,false +yes,rainy,cool,normal,false +no,rainy,cool,normal,true +yes,overcast,cool,normal,true +no,sunny,mild,high,false +yes,sunny,cool,normal,false +yes,rainy,mild,normal,false +yes,sunny,mild,normal,true +yes,overcast,mild,high,true +yes,overcast,hot,normal,false +no,rainy,mild,high,true