{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercise II: k-Nearest Neighbors (k-NN)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[k-NN](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm) is a simple and useful non-parametric method that is commonly used for both classification and regression. It relies on having some method of calculating distance between data points, and using the the \"nearest\" observations to predict the target value for new ones."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
" \n",
" \n",
" Example of k-NN classification. The test sample (green dot) should be classified either to blue squares or to red triangles. If k = 3 (solid line circle) it is assigned to the red triangles because there are 2 triangles and only 1 square inside the inner circle. If k = 5 (dashed line circle) it is assigned to the blue squares (3 squares vs. 2 triangles inside the outer circle).\n",
" \n",
" Wikipedia\n",
" \n",
" \n",
" \n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```{admonition} The Curse of Dimensionality\n",
" :class: note\n",
"> *The curse of dimensionality refers to various phenomena that arise when analyzing and organizing data in high-dimensional spaces that do not occur in low-dimensional settings such as the three-dimensional physical space of everyday experience. [Wikipedia](https://en.wikipedia.org/wiki/Curse_of_dimensionality)*\n",
"\n",
"**k-NN normally performs better with a limited number of features**. In simplified terms, distances become increasingly large in higher dimensionality spaces.\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Loading the Dataset"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this exercise we will use the [Iris Flower Dataset](https://en.wikipedia.org/wiki/Iris_flower_data_set). This dataset is commonly used for demonstrating simple statistical concepts and therefore `scikit-learn` provides us with a utility function to load it."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"\n",
"from sklearn.datasets import load_iris\n",
"\n",
"TARGET_NAME = \"class\"\n",
"\n",
"# Read a type of dictionary with the dataset as well as some metadata.\n",
"iris_dataset = load_iris()\n",
"\n",
"# Read the features and targets.\n",
"X = pd.DataFrame(iris_dataset.data, columns=iris_dataset.feature_names)\n",
"y = pd.Series(iris_dataset.target, name=TARGET_NAME)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Basic Exploration"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
".. _iris_dataset:\n",
"\n",
"Iris plants dataset\n",
"--------------------\n",
"\n",
"**Data Set Characteristics:**\n",
"\n",
" :Number of Instances: 150 (50 in each of three classes)\n",
" :Number of Attributes: 4 numeric, predictive attributes and the class\n",
" :Attribute Information:\n",
" - sepal length in cm\n",
" - sepal width in cm\n",
" - petal length in cm\n",
" - petal width in cm\n",
" - class:\n",
" - Iris-Setosa\n",
" - Iris-Versicolour\n",
" - Iris-Virginica\n",
" \n",
" :Summary Statistics:\n",
"\n",
" ============== ==== ==== ======= ===== ====================\n",
" Min Max Mean SD Class Correlation\n",
" ============== ==== ==== ======= ===== ====================\n",
" sepal length: 4.3 7.9 5.84 0.83 0.7826\n",
" sepal width: 2.0 4.4 3.05 0.43 -0.4194\n",
" petal length: 1.0 6.9 3.76 1.76 0.9490 (high!)\n",
" petal width: 0.1 2.5 1.20 0.76 0.9565 (high!)\n",
" ============== ==== ==== ======= ===== ====================\n",
"\n",
" :Missing Attribute Values: None\n",
" :Class Distribution: 33.3% for each of 3 classes.\n",
" :Creator: R.A. Fisher\n",
" :Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)\n",
" :Date: July, 1988\n",
"\n",
"The famous Iris database, first used by Sir R.A. Fisher. The dataset is taken\n",
"from Fisher's paper. Note that it's the same as in R, but not as in the UCI\n",
"Machine Learning Repository, which has two wrong data points.\n",
"\n",
"This is perhaps the best known database to be found in the\n",
"pattern recognition literature. Fisher's paper is a classic in the field and\n",
"is referenced frequently to this day. (See Duda & Hart, for example.) The\n",
"data set contains 3 classes of 50 instances each, where each class refers to a\n",
"type of iris plant. One class is linearly separable from the other 2; the\n",
"latter are NOT linearly separable from each other.\n",
"\n",
".. topic:: References\n",
"\n",
" - Fisher, R.A. \"The use of multiple measurements in taxonomic problems\"\n",
" Annual Eugenics, 7, Part II, 179-188 (1936); also in \"Contributions to\n",
" Mathematical Statistics\" (John Wiley, NY, 1950).\n",
" - Duda, R.O., & Hart, P.E. (1973) Pattern Classification and Scene Analysis.\n",
" (Q327.D83) John Wiley & Sons. ISBN 0-471-22361-1. See page 218.\n",
" - Dasarathy, B.V. (1980) \"Nosing Around the Neighborhood: A New System\n",
" Structure and Classification Rule for Recognition in Partially Exposed\n",
" Environments\". IEEE Transactions on Pattern Analysis and Machine\n",
" Intelligence, Vol. PAMI-2, No. 1, 67-71.\n",
" - Gates, G.W. (1972) \"The Reduced Nearest Neighbor Rule\". IEEE Transactions\n",
" on Information Theory, May 1972, 431-433.\n",
" - See also: 1988 MLC Proceedings, 54-64. Cheeseman et al\"s AUTOCLASS II\n",
" conceptual clustering system finds 3 classes in the data.\n",
" - Many, many more ...\n"
]
}
],
"source": [
"print(iris_dataset.DESCR)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {
"tags": [
"hide-input"
]
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
" \n",
" \n",
" \n",
" sepal length (cm) \n",
" sepal width (cm) \n",
" petal length (cm) \n",
" petal width (cm) \n",
" class \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 5.10 \n",
" 3.50 \n",
" 1.40 \n",
" 0.20 \n",
" setosa \n",
" \n",
" \n",
" 1 \n",
" 4.90 \n",
" 3.00 \n",
" 1.40 \n",
" 0.20 \n",
" setosa \n",
" \n",
" \n",
" 2 \n",
" 4.70 \n",
" 3.20 \n",
" 1.30 \n",
" 0.20 \n",
" setosa \n",
" \n",
" \n",
" 3 \n",
" 4.60 \n",
" 3.10 \n",
" 1.50 \n",
" 0.20 \n",
" setosa \n",
" \n",
" \n",
" 4 \n",
" 5.00 \n",
" 3.60 \n",
" 1.40 \n",
" 0.20 \n",
" setosa \n",
" \n",
" \n",
" 72 \n",
" 6.30 \n",
" 2.50 \n",
" 4.90 \n",
" 1.50 \n",
" versicolor \n",
" \n",
" \n",
" 73 \n",
" 6.10 \n",
" 2.80 \n",
" 4.70 \n",
" 1.20 \n",
" versicolor \n",
" \n",
" \n",
" 74 \n",
" 6.40 \n",
" 2.90 \n",
" 4.30 \n",
" 1.30 \n",
" versicolor \n",
" \n",
" \n",
" 75 \n",
" 6.60 \n",
" 3.00 \n",
" 4.40 \n",
" 1.40 \n",
" versicolor \n",
" \n",
" \n",
" 76 \n",
" 6.80 \n",
" 2.80 \n",
" 4.80 \n",
" 1.40 \n",
" versicolor \n",
" \n",
" \n",
" 145 \n",
" 6.70 \n",
" 3.00 \n",
" 5.20 \n",
" 2.30 \n",
" virginica \n",
" \n",
" \n",
" 146 \n",
" 6.30 \n",
" 2.50 \n",
" 5.00 \n",
" 1.90 \n",
" virginica \n",
" \n",
" \n",
" 147 \n",
" 6.50 \n",
" 3.00 \n",
" 5.20 \n",
" 2.00 \n",
" virginica \n",
" \n",
" \n",
" 148 \n",
" 6.20 \n",
" 3.40 \n",
" 5.40 \n",
" 2.30 \n",
" virginica \n",
" \n",
" \n",
" 149 \n",
" 5.90 \n",
" 3.00 \n",
" 5.10 \n",
" 1.80 \n",
" virginica \n",
" \n",
" \n",
"
\n"
],
"text/plain": [
""
]
},
"execution_count": 71,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import numpy as np\n",
"\n",
"# Class colors\n",
"COLORS = \"rgba(255, 0, 0, 0.3)\", \"rgba(0, 255, 0, 0.3)\", \"rgba(0, 0, 255, 0.3)\"\n",
"\n",
"# Create a unified dataframe.\n",
"data = pd.concat([X, y], axis=\"columns\")\n",
"\n",
"\n",
"# Set class background color\n",
"def set_class_color(class_index: str) -> str:\n",
" return f\"background-color: {COLORS[class_index]};\"\n",
"\n",
"\n",
"def set_class_name(class_index: str) -> str:\n",
" return iris_dataset.target_names[class_index]\n",
"\n",
"\n",
"# Select some sample indices\n",
"sample_indices = np.linspace(0, len(data) - 5, 3, dtype=int)\n",
"sample_indices = [index for i in sample_indices for index in range(i, i + 5)]\n",
"\n",
"# Display table\n",
"data.iloc[sample_indices, :].style.background_gradient().map(lambda x: set_class_color(x), subset=[TARGET_NAME]).format(\n",
" {TARGET_NAME: set_class_name}).set_properties(**{\n",
" \"border\": \"1px solid black\"\n",
" }, subset=[TARGET_NAME]).set_properties(**{\n",
" \"text-align\": \"center\"\n",
" }).set_table_styles([\n",
" dict(selector=\"th\", props=[(\"font-size\", \"14px\")]),\n",
" dict(selector=\"td\", props=[(\"font-size\", \"12px\")]),\n",
" ]).format(\"{:.2f}\", subset=[col for col in data.columns if col != TARGET_NAME])"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"RangeIndex: 150 entries, 0 to 149\n",
"Data columns (total 4 columns):\n",
" # Column Non-Null Count Dtype \n",
"--- ------ -------------- ----- \n",
" 0 sepal length (cm) 150 non-null float64\n",
" 1 sepal width (cm) 150 non-null float64\n",
" 2 petal length (cm) 150 non-null float64\n",
" 3 petal width (cm) 150 non-null float64\n",
"dtypes: float64(4)\n",
"memory usage: 4.8 KB\n"
]
}
],
"source": [
"X.info()"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" sepal length (cm) \n",
" sepal width (cm) \n",
" petal length (cm) \n",
" petal width (cm) \n",
" \n",
" \n",
" \n",
" \n",
" count \n",
" 150.00 \n",
" 150.00 \n",
" 150.00 \n",
" 150.00 \n",
" \n",
" \n",
" mean \n",
" 5.84 \n",
" 3.06 \n",
" 3.76 \n",
" 1.20 \n",
" \n",
" \n",
" std \n",
" 0.83 \n",
" 0.44 \n",
" 1.77 \n",
" 0.76 \n",
" \n",
" \n",
" min \n",
" 4.30 \n",
" 2.00 \n",
" 1.00 \n",
" 0.10 \n",
" \n",
" \n",
" 25% \n",
" 5.10 \n",
" 2.80 \n",
" 1.60 \n",
" 0.30 \n",
" \n",
" \n",
" 50% \n",
" 5.80 \n",
" 3.00 \n",
" 4.35 \n",
" 1.30 \n",
" \n",
" \n",
" 75% \n",
" 6.40 \n",
" 3.30 \n",
" 5.10 \n",
" 1.80 \n",
" \n",
" \n",
" max \n",
" 7.90 \n",
" 4.40 \n",
" 6.90 \n",
" 2.50 \n",
" \n",
" \n",
"
\n",
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from matplotlib.colors import ListedColormap\n",
"\n",
"cmap = ListedColormap([(1, 0, 0), (0, 1, 0), (0, 0, 1)])\n",
"_ = pd.plotting.scatter_matrix(X,\n",
" c=y,\n",
" cmap=cmap,\n",
" figsize=(15, 15),\n",
" marker='o',\n",
" hist_kwds={\n",
" 'bins': 20,\n",
" 'alpha': 0.8\n",
" },\n",
" s=60,\n",
" alpha=0.4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Train/Test Split"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```{admonition} [Train-Test Split](https://machinelearningmastery.com/train-test-split-for-evaluating-machine-learning-algorithms/)\n",
" :class: note\n",
"A lot can be said regarding the different approaches for model validation and evaluation (which we'll discuss later in the course), but the general guideline is that, since our model should detect underlying trends in the data, we would evaluate its performance over unseen data. Therefore, we'll split our data into a training (for model fitting) and testing (for evaluation).\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.model_selection import train_test_split\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X,\n",
" y,\n",
" random_state=0,\n",
" test_size=0.25)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"tags": [
"remove-input"
]
},
"outputs": [
{
"data": {
"application/papermill.record/text/plain": "112"
},
"metadata": {
"scrapbook": {
"mime_prefix": "application/papermill.record/",
"name": "n_train"
}
},
"output_type": "display_data"
},
{
"data": {
"application/papermill.record/text/plain": "38"
},
"metadata": {
"scrapbook": {
"mime_prefix": "application/papermill.record/",
"name": "n_test"
}
},
"output_type": "display_data"
}
],
"source": [
"from myst_nb import glue\n",
"\n",
"glue(\"n_train\", len(X_train), display=False)\n",
"glue(\"n_test\", len(X_test), display=False)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We now have a training dataset consisting of {glue:}`n_train` observations and a test dataset with {glue:}`n_test` observations."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Model Creation"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```{admonition} [Models and Estimators](https://scikit-learn.org/stable/getting_started.html)\n",
" :class: note\n",
"Machine Learning algorithms and models are easily accesible through numberous packages, namely [scikit-learn](https://scikit-learn.org/stable/index.html). While different estimators provide different advantages and pitfalls, they share some basic properties, making it easy for users to use them.\n",
"\n",
"*Since these estimators are basically just algorithms and formulas that need to be tailored to the dataset being used, all estimators have a 'fit' method, (unsurprisingly) fitting the estimators to generalize to any specific data.\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.neighbors import KNeighborsClassifier\n",
"\n",
"k = 1\n",
"\n",
"knn = KNeighborsClassifier(n_neighbors=k)\n",
"_ = knn.fit(X_train, y_train)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Model Evaluation"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Misclassification Rate / Accuracy"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
" \n",
" \n",
" Accuracy is defined as 1-error rate. It is used as a statistical measure of how well a classification test performes.\n",
" \n",
" Wikipedia\n",
" \n",
" \n",
" \n",
" "
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"y_predicted = knn.predict(X_test)\n",
"\n",
"misclassification_rate = np.mean(y_predicted != y_test) * 100"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"tags": [
"remove-input"
]
},
"outputs": [
{
"data": {
"application/papermill.record/text/plain": "'2.632'"
},
"metadata": {
"scrapbook": {
"mime_prefix": "application/papermill.record/",
"name": "misclassification_rate"
}
},
"output_type": "display_data"
},
{
"data": {
"application/papermill.record/text/plain": "37"
},
"metadata": {
"scrapbook": {
"mime_prefix": "application/papermill.record/",
"name": "n_correct"
}
},
"output_type": "display_data"
}
],
"source": [
"glue(\"misclassification_rate\", f\"{misclassification_rate:.3f}\", display=False)\n",
"glue(\"n_correct\", (y_predicted == y_test).sum(), display=False)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Our model achieved a misclassification_rate of {glue:}`misclassification_rate`%, meaning it correctly predicted {glue:}`n_correct` of {glue:}`n_test` target values in our test set.\n",
"\n",
"Another way to look at it is:"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.metrics import accuracy_score"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"97.36842105263158"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"accuracy_score(y_test, y_predicted) * 100"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Confusion Matrix"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
" \n",
" \n",
" A confusion matrix is a table that is often used to describe the performance of a classification model on a set of data for which the true values are known.\n",
" \n",
" Medium\n",
" \n",
" \n",
" \n",
" "
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.metrics import confusion_matrix"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[13, 0, 0],\n",
" [ 0, 15, 1],\n",
" [ 0, 0, 9]])"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"confusion_matrix(y_test, y_predicted)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"from sklearn.metrics import ConfusionMatrixDisplay\n",
"\n",
"\n",
"disp = ConfusionMatrixDisplay.from_estimator(knn,\n",
" X_test,\n",
" y_test,\n",
" display_labels=iris_dataset.target_names,\n",
" cmap=plt.cm.Blues,\n",
" normalize=\"true\")\n",
"_ = disp.ax_.set_title(f\"Confusion Matrix (k={k})\")"
]
}
],
"metadata": {
"celltoolbar": "Tags",
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.2"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
![\"KNN](\"https://upload.wikimedia.org/wikipedia/commons/thumb/e/e7/KnnClassification.svg/1024px-KnnClassification.svg.png\")
![\"Sepal](\"https://miro.medium.com/max/362/1*XN85Vu-SmkJc3TkwgTx5Kw.jpeg\")
![\"Accuracy\"](\"https://wikimedia.org/api/rest_v1/media/math/render/svg/f0453f2614cd29f5dd49c2c9a0ef807985128e9e\")
![\"Confusion](\"https://miro.medium.com/v2/resize:fit:640/format:webp/1*qcK0IMq6gxIsoKzaTmSYiw.jpeg\")