保留初心，砥砺前行

k-nearest neighbor, k-NN是一种可以用于多分类和回归的方法。knn是一个很简单的分类方法。

k近邻法的输入是实例的特征向量，也就是特征空间中的点；
k近邻法的输出是实例的类别，可以是多个类。

接下来本文将从：

• k近邻算法
• k近邻法的模型
• kd树

三个方面进行阐述。

1. k近邻算法

本文的第一句话，就已经非常明确地告诉了你，k-NN是用来做什么的。机器学习无非就是做这几件事而已，k-NN一下子就可以分类和回归，是不是很牛。

然后介绍了它的输入输出，这个时候你可能就一头雾水了——等等，我连它是什么都不清楚，怎么就输入输出了呢。别急，接下来我就开始介绍k近邻算法。

k近邻算法简单、直观：给定一个训练数据集（其中的实例类别已定），对新的输入实例，在训练数据集中找到与该实例最接近的k个实例，这k个实例的多数属于某个类，就把该输入实例分为这个类。

通过以上的话已经足够理解k近邻，如果说的再具象一些：

1. 我们需要输入一个这样的数据集
   T = {(x₁,y₁),(x₂,y₂),(x₃,y₃),···,(x_N,y_N)}
   其中x_i是实例的特征向量，y_i是x_i这个实例对应的类别，有可能是c₁，c₂，c₃，··· ， c_K。
   然后我们要再输入一个需要被分类的实例的特征向量x。

2. 根据给定的某种距离度量，在 T 中找到与x最接近的k个点。

3. 在k个点中根据某种分类的决策规则（例如，哪个类别多就是哪个类别）决定x的类别y。

4. 输出x的类别y。

从以上的叙述可以看出， k近邻是没有显式的学习过程的。

当 k近邻的k = 1时，成为最近邻算法。顾名思义，相信聪明的你肯定知道是什么意思了。

2. k近邻法的模型

在前边的介绍中的第2个步骤中，可以看到“某种距离度量”；第3步中有“某种决策规则”；还有k近邻的k究竟是多少。
以上这些都是在了解了 k近邻算法后我们会产生的问题。

没错，这三个问题就是k近邻法的3个基本要素。
下面，我们就从这3个基本要素，探究k近邻法的模型。

2.1. 距离度量

根据k近邻法的思路，我们输入的x与数据集中的某个x_i的相似程度，需要通过两个点的距离来反应。

一般使用的是欧氏距离，推广到更一般的情况是L_p距离。

L_p距离的定义是：

L_p(x_i,x_j) = (∑_l=1ⁿ|x_i^(l) – x_j^(l)|^p)^1/p

其中x_i,x_j为特征空间中的两个点。上式就代表了x_i和x_j间的L_p距离。

当p = 2时L_p距离就称为欧氏距离。
欧氏距离简单说就是两点的每一个维度的元素分别做差，再求平方和，最后开根号，是不是很容易。

2.2. k值的选择

算法名叫 k近邻，因此显而易见k值对于该算法的重要性。

先说结论： K值一般取一个较小的值，通常采用交叉验证法来选取最优的k值。

K值的选择会对k近邻法的结果产生较大的影响。

• 当k较小时：
  优点：学习的近似误差会减小。
  缺点：预测结果会对近邻的实例点非常敏感（我个人的理解是：例如，如果k = 2， 邻近的2个点恰好的不同类的情况下， 预测结果就会出错），k值的减小就意味着整体模型变得复杂，容易发生过拟合。

• 当k较大时：
  优点：减小学习的估计误差。
  缺点：学习的近似误差会增大，k值的增大意味着整体的模型变得简单，过于简单会完全忽略训练实例中的大量有用信息。

从上图可以看出，k = 3 与 k = 5 时的分类结果是不同的。然而k值并不会在学习过程中自动优化，而是在模型初始化是人为约定好的。因此
k值对于
k近邻至关重要，需要给予更多的关注。

2.3. 分类决策规则

一般是多数表决，就是说k个实例中哪个类别多，输入的x就是哪一类。

3. kd树

重头戏来了，在实现 k近邻时，需要计算输入x与数据集中的每一个x_i的距离，从而选择距离最小的k个。当训练集很大或维数很大时，计算会非常耗时。
因此为了提高 k近邻的效率，下面介绍kd树方法来存储训练数据，减少计算次数。

kd树是对k维空间中的实例点进行存储以便对其快速检索的二叉树数据结构，表示对k维空间的一种划分。

