【机器学习】k近邻

ZhShy23

已于 2022-05-23 16:58:10 修改

阅读量671

点赞数

分类专栏：机器学习文章标签：机器学习人工智能数据挖掘

于 2022-01-23 20:46:22 首次发布

本文链接：https://blog.csdn.net/weixin_43651049/article/details/122643179

版权

机器学习专栏收录该内容

37 篇文章 35 订阅

订阅专栏

文章目录

1. k近邻分类
- 通过scikit-learn来应用k近邻算法。
2. 分析KNeighborsClassifier
- [k近邻 - forge]
- [k近邻 - cancer]
3. k近邻回归
4. 分析KNeighborsRegressor
5. 优点、缺点和参数
【完整代码】

k-NN算法可以说是最简单的机器学习算法。构建模型只需要保存训练数据集即可。想要对新数据点做出预测，算法会在训练数据集中找到最近的数据点，也就是它的“最近邻”。

1. k近邻分类

k-NN算法最简单的版本只考虑一个最近邻，也就是与我们想要预测的数据点最近的训练数据点。预测结果就是这个训练数据点的已知输出。
这种分类方法在forge数据集上的应用：

mglearn.plots.plot_knn_classification(n_neighbors=1)

在这里插入图片描述
这里我们添加了3个新数据点（用五角星表示）。对于每个新数据点，我们标记了训练集中与它最近的点。单一最近邻算法的预测结果就是那个点的标签（对应五角星的颜色）。

除了仅考虑最近邻，我还可以考虑任意个（k个）邻居。这也是k近邻算法名字的来历。在考虑多于一个邻居的情况时，我们用“投票法”（voting）来指定标签。也就是说，对于每个测试点，我们数一数多少个邻居属于类别0，多少个邻居属于类别1。然后将出现次数更多的类别（也就是k个近邻中占多数的类别）作为预测结果。
下面的例子用到了3个近邻：

mglearn.plots.plot_knn_classification(n_neighbors=3)

在这里插入图片描述
和上面一样，预测结果可以从五角星的颜色看出。你可以发现，左上角新数据点的预测结果与只用一个邻居时的预测结果不同。
虽然这张图对应的是一个二分类问题，但方法同样适用于多分类的数据集。对于多分类问题，我们数一数每个类别分别有多少个邻居，然后将最常见的类别作为预测结果。

通过scikit-learn来应用k近邻算法。

首先，将数据分为训练集和测试集，以便评估泛化性能：

import mglearn as mglearn
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

X, y = mglearn.datasets.make_forge()

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

然后，导入类并将其实例化。这时可以设定参数，比如邻居的个数。这里我们将其设为3：

from sklearn.neighbors import KNeighborsClassifier
clf = KNeighborsClassifier(n_neighbors=3)

现在，利用训练集对这个分类器进行拟合。对于KNeighborsClassifier来说就是保存数据集，以便在预测时计算与邻居之间的距离：

clf.fit(X_train, y_train)

调用predict方法来对测试数据进行预测。对于测试集中的每个数据点，都要计算它在训练集的最近邻，然后找出其中出现次数最多的类别：

print("Test set predictions: {}".format(clf.predict(X_test)))
---------------------------------
Test set predictions: [1 0 1 0 1 0 0]

为了评估模型的泛化能力好坏，我们可以对测试数据和测试标签调用score方法：

print("Test set accuracy: {.2f}".format(clf.score(X_test, y_test)))
------------------------------
Test set accuracy: 0.86

可以看到，我们的模型精度约为86%，也就是说，在测试数据集中，模型对其中86%的样本预测的类别都是正确的。

2. 分析KNeighborsClassifier

对于二维数据集，我们还可以在xy平面上画出所有可能的测试点的预测结果。我们根据平面中每个点所属的类别对平面进行着色。这样可以查看决策边界（decision boundary），即算法对类别0和类别1的分界线。

[k近邻 - forge]

