{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "id": "8bPV9aEwTKC8" }, "outputs": [], "source": [ "import numpy as np\n", "from matplotlib import pyplot as plt\n", "import sklearn\n", "import pandas as pd" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "id": "jFHJbjkfeepf" }, "outputs": [], "source": [ "RANDOM_SEED = 0x0" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "ykbI8UnR6PsU" }, "source": [ "# TASK 1 (2 Points): \n", "\n", "We work with the \"Wine Recognition\" dataset. You can read more about this dataset at [https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset).\n", "\n", "The data is the results of a chemical analysis of wines grown in the same region in Italy by three different cultivators.\n", "The data is loaded below and split into `data` and `target`. `data` is a `Dataframe` that contains the result of the chemical analysis while `target` contains an integer representing the wine cultivator." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "id": "em6VCOuE6MRU" }, "outputs": [], "source": [ "from sklearn.datasets import load_wine\n", "(data, target) = load_wine(return_X_y=True, as_frame=True)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "id": "HJoAuMNR6MgM" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
alcoholmalic_acidashalcalinity_of_ashmagnesiumtotal_phenolsflavanoidsnonflavanoid_phenolsproanthocyaninscolor_intensityhueod280/od315_of_diluted_winesproline
014.231.712.4315.6127.02.803.060.282.295.641.043.921065.0
113.201.782.1411.2100.02.652.760.261.284.381.053.401050.0
213.162.362.6718.6101.02.803.240.302.815.681.033.171185.0
314.371.952.5016.8113.03.853.490.242.187.800.863.451480.0
413.242.592.8721.0118.02.802.690.391.824.321.042.93735.0
..........................................
17313.715.652.4520.595.01.680.610.521.067.700.641.74740.0
17413.403.912.4823.0102.01.800.750.431.417.300.701.56750.0
17513.274.282.2620.0120.01.590.690.431.3510.200.591.56835.0
17613.172.592.3720.0120.01.650.680.531.469.300.601.62840.0
17714.134.102.7424.596.02.050.760.561.359.200.611.60560.0
\n", "

178 rows × 13 columns

\n", "
" ], "text/plain": [ " alcohol malic_acid ash alcalinity_of_ash magnesium total_phenols \\\n", "0 14.23 1.71 2.43 15.6 127.0 2.80 \n", "1 13.20 1.78 2.14 11.2 100.0 2.65 \n", "2 13.16 2.36 2.67 18.6 101.0 2.80 \n", "3 14.37 1.95 2.50 16.8 113.0 3.85 \n", "4 13.24 2.59 2.87 21.0 118.0 2.80 \n", ".. ... ... ... ... ... ... \n", "173 13.71 5.65 2.45 20.5 95.0 1.68 \n", "174 13.40 3.91 2.48 23.0 102.0 1.80 \n", "175 13.27 4.28 2.26 20.0 120.0 1.59 \n", "176 13.17 2.59 2.37 20.0 120.0 1.65 \n", "177 14.13 4.10 2.74 24.5 96.0 2.05 \n", "\n", " flavanoids nonflavanoid_phenols proanthocyanins color_intensity hue \\\n", "0 3.06 0.28 2.29 5.64 1.04 \n", "1 2.76 0.26 1.28 4.38 1.05 \n", "2 3.24 0.30 2.81 5.68 1.03 \n", "3 3.49 0.24 2.18 7.80 0.86 \n", "4 2.69 0.39 1.82 4.32 1.04 \n", ".. ... ... ... ... ... \n", "173 0.61 0.52 1.06 7.70 0.64 \n", "174 0.75 0.43 1.41 7.30 0.70 \n", "175 0.69 0.43 1.35 10.20 0.59 \n", "176 0.68 0.53 1.46 9.30 0.60 \n", "177 0.76 0.56 1.35 9.20 0.61 \n", "\n", " od280/od315_of_diluted_wines proline \n", "0 3.92 1065.0 \n", "1 3.40 1050.0 \n", "2 3.17 1185.0 \n", "3 3.45 1480.0 \n", "4 2.93 735.0 \n", ".. ... ... \n", "173 1.74 740.0 \n", "174 1.56 750.0 \n", "175 1.56 835.0 \n", "176 1.62 840.0 \n", "177 1.60 560.0 \n", "\n", "[178 rows x 13 columns]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "id": "xrsPKm3w6Mi-" }, "outputs": [ { "data": { "text/plain": [ "0 0\n", "1 0\n", "2 0\n", "3 0\n", "4 0\n", " ..\n", "173 2\n", "174 2\n", "175 2\n", "176 2\n", "177 2\n", "Name: target, Length: 178, dtype: int64" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "target" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "B3W5r6Se8kXW" }, "source": [ "Next, the data is split into training data and testing data.\n", "The training data is used to train the model while the testing data is used to evaluate the model on different data than it was trained for. You will learn later in the course why this is necessary." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "id": "m1w8dDgw6MoO" }, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(data, target, test_size=0.33, random_state=42)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "J_eeYvZc-f_n" }, "source": [ "\n", "In the following, we define functions to classify the data. We use a [Decision Tree Classifier](https://scikit-learn.org/stable/modules/tree.html#tree) and a [Support Vector Classifier](https://scikit-learn.org/stable/modules/svm.html#svm-classification). You will learn later in the course how these classifiers work." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "id": "pvm_zBOe-e_X" }, "outputs": [], "source": [ "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.svm import SVC\n", "from sklearn.metrics import accuracy_score\n", "\n", "def run_classifier(clf, X_train, y_train, X_test, y_test):\n", " clf.fit(X_train, y_train)\n", " y_test_predicted = clf.predict(X_test)\n", " return accuracy_score(y_test, y_test_predicted)\n", "\n", "\n", "def run_decision_tree(X_train, y_train, X_test, y_test):\n", " clf = DecisionTreeClassifier(random_state=0)\n", " accuracy = run_classifier(clf, X_train, y_train, X_test, y_test)\n", " print(\"The accuracy of the Decision Tree classifier is\", accuracy)\n", "\n", "def run_svc(X_train, y_train, X_test, y_test):\n", " clf = SVC(random_state=0)\n", " accuracy = run_classifier(clf, X_train, y_train, X_test, y_test)\n", " print(\"The accuracy of the Support Vector classifier is\", accuracy)\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "s1MS2D8LAMpD" }, "source": [ "### Task 1a: Classify the data\n", "\n", "Classify the data by calling the two functions `run_decision_tree` and `run_svc`.\n", "Which classifier works better (i.e. achieves the higher accuracy)?" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "id": "5ToW8fx4ANZ8" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The accuracy of the Decision Tree classifier is 0.9661016949152542\n", "The accuracy of the Support Vector classifier is 0.711864406779661\n" ] } ], "source": [ "run_decision_tree(X_train, y_train, X_test, y_test)\n", "run_svc(X_train, y_train, X_test, y_test)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "_The Decision Tree Classifier seems to be working better._" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "BbM8OUZFBRGH" }, "source": [ "### Task 1b: Normalize the data with mean and standard deviation\n", "\n", "Normalize the training and testing data using the following formula:\n", "\n", "$$X_{normalized} = \\frac{X-\\mu_X}{\\sigma_X}$$\n", "\n", "Calculate the mean and standard deviation __on the training data__ only (also when you normalize the testing dataset).\n", "\n", "`Pandas` provides built-in functions to calculate the average and the standard deviation. For example, `X_train.mean()` returns the average value per feature in the training dataset while `X_train.std()` returns the standard deviation per feature." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "id": "K0qkP9TqBRft" }, "outputs": [], "source": [ "def std_norm(data):\n", " return (data - X_train.mean()) / X_train.std()\n", "\n", "X_train_std_norm = std_norm(X_train)\n", "X_test_std_norm = std_norm(X_test)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "_fNuBgC6BSFt" }, "source": [ "Call the two classification functions again with the normalized data and report the changes in accuracy. What do you notice?" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "id": "TFg6WbmgBShk" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The accuracy of the Support Vector classifier is 0.9830508474576272\n", "The accuracy of the Decision Tree classifier is 0.9661016949152542\n" ] } ], "source": [ "run_svc(X_train_std_norm, y_train, X_test_std_norm, y_test)\n", "run_decision_tree(X_train_std_norm, y_train, X_test_std_norm, y_test)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "_Now the Support Vector Classifier is more accurate - however, both have a very high accuracy._" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "1_1EVF-TBS7v" }, "source": [ "### Task 1c: Repeat Task 1b with min-max Normalization\n", "\n", "Repeat the task 1b but use the following formula to normalize tha data:\n", "\n", "$$X_{normalized} = \\frac{X-X_{min}}{X_{max} - X_{min}}$$\n", "\n", "Again, calculate the maximum and minimum __on the training data__ only (also when you normalize the testing dataset) and use the built-in function `X_train.min()` resp. `X_train.max()`." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "id": "i25XenppJ7gf" }, "outputs": [], "source": [ "def min_max_norm(data):\n", " return (data - X_train.min()) / (X_train.max() - X_train.min())\n", "\n", "X_train_min_max_norm = min_max_norm(X_train)\n", "X_test_min_max_norm = min_max_norm(X_test)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "NIy0ECbTJ7gq" }, "source": [ "Call the two classification functions again with the normalized data and report the changes in accuracy. What do you notice?" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "id": "99uuR7ngJ7gr" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The accuracy of the Support Vector classifier is 0.9830508474576272\n", "The accuracy of the Decision Tree classifier is 0.9661016949152542\n" ] } ], "source": [ "run_svc(X_train_min_max_norm, y_train, X_test_min_max_norm, y_test)\n", "run_decision_tree(X_train_min_max_norm, y_train, X_test_min_max_norm, y_test)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "_The accuracy does not change._" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "c_i1aBh6KnWw" }, "source": [ "## 📢 **HAND-IN** 📢: Report on Moodle whether you solved this task." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "m7I1RBjQK7Ly" }, "source": [ "---\n", "# TASK 2 (2 Points): \n", "\n", "In Task 1 we clearly saw that normalization improves the result for Support Vector Classifiers but not for Decision Trees. You will learn later in the course why Decision Trees don't need normalization.\n", "\n", "However, to better understand the influence of normalization, we will plot the data with and without normalization.\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "id": "w9qp3e4nBTPK" }, "outputs": [], "source": [ "import seaborn as sns\n", "sns.set_theme(style=\"ticks\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "tnF26SbCNCRS" }, "source": [ "### Task 2a: Plot the unnormalized data\n", "\n", "For simplicity, we only consider only the columns `alcohol` and `malic_acid` from the training dataset.\n", "\n", "Create a [Scatterplot](https://seaborn.pydata.org/generated/seaborn.scatterplot.html) from the corresponding training data mentioned below with the attribute `alcohol` on the `x`-axis and `malic_acid` on the `y`-axis.\n", "\n", "Plot the un-normalized data `X_train` as well as the two normalized versions from Exercise 1 in the same plot and describe what happens.\n", "\n", "__Hint:__ To visualize the data distributions in the same plot just call `sns.scatterplot` three times within the same code-cell. Add a 'label' argument to differentiate the data distributions." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "id": "-lc07hbiOvYu" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "for data in [\n", " [X_train, \"Un-Normalized\"],\n", " [X_train_std_norm, \"Standard Deviation\"],\n", " [X_train_min_max_norm, \"Min/Max Normalized\"]]:\n", " sns.scatterplot(data[0], x=\"alcohol\", y=\"malic_acid\", label=data[1])" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "pJ5Ncd5cN-9z" }, "source": [ "We will now have a closer look at the data. Calculate for the un-normalized training data as well as for the two normalized versions of the training data\n", "\n", "- The average value in the column `avg(alcohol)`\n", "- The standard deviation in the column `std(alcohol)`\n", "- The minimum value in the column `min(alcohol)`\n", "- The maxmium value in the column `max(alcohol)`\n", "- The range in the column by subtracting the minimum of the maximum in the column `max(alcohol) - min(alcohol)`\n", "\n", "Compare the properties of the un-normalized training data with the normalized training data. What do you notice?" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "id": "J3D06pyKQjGq" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
AverageStandard DeviationMinimumMaximumRange
Un-Normalized1.297101e+010.85197511.03000014.8300003.800000
Standard Deviation-1.160603e-151.000000-2.2782452.1819794.460224
Min/Max Normalized5.107917e-010.2242040.0000001.0000001.000000
\n", "
" ], "text/plain": [ " Average Standard Deviation Minimum Maximum \\\n", "Un-Normalized 1.297101e+01 0.851975 11.030000 14.830000 \n", "Standard Deviation -1.160603e-15 1.000000 -2.278245 2.181979 \n", "Min/Max Normalized 5.107917e-01 0.224204 0.000000 1.000000 \n", "\n", " Range \n", "Un-Normalized 3.800000 \n", "Standard Deviation 4.460224 \n", "Min/Max Normalized 1.000000 " ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data = pd.DataFrame(\n", " [\n", " [\n", " selector(dataset[\"alcohol\"])\n", " for selector in [\n", " lambda column : column.mean(),\n", " lambda column : column.std(),\n", " lambda column : column.min(),\n", " lambda column : column.max(),\n", " lambda column : column.max() - column.min()]\n", " ]\n", " for dataset in [X_train, X_train_std_norm, X_train_min_max_norm]\n", " ],\n", " columns=[\"Average\", \"Standard Deviation\", \"Minimum\", \"Maximum\", \"Range\"],\n", " index=[\"Un-Normalized\", \"Standard Deviation\", \"Min/Max Normalized\"])\n", "\n", "data" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "As expected, the _Standard Deviation Normalization_ causes the the standard deviation to equal $1$. The _Min/Max Normalization_ causes all values to be in the range of $0..1$ making the range equal $1$." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "AH7H07ZcSniv" }, "source": [ "## 📢 **HAND-IN** 📢: Report on Moodle whether you solved this task.\n", "\n", "---" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "UT3_BLJDl-0o" }, "source": [ "# TASK 3 (6 Points): Binning\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "q7K4Cikz4aZE" }, "source": [ "The following list consists of the age of several people: \n", "```python\n", "[13, 15, 16, 18, 19, 20, 20, 21, 22, 22, 25, 25, 26, 26, 30, 33, 34, 35, 35, 35, 36, 37, 40, 42, 46, 53, 70]\n", "```" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "lsHmNGlW4aZE" }, "source": [ "### Task 3a: Equal-Width Binning\n", "Apply binning to the dataset using 3 equal-width bins. Smooth the data using the mean of the bins.\n", "\n", "Tips:\n", "1. Calculate the size of the bins\n", "2. Assign each value to the corresponding bin\n", "3. Calculate the mean per bin\n", "4. Replace each value by the mean of its bin\n", "\n", "__Solve this exercise by hand without using Python__" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "eukBUnVs4aZE" }, "source": [ "❗ TODO ❗\n", " 1. $\\frac{70 - 13}{3} = 19$ $\\rightarrow$ `[[13-32], [32-51], [51-70]]`\n", " 2. `[[13, 15, 16, 18, 19, 20, 20, 21, 22, 22, 25, 25, 26, 26, 30], [33, 34, 35, 35, 35, 36, 37, 40, 42, 46], [53, 70]]`\n", " 3. `[21.2, 37.3, 61.5]`\n", " 4. `[21.2, 21.2, 21.2, 21.2, 21.2, 21.2, 21.2, 21.2, 21.2, 21.2, 21.2, 21.2, 21.2, 21.2, 21.2, 37.3, 37.3, 37.3, 37.3, 37.3, 37.3, 37.3, 37.3, 37.3, 37.3, 61.5, 61.5]`" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "8UL9OUG44aZF" }, "source": [ "### Task 3b: Equal-Depth Binning\n", "\n", "Apply binning to the dataset using 3 equal-depth bins. Smooth the data using the mean of the bins. Explain the steps of your approach and give the final result.\n", "\n", "Tips:\n", "1. Calculate the number of elements per bin\n", "2. Assign each value to the corresponding bin\n", "3. Calculate the mean per bin\n", "4. Replace each value by the mean of its bin\n", "\n", "__Please solve this exercise by hand without using Python__ " ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "Vhf3wkSm4aZF" }, "source": [ "❗ TODO ❗\n", " 1. $9$\n", " 2. `[[13, 15, 16, 18, 19, 20, 20, 21, 22], [22, 25, 25, 26, 26, 30, 33, 34, 35], [35, 35, 36, 37, 40, 42, 46, 53, 70]]`\n", " 3. `[18.222, 28.444, 43.778]`\n", " 4. `[18, 18, 18, 18, 18, 18, 18, 18, 18, 28, 28, 28, 28, 28, 28, 28, 28, 28, 43, 43, 43, 43, 43, 43, 43, 43, 43]`" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "ex21HuPTl_Qx" }, "source": [ "## 📢 **HAND-IN** 📢: Describe on Moodle the results of Exercise 3: \n", "\n", "* Copy the results of Exercise 3a and 3b to Moodle\n", "* Describe the differences between task 3a and task 3b\n", "* Describe situations when binning should be used and give a concrete example. Are there also circumstances in which binning should not be applied?" ] } ], "metadata": { "colab": { "private_outputs": true, "provenance": [] }, "kernelspec": { "display_name": "base", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.3" }, "vscode": { "interpreter": { "hash": "558914ba93c675d10f9462c68c84c8e4fd6bd2548e0b0f568325ba1dc72cba58" } } }, "nbformat": 4, "nbformat_minor": 0 }