Python 中的 k-Nearest最近邻 (kNN) 算法 |【生长吧！Python】

目录

在本教程中，您将全面介绍 Python 中的 k-最近邻 (kNN) 算法。kNN 算法是最著名的机器学习算法之一，绝对是您机器学习工具箱中的必备品。Python 是机器学习的首选编程语言，所以有什么比使用 Python 著名的软件包NumPy和scikit-learn更好地发现 kNN 的方法了！

下面，您将在理论和实践中探索 kNN 算法。虽然许多教程跳过了理论部分，只关注库的使用，但您不希望依赖自动化包来进行机器学习。了解机器学习算法的机制以了解它们的潜力和局限性非常重要。

同时，了解如何在实践中使用算法也很重要。考虑到这一点，在本教程的第二部分，您将重点介绍 kNN 在 Python 库 scikit-learn 中的使用，以及将性能提升到最大的高级技巧。

在本教程中，您将学习如何：

• 直观地和数学地解释kNN 算法
• 使用NumPy从头开始在 Python 中实现 kNN
• 通过scikit-learn在 Python 中使用 kNN
• 使用以下方法调整kNN 的超参数GridSearchCV
• 添加装袋到k近邻有更好的表现

机器学习基础

为了让您参与进来，有必要退后一步，对机器学习进行总体快速调查。在本节中，您将了解机器学习背后的基本思想，并了解 kNN 算法与其他机器学习工具的关系。

机器学习的一般思想是获得一个模型，从任何主题的历史数据中学习趋势，并能够在未来在可比数据上重现这些趋势。这是一个概述基本机器学习过程的图表：

kNN 是一种有监督的机器学习算法

的机器学习算法的第一确定属性是之间的分裂监督和无监督模式。监督模型和无监督模型之间的区别在于问题陈述。

在监督模型中，您同时拥有两种类型的变量：

1. 甲目标变量，其也被称为从属变量或y变量。
2. 自变量，也称为x变量或解释变量。

目标变量是您要预测的变量。这取决于自变量，它不是您提前知道的。自变量是您提前知道的变量。您可以将它们代入方程以预测目标变量。这样一来，就比较像y = ax + bcase了。

在您之前看到的图表和本节的以下图表中，目标变量是数据点的形状，自变量是高度和宽度。您可以在下图中看到监督学习背后的想法：

在这个图中，每个数据点都有一个高度、一个宽度和一个形状。有十字形、星形和三角形。右边是机器学习模型可能已经学到的决策规则。

在这种情况下，标有十字的观测值高但不宽。星星又高又宽。三角形很短，但可以宽也可以窄。从本质上讲，该模型已经学习了一个决策规则，仅根据其高度和宽度来确定观察结果是否更有可能是十字形、星形或三角形。

在无监督模型中，目标变量和自变量之间没有分裂。无监督学习试图通过评估数据点的相似性来对数据点进行分组。

正如您在示例中看到的那样，您永远无法确定分组的数据点从根本上属于一起，但只要分组有意义，它在实践中就非常有价值。您可以在下图中看到无监督学习背后的想法：

在此图中，观测值不再具有不同的形状。他们都是圈子。然而，它们仍然可以根据点之间的距离分为三组。在这个特定的例子中，有三组点可以根据它们之间的空白空间分开。

kNN 算法是一种有监督的机器学习模型。这意味着它使用一个或多个自变量来预测目标变量。

要了解有关无监督机器学习模型的更多信息，请查看Python 中的 K-Means 聚类：实用指南。

kNN 是一种非线性学习算法

在机器学习算法中产生巨大差异的第二个属性是模型是否可以估计非线性关系。

线性模型是使用线或超平面进行预测的模型。在图像中，模型被描绘为在点之间绘制的线。该模型y = ax + b是线性模型的经典示例。您可以在以下示意图中看到线性模型如何拟合示例数据：

在这张图片中，数据点在左侧用星形、三角形和十字形表示。右边是一个线性模型，可以将三角形与非三角形分开。决定是一条线。线上方的每个点都是非三角形，线下方的所有点都是三角形。

如果您想向之前的图形添加另一个自变量，您需要将其绘制为一个附加维度，从而创建一个包含其中形状的立方体。然而，一条线无法将一个立方体切成两部分。线的多维对应物是超平面。因此，线性模型由超平面表示，在二维空间的情况下，它恰好是一条线。