下列代码分别将1个、3个和9个邻居三种情况的决策边界可视化:
k近邻-forge完整代码


fig, axes = plt.subplots(1, 3, figsize=(10, 3))
for n_neighbors, ax in zip([1, 3, 9], axes):
    clf = KNeighborsClassifier(n_neighbors=n_neighbors).fit(X, y)
    mglearn.plots.plot_2d_separator(clf, X, fill=True, eps=0.5, ax=ax, alpha=.4)
    mglearn.discrete_scatter(X[:, 0], X[:, 1], y, ax=ax)
    ax.set_title("{} neighbor(s)".format(n_neighbors))
    ax.set_xlabel("feature 0")
    ax.set_ylabel("feature 1")

axes[0].legend(loc=3)
plt.show()

在这里插入图片描述
从图上可以看出，使用单一邻居绘制的决策边界紧跟着训练数据。
随着邻居个数越来越多，决策边界也越来越平滑。更平滑的边界对应更简单的模型。

使用更少的邻居对应更高的模型复杂度（如图右侧所示）
使用更多的邻居对应更低的模型复杂度（如图左侧所示）。
假如考虑极端情况，即邻居个数等于训练集中所有数据点的个数，那么每个测试点的邻居都完全相同（即所有训练点），所有预测结果也完全相同（即训练集中出现次数最多的类别）。

[k近邻 - cancer]

k近邻 - cancer完整代码
研究一下能否证实之前讨论过的模型复杂度和泛化能力之间的关系。我们将在现实世界的乳腺癌数据集上进行研究。先将数据集分成训练集和测试集，然后用不同的邻居个数对训练集和测试集的性能进行评估。

import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    cancer.data, cancer.target, stratify=cancer.target, random_state=66
)

training_accuracy = []
test_accuracy = []
# n_neighbors取值从1到10
neighbors_settings = range(1, 11)
for n_neighbors in neighbors_settings:
    # 构建模型
    clf = KNeighborsClassifier(n_neighbors=n_neighbors)
    clf.fit(X_train, y_train)
    # 记录训练集精度
    training_accuracy.append(clf.score(X_train, y_train))
    # 记录泛化精度
    test_accuracy.append(clf.score(X_test, y_test))

plt.plot(neighbors_settings, training_accuracy, label="training accuracy")
plt.plot(neighbors_settings, test_accuracy, label="test accuracy")
plt.ylabel("Accuracy")
plt.xlabel("n_neighbors")
plt.legend()
plt.show()

在这里插入图片描述图像的x轴是n neighbors, y轴是训练集精度和测试集精度。虽然现实世界的图像很少有非常平滑的，但我们仍可以看出过拟合与欠拟合的一些特征.
仅考虑单一近邻时，训练集上的预测结果十分完美。但随着邻居个数的增多，模型变得更简单，训练集精度也随之下降。
单一邻居时的测试集精度比使用更多邻居时要低，这表示单一近邻的模型过于复杂。与之相反，当考虑10个邻居时，模型又过于简单，性能甚至变得更差。
最佳性能在中间的某处，邻居个数大约为6。最差的性能约为88%的精度，这个结果仍然可以接受。

3. k近邻回归

k近邻算法还可以用于回归。
k近邻 - wave完整代码
我们还是先从单一近邻开始，这次使用wave数据集。我们添加了3个测试数据点，在x轴上用绿色五角星表示。利用单一邻居的预测结果就是最近邻的目标值。在图中用蓝色五角星表示：

import matplotlib.pyplot as plt
import mglearn as mglearn

mglearn.plots.plot_knn_regression(n_neighbors=1)
plt.show()

在这里插入图片描述同样，也可以用多个近邻进行回归。在使用多个近邻时，预测结果为这些邻居的平均值：

mglearn.plots.plot_knn_regression(n_neighbors=3)

在这里插入图片描述用于回归的k近邻算法在scikit-learn的KNeighborsRegressor类中实现。其用法与KNeighborsClassifier类似：

from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor

