Python机器学习基础教程 监督学习算法（二）

K近邻

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

1、k近邻分类

k-NN算法最简单的版本只考虑一个最近邻，也就是与我们想要预测的数据点最近的训练数据点。预测结果就是这个训练数据点的已知输出。

k近邻算法的应用，首先数据分为训练集和测试集，以便评估泛化性能

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)

然后，导入类并将其实例化，设定邻居个数，此处设为1

from sklearn.neighbors import KNeighborsClassifier

clf=KNeighborsClassifier(n_neighbors=1)

利用训练集对这个分类器进行拟合，对KNeighborsClassifier来说就是保存数据集，以便在预测时计算与邻居之间的距离，之前提到过，fit()方法是基于训练集构建模型

clf.fit(X_train,y_train)

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

print("Test set prediction:{}".format(clf.predict(X_test)))



Test set prediction:[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平面上画出所有可能的测试点的预测结果。根据平面中每个点所属的类别对平面进行着色，这样可以查看决策边界，就是算法对类别0和类别1的分界线

例中显示的1个，3个，9个邻居三种情况的决策边界可视化

import mglearn
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier

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=.5,ax=ax,alpha=.4)
    mglearn.discrete_scatter(X[:,0],X[:,1],y,ax=ax)
axes[0].legend(loc=3)

fig 表示图像，axes 表示子区域

plt.subplots(x,y,figsize(m,n)) 便与绘图

x表示行，y表示列，figsize表示图像大小，制定宽度和高度，默认英寸。例中表示1行三列，图像大小为10X3英寸

mglearn.plots.plot_2d_separator(clf,X,fill=True,eps=.5,ax=ax,alpha=.4)

ax表示绘制边界线

边界可视化，里面其余的参数在之前的文章里都有提到，在此不做过多分析

结论：随着邻居个数用来移动，决策边界也越来越平滑，更平滑的边界对应更简单的模型。也就是，使用更少的邻居对应更高的模型复杂度，而使用更多的邻居对应更低的模型复杂度。

假设考虑极端情况，即邻居个数等于训练集中所有数据点的个数，那么每个测试点的邻居都完全相同（即所有训练点），所有预测结果也完全相同（即训练集中出现次数最多的类别），接下来将讨论模型复杂度与泛化能力的关系，先将数据集分成训练集和测试集，然后用不同的邻居个数对训练集和测试集的性能进行评估。

import mglearn
from sklearn.datasets import load_breast_cancer
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

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=[]
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()

stratify=cancer.target 表示分层，以样本标签进行分层

stratify : array-like or None (default=None)
        If not None, data is split in a stratified fashion, using this as
        the class labels.

意思大概是：默认不存在，如果存在，则以分层的方式对数据进行分割，并将其作为类标签。

如果不设置random_state则每次拆分出的训练集、测试集是不同的，对于数据集的拆分，它本质上也是随机的，设置不同的随机状态（或者不设置random_state参数）可以彻底改变拆分的结果。

图像的x轴为n_neighbors，y轴是训练集精度和测试集精度。仅考虑单一近邻时，训练集上的预测结果十分完美，但随着邻居个数的增多，模型变得更简单，训练集精度也随之下降。单一邻居时的测试集精度比使用更多邻居时要低，这表示单一近邻的模型过于复杂，与之相反的是，当考虑十个邻居时，模型又过于简单，性能甚至变得更差。

3、k近邻回归

k近邻算法还可用于回归，在sklearn-learn的KNeighborsRegressor类中实现，其用法与KNeighborsClassifier类似

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

X,y=mglearn.datasets.make_wave(n_samples=40)
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state=0)
reg=KNeighborsRegressor(n_neighbors=3)
reg.fit(X_train,y_train)
print("Test set predictions:\n{}".format(reg.predict(X_test)))
print("Test set R^2:{:.2f}".format(reg.score(X_test,y_test)))



Test set predictions:
[-0.05396539  0.35686046  1.13671923 -1.89415682 -1.13881398 -1.63113382
  0.35686046  0.91241374 -0.44680446 -1.13881398]
Test set R^2:0.83

对于回归问题，这一方法返回的是R^2分数，也较决定系数，是回归模型预测的优度度量，位于0到1之间

4、分析KNeighborsRegressor

import mglearn
import numpy as np
from sklearn.neighbors import KNeighborsRegressor
from sklearn.model_selection import train_test_split

fig,axes=plt.subplots(1,3,figsize=(15,4))
line=np.linspace(-3,3,1000).reshape(-1,1)
for n_neighbors,ax in zip([1,3,9],axes):
    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,'^',c=mglearn.cm2(1),markersize=8)
    ax.set_title("{}neighbor(s)\n train score:{:.2f}test score:{:.2f}".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 prediction","Training data/target","Test data/target"],loc="best")

np.linspace(-3,3,1000).reshape(-1,1)

reshape(-1,1)表示可以根据指定的数值将数据转换为特定的行数和列数，-1表示未给定，多少行都可以，1表示列数，只有一列，当其中的数值发生改变时，相应的行数和列数也改变。

import numpy as np

line=np.linspace(-3,3,10)
print(line)
print(line.reshape(-1,1))
print(line.reshape(-1,2))
print(line.reshape(2,-1))



[-3.         -2.33333333 -1.66666667 -1.         -0.33333333  0.33333333
  1.          1.66666667  2.33333333  3.        ]

[[-3.        ]
 [-2.33333333]
 [-1.66666667]
 [-1.        ]
 [-0.33333333]
 [ 0.33333333]
 [ 1.        ]
 [ 1.66666667]
 [ 2.33333333]
 [ 3.        ]]

[[-3.         -2.33333333]
 [-1.66666667 -1.        ]
 [-0.33333333  0.33333333]
 [ 1.          1.66666667]
 [ 2.33333333  3.        ]]

[[-3.         -2.33333333 -1.66666667 -1.         -0.33333333]
 [ 0.33333333  1.          1.66666667  2.33333333  3.        ]]

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

5、优缺点和参数

优点：模型容易理解，通常不需要过多调节就可以得到不错的性能。构建最近邻模型的速度通常很快。

缺点：如果训练集很大，预测速度可能会比较慢。对于有很多特征的数据集往往效果很不好，对于稀疏数据集来说，这一算法很不好

参数：邻居个数和数据点之间距离的量度方法。