非线性模型是使用除线以外的任何方法来分离案例的模型。一个众所周知的例子是决策树，它基本上是一长串 if ... else 语句。在非线性图中，if ... else 语句将允许您绘制正方形或您想绘制的任何其他形式。下图描述了应用于示例数据的非线性模型：

鲍鱼是一种看起来有点像贻贝的小海螺。如果您想了解更多关于它们的信息，您可以查看鲍鱼维基百科页面以获取更多信息。

>>> import pandas as pd
>>> url = (
...     "https://archive.ics.uci.edu/ml/machine-learning-databases"
...     "/abalone/abalone.data"
... )
>>> abalone = pd.read_csv(url, header=None)

在此代码中，您首先导入pandas，然后使用它来读取数据。您将路径指定为 URL，以便直接通过 Internet 获取文件。

为确保您已正确导入数据，您可以按如下方式进行快速检查：

>>> abalone.head()
   0      1      2      3       4       5       6      7   8
0  M  0.455  0.365  0.095  0.5140  0.2245  0.1010  0.150  15
1  M  0.350  0.265  0.090  0.2255  0.0995  0.0485  0.070   7
2  F  0.530  0.420  0.135  0.6770  0.2565  0.1415  0.210   9
3  M  0.440  0.365  0.125  0.5160  0.2155  0.1140  0.155  10
4  I  0.330  0.255  0.080  0.2050  0.0895  0.0395  0.055   7

这应该会显示鲍鱼数据集的前五行，在 Python 中作为 pandas DataFrame 导入。您可以看到列名仍然缺失。您可以abalone.names在 UCI 机器学习存储库的文件中找到这些名称。您可以将它们添加到您DataFrame的如下：

>>> abalone.columns = [
...     "Sex",
...     "Length",
...     "Diameter",
...     "Height",
...     "Whole weight",
...     "Shucked weight",
...     "Viscera weight",
...     "Shell weight",
...     "Rings",
... ]

导入的数据现在应该更容易理解了。但是您还应该做另一件事：您应该删除该Sex列。当前练习的目标是使用物理测量来预测鲍鱼的年龄。由于性别不是纯粹的物理测量，您应该将其从数据集中删除。您可以Sex使用.drop以下方法删除该列：

>>> abalone = abalone.drop("Sex", axis=1)

使用此代码，您可以删除该Sex列，因为它在建模中没有附加值。

鲍鱼数据集的描述性统计

在进行机器学习时，您需要了解正在处理的数据。在不深入的情况下，这里是一些探索性统计数据和图表。

本练习的目标变量是Rings，因此您可以从它开始。一个柱状图会给你一个快速的和有用的概述的年龄范围，你可以期望：

>>> import matplotlib.pyplot as plt
>>> abalone["Rings"].hist(bins=15)
>>> plt.show()

此代码使用Pandas 绘图功能生成包含 15 个 bin 的直方图。使用 15 个 bin 的决定是基于一些试验。在定义 bin 数量时，您通常尽量避免每个 bin 的观测值过多或过少。bin 太少会隐藏某些模式，而 bin 太多会使直方图缺乏平滑度。您可以在下图中看到直方图：

直方图显示数据集中的大多数鲍鱼有 5 到 15 个环，但也有可能达到 25 个环。较老的鲍鱼在该数据集中的代表性不足。这似乎很直观，因为由于自然过程，年龄分布通常会像这样倾斜。

第二个相关探索是找出哪些变量（如果有）与年龄有很强的相关性。自变量与您的目标变量之间的强相关性将是一个好兆头，因为这将确认身体测量值和年龄相关。

您可以在 中观察完整的相关矩阵correlation_matrix。最重要的相关性是与目标变量的相关性Rings。您可以像这样获得这些相关性：

>>> correlation_matrix = abalone.corr()
>>> correlation_matrix["Rings"]
Length            0.556720
Diameter          0.574660
Height            0.557467
Whole weight      0.540390
Shucked weight    0.420884
Viscera weight    0.503819
Shell weight      0.627574
Rings             1.000000
Name: Rings, dtype: float64

使用距离的数学定义来定义“最近”

要找到最接近您需要预测的点的数据点，您可以使用称为欧几里德距离的距离的数学定义。

要获得这个定义，您应该首先了解两个向量的差值是什么意思。下面是一个例子：