对构造kd树的语言描述晦涩难懂，因此直接上算法，再加上一个低维空间的例子，就可以搞懂它到底是怎么回事。

（以下算法描述只为了清晰易懂，并不是严禁的说法）

• 构造算法：
  输入：k维空间数据集T = {x₁, x₂, …, x_N},
  其中x_i = (x_i⁽¹⁾, x_i⁽²⁾, …, x_i^(k)), i = 1, 2, 3, …, N
  输出： kd树

1. 将所有实例点视作根节点。也就是说现在的根节点（为了叙述方便，起个别名叫做节点A）包含了整个k维空间。
2. 选择一条坐标轴x⁽¹⁾，l = j mod k + 1，其中j为节点的深度，k为空间的维度。
   将节点A中的所有的点的 x⁽¹⁾轴的中位数找出来，给它起个名字叫做切分点（选择中位数作为切分点叫做平衡kd树）。并且通过切分点画一个与x⁽¹⁾轴垂直的超平面，将节点A所表示的那个k维空间1分为2。
3. 把那些被划分到两个子空间的实例点放在2个子节点（节点B和节点C）上（坐标x⁽¹⁾小于切分点的点放在左子节点，大于的放在右子节点），那些恰巧落在切分超平面上的点，还保留在节点A中。
4. 上述的2和3步骤，也就是选择坐标轴，选择切分点，划分超平面的动作循环执行下去… …
   直到，某次划分的两个子区域没有实例点存在，就停止算法。至此，kd树形成。

• 例题：
  这个例题从低维出发，便于读者想象思考，高维同理。
  使用如下2维空间数据集：
  T = {(2, 3), (5, 4), (9, 6), (4, 7), (8, 1), (7, 2)}
  和上述算法构造一个平衡kd树。

对应上述算法的第1步

图-1 对应上述算法的第1步

将根节点1分为2，恰好落在超平面上的点保留在根节点，剩下的点按照划分进入左右子节点

图-2 将根节点1分为2，恰好落在超平面上的点保留在根节点，剩下的点按照划分进入左右子节点

继续上图的划分，在左右两个子节点的基础上继续划分，落在超平面上的点留下，分到两边的点进入下一层的左右子节点

图-3 继续上图的划分，在左右两个子节点的基础上继续划分，落在超平面上的点留下，分到两边的点进入下一层的左右子节点

最后一次划分，左右子节点已经没有实例点的存在了，算法结束

图-4 最后一次划分，左右子节点已经没有实例点的存在了，算法结束
图-5 kd树

• 搜索算法
  输入：经过上边的构造算法构造出来的kd树，目标点x
  输出：x的最近邻点

图-6 图解搜索算法

上图是构造kd树算法的输出结果，红点代表目标点x。也就是说我们要寻找红色目标点的最近邻。
首先在kd树中找到红色园点所在的子节点，也就是（4,7）那个点所在的叶子节点。
因此把（4,7）作为最邻近。并且以红色目标点为圆心，经过（4,7）画圆。从图中可以看出的是，真正的最近邻一定在这个圆的内部。
你可能会说，从这个图一下不就看出来内部有一个点吗。等等等等，这是你从上帝视角看的图，而真实的数据结构是一棵二叉树，并不是这张图，因此从树上是无法做出这种判断的。
接下来我们就要寻找比（4,7）距离红点更近的点。
根据kd树找到（4,7）父节点的另一个子节点，如果这个子节点的区域与圆不相交，这个子节点的区域就不会存在最近邻点，这种情况下就退回（4,7）父节点的父节点，继续以上的步骤。而从图-5可以看出（4,7）的兄弟节点是（2,3），就在圆内，因此最近邻节点由（4,7）变成（2,3）。因此就可以得到红色圆点的最近邻为（2,3）。
这是低维，少量数据的情况，只是为了清楚地解释搜索算法。可以推广到高维大量数据的情况，实相同的道理。

OK，理论结束，开始实践。
经过上述的讲解，我们已经知道，k近邻算法是没有显示的学习过程的，整个分类过程就是构建kd树和搜索kd树的过程。

k近邻实验，我们使用sklearn中内置的Iris数据集。它由150个实例组成，平均分为3个种类，每个种类50个实例。每个实例分别有4个属性描述。
下面从sklearn中导入Iris数据集的下载器，使用下载器下载数据存入变量iris中。

from sklearn.datasets import load_iris

iris = load_iris()

print iris.data.shape