X, y = mglearn.datasets.make_wave(n_samples=40)

# 将 wave 数据集分成训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

# 模型实例化，并将邻居个数设为 3
reg = KNeighborsRegressor(n_neighbors=3)
# 利用训练数据和训练目标来拟合模型
reg.fit(X_train, y_train)
# 对测试集进行预测：
print("Test set predicitions:\n{}".format(reg.predict(X_test)))

--------------------------------
Test set predicitions:
[-0.05396539  0.35686046  1.13671923 -1.89415682 -1.13881398 -1.63113382
  0.35686046  0.91241374 -0.44680446 -1.13881398]

我们还可以用score方法来评估模型，对于回归问题，这一方法返回的是 $R^2$ 分数。 $R^2$ 分数也叫作决定系数，是回归模型预测的优度度量，位于0到1之间。 $R^2$ 等于1对应完美预测，R2等于0对应常数模型，即总是预测训练集响应（y_train）的平均值：

print("Test set R^2: {:.2f}".format(reg.score(X_test,y_test)))
-------------------------------
Test set R^2: 0.83

这里的分数是0.83，表示模型的拟合相对较好

4. 分析KNeighborsRegressor

对于我们的一维数据集，可以查看所有特征取值对应的预测结果。为了便于绘图，我们创建一个由许多点组成的测试数据集：

import numpy as np

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
# 创建1000个数据点，在-3到3之间均匀分布
line = np.linspace(-3, 3, 1000).reshape(-1, 1)
for n_neighbors, ax in zip([1, 3, 9], axes):
    # 利用1个、3个、9个邻居分别进行预测
    reg = KNeighborsRegressor(n_neighbors=n_neighbors)
    reg.fit(X_train, y_train)
    ax.plot(line, reg.predict(line))
    ax.plot(X_train, y_train, '^', c=mglearn.cm2(0), markersize=8)
    ax.plot(X_test, y_test, 'v', c=mglearn.cm2(1), markersize=8)
    ax.set_title(
        "{} neighbor:(s)\n"
        "\t train score: {:.2f}\n"
        "\t test score: {:.2f}\n"
            .format(n_neighbors, reg.score(X_train, y_train), reg.score(X_test, y_test))
    )
    ax.set_xlabel("Feature")
    ax.set_ylabel("Target")

axes[0].legend(["Model predictions", "Training data/target", "Test data/target"], loc="best")
plt.show()

在这里插入图片描述从图中可以看出，仅使用单一邻居，训练集中的每个点都对预测结果有显著影响，预测结果的图像经过所有数据点。这导致预测结果非常不稳定。考虑更多的邻居之后，预测结果变得更加平滑，但对训练数据的拟合也不好。

5. 优点、缺点和参数

KNeighbors重要参数：

邻居个数
数据点之间距离的度量方法

在实践中，使用较小的邻居个数（比如3个或5个）往往可以得到比较好的结果，但你应该调节这个参数。

k-NN的优点之一就是模型很容易理解，通常不需要过多调节就可以得到不错的性能。在考虑使用更高级的技术之前，尝试此算法是一种很好的基准方法。

构建最近邻模型的速度通常很快，但如果训练集很大（特征数很多或者样本数很大），预测速度可能会比较慢。
使用k-NN算法时，对数据进行预处理是很重要的。这一算法对于有很多特征（几百或更多）的数据集往往效果不好，对于大多数特征的大多数取值都为0的数据集（所谓的稀疏数据集）来说，这一算法的效果尤其不好。

虽然k近邻算法很容易理解，但由于预测速度慢且不能处理具有很多特征的数据集，所以在实践中往往不会用到。

【完整代码】

1. k近邻 - forge代码

import mglearn as mglearn
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

X, y = mglearn.datasets.make_forge()

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

from sklearn.neighbors import KNeighborsClassifier

clf = KNeighborsClassifier(n_neighbors=3)
clf.fit(X_train, y_train)
print("Test set predictions: {}".format(clf.predict(X_test)))
print("Test set accuracy: {:.2f}".format(clf.score(X_test, y_test)))