在这张图片中，您会看到两个数据点：(2,2) 处的蓝色和 (4,4) 处的绿色。要计算它们之间的距离，您可以从添加两个向量开始。向量a从点 (4,2) 到点 (4,4)，向量b从点 (4,2) 到点 (2,2)。他们的头由彩色点表示。请注意，它们呈 90 度角。

这些向量之间的区别是从 vectorc的头部到 vectora的头部的 vector b。矢量的长度c表示两个数据点之间的距离。

向量的长度称为范数。范数是一个正值，表示向量的大小。您可以使用欧几里得公式计算向量的范数：

在这个公式中，距离的计算方法是求每个维度的平方差，然后求这些值之和的平方根。在这种情况下，您应该计算差分向量的范数c以获得数据点之间的距离。

现在，要将其应用于您的数据，您必须了解您的数据点实际上是向量。然后，您可以通过计算差异向量的范数来计算它们之间的距离。

您可以使用linalg.norm()NumPy在 Python 中进行计算。下面是一个例子：

>>> import numpy as np
>>> a = np.array([2, 2])
>>> b = np.array([4, 4])
>>> np.linalg.norm(a - b)
2.8284271247461903

>>> X = abalone.drop("Rings", axis=1)
>>> X = X.values
>>> y = abalone["Rings"]
>>> y = y.values

此代码块生成两个现在包含您的数据的对象：X和y. X是自变量，y是模型的因变量。请注意，您使用大写字母表示，X但使用小写字母表示y。这通常在机器学习代码中完成，因为数学符号通常对矩阵使用大写字母，对向量使用小写字母。

现在，您可以k在具有以下物理测量值的新鲍鱼上应用= 3的 kNN ：

您可以为该数据点创建 NumPy 数组，如下所示：

>>> new_data_point = np.array([
...     0.569552,
...     0.446407,
...     0.154437,
...     1.016849,
...     0.439051,
...     0.222526,
...     0.291208,
... ])

下一步是使用以下代码计算这个新数据点与鲍鱼数据集中每个数据点之间的距离：

>>> distances = np.linalg.norm(X - new_data_point, axis=1)

您现在有一个距离向量，您需要找出三个最近的邻居。为此，您需要找到最小距离的 ID。您可以使用称为.argsort()从低到高对数组进行排序的方法，并可以取第一个k元素来获取k最近邻居的索引：

>>> k = 3
>>> nearest_neighbor_ids = distances.argsort()[:k]
>>> nearest_neighbor_ids
array([4045, 1902, 1644], dtype=int32)

这会告诉您哪三个邻居与您的new_data_point. 在下一段中，您将看到如何在估计中转换这些邻居。

多个邻居的投票或平均

确定了未知年龄鲍鱼的三个最近邻居的索引后，您现在需要将这些邻居合并到新数据点的预测中。

作为第一步，您需要找到这三个邻居的基本事实：

>>> nearest_neighbor_rings = y[nearest_neighbor_ids]
>>> nearest_neighbor_rings
array([ 9, 11, 10])

>>> prediction = nearest_neighbor_rings.mean()

>>> import scipy.stats
>>> class_neighbors = np.array(["A", "B", "B", "C"])
>>> scipy.stats.mode(class_neighbors)
ModeResult(mode=array(['B'], dtype='<U1'), count=array([2]))

>>> from sklearn.model_selection import train_test_split
>>> X_train, X_test, y_train, y_test = train_test_split(
...     X, y, test_size=0.2, random_state=12345
... )

该test_size指的是要放在训练数据和测试数据的观测次数。如果指定 a test_sizeof 0.2，test_size则将是原始数据的 20%，因此将其他 80% 保留为训练数据。

该random_state是一个参数，使您可以得到相同的结果每次代码运行的时间。train_test_split()在数据中进行随机拆分，这对于再现结果是有问题的。因此，通常使用random_state. in 值的选择random_state是任意的。

在上面的代码中，您将数据分为训练数据和测试数据。这是客观模型评估所必需的。您现在可以继续使用 scikit-learn 在训练数据上拟合 kNN 模型。

将 scikit-learn 中的 kNN 回归拟合到鲍鱼数据集

要拟合 scikit-learn 中的模型，您首先要创建一个正确类的模型。此时，您还需要为超参数选择值。对于 kNN 算法，您需要选择 的值k，该值n_neighbors在 scikit-learn 实现中调用。以下是在 Python 中执行此操作的方法：