(150, 4)

print iris.data   #打印数据集中的数据
print iris.target  #打印实例对应的类别

[[ 5.1  3.5  1.4  0.2]
 [ 4.9  3.   1.4  0.2]
 [ 4.7  3.2  1.3  0.2]
 [ 4.6  3.1  1.5  0.2]
... ...
... ...
篇幅原因，中间省略
一共150个实例
... ...
... ...
 [ 6.8  3.2  5.9  2.3]
 [ 6.7  3.3  5.7  2.5]
 [ 6.7  3.   5.2  2.3]
 [ 6.3  2.5  5.   1.9]
 [ 6.5  3.   5.2  2. ]
 [ 6.2  3.4  5.4  2.3]
 [ 5.9  3.   5.1  1.8]]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2]

接下来对数据集进行分割，需要强调的一点是，无论什么数据集，在分割训练集和测试集的时候一定要做到随机采样，避免相同特征的数据聚在一起的情况。

from sklearn.cross_validation import train_test_split

X_train, X_test, Y_train, Y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=33)

print 'X_train: ', X_train
print 'X_test: ', X_test
print 'Y_train: ', Y_train
print 'Y_test: ', Y_test

X_train:  [[ 5.   2.3  3.3  1. ]
 [ 4.9  3.1  1.5  0.1]
 [ 6.3  2.3  4.4  1.3]
 [ 5.8  2.6  4.   1.2]
... ...
... ...
... ...
 [ 5.6  3.   4.5  1.5]
 [ 7.7  3.   6.1  2.3]
 [ 5.4  3.4  1.7  0.2]]
X_test:  [[ 5.7  2.9  4.2  1.3]
 [ 6.7  3.1  4.4  1.4]
 [ 4.7  3.2  1.6  0.2]
 [ 6.5  2.8  4.6  1.5]
... ...
 [ 5.8  2.7  5.1  1.9]
 [ 5.7  3.   4.2  1.2]]
Y_train:  [1 0 1 1 1 0 0 1 0 2 0 0 1 2 0 1 2 2 1 1 0 0 2 0 0 2 1 1 2 2 2 2 0 0 1 1 0
 1 2 1 2 0 2 0 1 0 2 1 0 2 2 0 0 2 0 0 0 2 2 0 1 0 1 0 1 1 1 1 1 0 1 0 1 2
 0 0 0 0 2 2 0 1 1 2 1 0 0 1 1 1 0 1 1 0 2 2 2 1 2 0 1 0 0 0 2 1 2 1 2 1 2
 0]
Y_test:  [1 1 0 1 2 2 0 0 2 2 2 0 2 1 2 1 2 0 1 2 0 0 2 0 2 2 1 1 2 2 1 1 2 2 2 2 2
 1]

最后就是使用sklearn的k近邻分类器，对测试集进行分类测试：
KNeighborsClassifier函数默认k为5，经过测试，对于这个数据集，当k=7时效果最好。

# 导入数据标准化模块
from sklearn.preprocessing import StandardScaler
# 导入k近邻分类器
from sklearn.neighbors import KNeighborsClassifier
# 标准化训练集
ss = StandardScaler()
X_train = ss.fit_transform(X_train)
# 标准化测试集
X_test = ss.fit_transform(X_test)
# 将knn分类器赋给变量knn，并且参数中选择上文中讲的kd树
knn = KNeighborsClassifier(algorithm='kd_tree')
#knn = KNeighborsClassifier(n_neighbors=7, algorithm='kd_tree')
# Fit the model using X as training data and y as target values
knn.fit(X_train, Y_train)
# 输入测试集进行预测
y_predict = knn.predict(X_test)

print Y_test
print y_predict

第一行打印的是正确的结果
第二行打印的是knn模型预测的结果

[1 1 0 1 2 2 0 0 2 2 2 0 2 1 2 1 2 0 1 2 0 0 2 0 2 2 1 1 2 2 1 1 2 2 2 2 2 1]
[1 1 0 1 1 2 0 0 1 2 2 0 2 1 2 1 1 0 1 1 0 0 2 0 1 1 1 1 1 1 1 1 1 1 2 2 1 1]

错误率：e = 1/m ∑_i=1^mI(f(xi)≠yi)
由以上结果可以算出e = 10 / 36
模型精度1 – e

如果你也喜欢机器学习，并且也像我一样在ML之路上努力，请关注我，我会进行不定期更新，总有一些可以帮到你。

所有图片均来自网络