# 画一个1*3的多图表，尺寸是10*3
fig, axes = plt.subplots(1, 3, figsize=(10, 3))
# 遍历 1个3个9个邻居 画布
for n_neighbors, ax in zip([1, 3, 9], axes):
    clf = KNeighborsClassifier(n_neighbors=n_neighbors).fit(X, y)
    mglearn.plots.plot_2d_separator(clf, X, fill=True, eps=0.5, ax=ax, alpha=.4)
    mglearn.discrete_scatter(X[:, 0], X[:, 1], y, ax=ax)
    ax.set_title("{} neighbor(s)".format(n_neighbors))
    ax.set_xlabel("feature 0")
    ax.set_ylabel("feature 1")

axes[0].legend(loc=3)
# loc参数：
# 0: ‘best'
# 1: ‘upper right'
# 2: ‘upper left'
# 3: ‘lower left'
# 4: ‘lower right'
# 5: ‘right'
# 6: ‘center left'
# 7: ‘center right'
# 8: ‘lower center'
# 9: ‘upper center'
# 10: ‘center'

plt.show()

2. k近邻 - cancer代码

import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
# stratify 拆分数据的方式
X_train, X_test, y_train, y_test = train_test_split(
    cancer.data, cancer.target, stratify=cancer.target, random_state=66
)

training_accuracy = []
test_accuracy = []
# n_neighbors取值从1到10
neighbors_settings = range(1, 11)
for n_neighbors in neighbors_settings:
    # 构建模型
    clf = KNeighborsClassifier(n_neighbors=n_neighbors)
    clf.fit(X_train, y_train)
    # 记录训练集精度
    training_accuracy.append(clf.score(X_train, y_train))
    # 记录泛化精度
    test_accuracy.append(clf.score(X_test, y_test))

plt.plot(neighbors_settings, training_accuracy, label="training accuracy")
plt.plot(neighbors_settings, test_accuracy, label="test accuracy")
plt.ylabel("Accuracy")
plt.xlabel("n_neighbors")
plt.legend()
plt.show()

3. k近邻回归 - Wave代码

import matplotlib.pyplot as plt
import mglearn as mglearn

# mglearn.plots.plot_knn_regression(n_neighbors=1)
# mglearn.plots.plot_knn_regression(n_neighbors=3)

# plt.show()


from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor

X, y = mglearn.datasets.make_wave(n_samples=40)

# 将 wave 数据集分成训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

# 模型实例化，并将邻居个数设为 3
reg = KNeighborsRegressor(n_neighbors=3)
# 利用训练数据和训练目标来拟合模型
reg.fit(X_train, y_train)
# 对测试集进行预测：
print("Test set predicitions:\n{}".format(reg.predict(X_test)))

print("Test set R^2: {:.2f}".format(reg.score(X_test, y_test)))

import numpy as np

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
# 创建1000个数据点，在-3到3之间均匀分布
line = np.linspace(-3, 3, 1000).reshape(-1, 1)
for n_neighbors, ax in zip([1, 3, 9], axes):
    # 利用1个、3个、9个邻居分别进行预测
    reg = KNeighborsRegressor(n_neighbors=n_neighbors)
    reg.fit(X_train, y_train)
    ax.plot(line, reg.predict(line))
    ax.plot(X_train, y_train, '^', c=mglearn.cm2(0), markersize=8)
    ax.plot(X_test, y_test, 'v', c=mglearn.cm2(1), markersize=8)
    ax.set_title(
        "{} neighbor:(s)\n"
        "\t train score: {:.2f}\n"
        "\t test score: {:.2f}\n"
            .format(n_neighbors, reg.score(X_train, y_train), reg.score(X_test, y_test))
    )
    ax.set_xlabel("Feature")
    ax.set_ylabel("Target")

axes[0].legend(["Model predictions", "Training data/target", "Test data/target"], loc="best")
plt.show()