>>> from sklearn.neighbors import KNeighborsRegressor
>>> knn_model = KNeighborsRegressor(n_neighbors=3)

您创建一个未拟合的模型knn_model。该模型将使用三个最近的邻居来预测未来数据点的值。要将数据导入模型，您可以在训练数据集上拟合模型：

>>> knn_model.fit(X_train, y_train)

>>> from sklearn.metrics import mean_squared_error
>>> from math import sqrt
>>> train_preds = knn_model.predict(X_train)
>>> mse = mean_squared_error(y_train, train_preds)
>>> rmse = sqrt(mse)
>>> rmse
1.65

在此代码中，您使用knn_model在前一个代码块中拟合的来计算 RMSE 。您现在计算训练数据的 RMSE。为了获得更真实的结果，您应该评估未包含在模型中的数据的性能。这就是您现在将测试集分开的原因。您可以使用与之前相同的函数来评估测试集上的预测性能：

>>> test_preds = knn_model.predict(X_test)
>>> mse = mean_squared_error(y_test, test_preds)
>>> rmse = sqrt(mse)
>>> rmse
2.37

>>> import seaborn as sns
>>> cmap = sns.cubehelix_palette(as_cmap=True)
>>> f, ax = plt.subplots()
>>> points = ax.scatter(
...     X_test[:, 0], X_test[:, 1], c=test_preds, s=50, cmap=cmap
... )
>>> f.colorbar(points)
>>> plt.show()

在此代码块中，您使用SeabornX_test通过子集数组X_test[:,0]和来创建第一列和第二列的散点图X_test[:,1]。请记住，前两列是Length和Diameter。正如您在相关表中看到的那样，它们具有很强的相关性。

您用于c指定test_preds应将预测值 ( ) 用作颜色条。该参数s用于指定散点图中点的大小。您用于cmap指定cubehelix_palette颜色映射。要了解有关使用 Matplotlib 绘图的更多信息，请查看Python Plotting With Matplotlib。

使用上面的代码，你会得到下图：

在该图中，每个点都是测试集中的一个鲍鱼，其实际长度和实际直径分别位于 X 轴和 Y 轴上。点的颜色反映了预测的年龄。您可以看到鲍鱼越长越大，其预测年龄越高。这是合乎逻辑的，这是一个积极的信号。这意味着您的模型正在学习一些看起来正确的东西。

要确认实际鲍鱼数据中是否存在这种趋势，您可以通过简单地替换用于 的变量来对实际值执行相同操作c：

>>> cmap = sns.cubehelix_palette(as_cmap=True)
>>> f, ax = plt.subplots()
>>> points = ax.scatter(
...     X_test[:, 0], X_test[:, 1], c=y_test, s=50, cmap=cmap
>>> )
>>> f.colorbar(points)
>>> plt.show()

此代码使用 Seaborn 创建带有颜色条的散点图。它产生以下图形：

这证实了您的模型正在学习的趋势确实有意义。

您可以为七个自变量的每个组合提取可视化。对于本教程，这会太长，但不要犹豫，尝试一下。唯一需要更改的是散点图中指定的列。

这些可视化是七维数据集的二维视图。如果你和他们一起玩，它会让你很好地理解模型正在学习什么，也许，它没有学习什么或学习错误。

使用 scikit-learn 在 Python 中调整和优化 kNN

有多种方法可以提高您的预测分数。通过使用data wrangling 处理输入数据可以进行一些改进，但在本教程中，重点是 kNN 算法。接下来，您将了解改进建模管道算法部分的方法。

>>> from sklearn.model_selection import GridSearchCV
>>> parameters = {"n_neighbors": range(1, 50)}
>>> gridsearch = GridSearchCV(KNeighborsRegressor(), parameters)
>>> gridsearch.fit(X_train, y_train)
GridSearchCV(estimator=KNeighborsRegressor(),
             param_grid={'n_neighbors': range(1, 50),
                         'weights': ['uniform', 'distance']})

在这里，您使用GridSearchCV拟合模型。简而言之，GridSearchCV在一部分数据上反复拟合 kNN 回归器，并在数据的其余部分上测试性能。重复执行此操作将产生对每个值的预测性能的可靠估计k。在此示例中，您将测试从1到的值50。

最后，它将保留 的最佳性能值k，您可以通过以下方式访问.best_params_：

>>> gridsearch.best_params_
{'n_neighbors': 25, 'weights': 'distance'}

在此代码中，您打印具有最低错误分数的参数。使用.best_params_，您可以看到选择25作为值k将产生最佳预测性能。现在您知道什么是最佳值k，您可以了解它如何影响您的训练和测试性能：

>>> train_preds_grid = gridsearch.predict(X_train)
>>> train_mse = mean_squared_error(y_train, train_preds_grid)
>>> train_rmse = sqrt(train_mse)
>>> test_preds_grid = gridsearch.predict(X_test)
>>> test_mse = mean_squared_error(y_test, test_preds_grid)
>>> test_rmse = sqrt(test_mse)
>>> train_rmse
2.0731294674202143
>>> test_rmse
2.1700197339962175

>>> parameters = {
...     "n_neighbors": range(1, 50),
...     "weights": ["uniform", "distance"],
... }
>>> gridsearch = GridSearchCV(KNeighborsRegressor(), parameters)
>>> gridsearch.fit(X_train, y_train)
GridSearchCV(estimator=KNeighborsRegressor(),
             param_grid={'n_neighbors': range(1, 50),
                         'weights': ['uniform', 'distance']})
>>> gridsearch.best_params_
{'n_neighbors': 25, 'weights': 'distance'}
>>> test_preds_grid = gridsearch.predict(X_test)
>>> test_mse = mean_squared_error(y_test, test_preds_grid)
>>> test_rmse = sqrt(test_mse)
>>> test_rmse
2.163426558494748

在这里，您测试使用不同的称重是否有意义GridSearchCV。应用加权平均而不是常规平均已将预测误差从 降低2.17到2.1634。虽然这不是一个巨大的改进，但它仍然更好，这使它值得。

使用 Bagging 进一步改进 scikit-learn 中的 kNN

作为 kNN 调优的第三步，您可以使用bagging。Bagging 是一种集成方法，或者是一种采用相对简单的机器学习模型并拟合大量这些模型的方法，每次拟合都有细微的变化。Bagging 经常使用决策树，但 kNN 也能完美运行。

集成方法通常比单个模型性能更高。一个模型可能会不时出错，但一百个模型的平均值应该不会出错。不同个体模型的误差很可能会相互平均，结果预测的可变性会更小。

您可以使用 scikit-learn 使用以下步骤将装袋应用于 kNN 回归。首先，创建KNeighborsRegressor具有最佳选择的k和weights您从中获得的GridSearchCV：

>>> best_k = gridsearch.best_params_["n_neighbors"]
>>> best_weights = gridsearch.best_params_["weights"]
>>> bagged_knn = KNeighborsRegressor(
...     n_neighbors=best_k, weights=best_weights
... )

然后BaggingRegressor从 scikit-learn导入类并100使用bagged_knn模型创建一个带有估计器的新实例：

>>> from sklearn.ensemble import BaggingRegressor
>>> bagging_model = BaggingRegressor(bagged_knn, n_estimators=100)

现在您可以进行预测并计算 RMSE 以查看它是否有所改善：

>>> test_preds_grid = bagging_model.predict(X_test)
>>> test_mse = mean_squared_error(y_test, test_preds_grid)
>>> test_rmse = sqrt(test_mse)
>>> test_rmse
2.1616

在此表中，您可以看到从最简单到最复杂的四个模型。复杂度的顺序对应于错误度量的顺序。带有随机的模型k表现最差，带有装袋的模型GridSearchCV表现最好。

鲍鱼预测可能会有更多改进。例如，可以寻找以不同方式处理数据的方法或查找其他外部数据源。

结论

现在您已经了解了 kNN 算法的所有知识，您已准备好开始在 Python 中构建高性能预测模型。从基本的 kNN 模型转变为完全调优的模型需要几步，但性能提升是完全值得的！

在本教程中，您学习了如何：

• 了解kNN 算法背后的数学基础
• 在NumPy 中从头开始编写kNN 算法
• 使用scikit-learn实现以最少的代码量拟合 kNN
• 使用GridSearchCV找到最好的k近邻超参数
• 按k近邻到其最大性能使用装袋

模型调优工具的一个好处是，它们中的许多不仅适用于 kNN 算法，而且还适用于许多其他机器学习算法。要继续您的机器学习之旅，请查看机器学习学习路径，并随时发表评论以分享您可能有的任何问题或评论。

【生长吧！Python】有奖征文火热进行中：https://bbs.huaweicloud.com/blogs/278897