K最近邻(k-Nearest Neighbor，KNN)分类算法，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。该方法的思路是：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。

 

以下摘自李航《统计学习方法》。

3.1　k近邻算法

k近邻算法简单、直观：给定一个训练数据集，对新的输入实例，在训练数据集中找到与该实例最邻近的k个实例，这k个实例的多数属于某个类，就把该输入实例分为这个类。下面先叙述k近邻算法，然后再讨论其细节。

算法3.1（k近邻法）

输入：训练数据集

其中，x_i∊x⊆Rⁿ为实例的特征向量，y_i∊＝{c₁，c₂,…,c_K}为实例的类别，i＝1,2,…,N；实例特征向量x；

输出：实例x所属的类y。

（1）根据给定的距离度量，在训练集T中找出与x最邻近的k个点，涵盖这k个点的x的邻域记作N_k(x)；

（2）在N_k(x)中根据分类决策规则（如多数表决）决定x的类别y：

式（3.1）中，I为指示函数，即当y_i＝c_j时I为1，否则I为0。

k近邻法的特殊情况是k＝1的情形，称为最近邻算法。对于输入的实例点（特征向量）x，最近邻法将训练数据集中与x最邻近点的类作为x的类。

k近邻法没有显式的学习过程。

3.3k近邻法的实现：kd树

实现k近邻法时，主要考虑的问题是如何对训练数据进行快速k近邻搜索。这点在特征空间的维数大及训练数据容量大时尤其必要。

k近邻法最简单的实现方法是线性扫描（linear scan）。这时要计算输入实例与每一个训练实例的距离。当训练集很大时，计算非常耗时，这种方法是不可行的。

为了提高k近邻搜索的效率，可以考虑使用特殊的结构存储训练数据，以减少计算距离的次数。具体方法很多，下面介绍其中的kd树（kd tree）方法^[1]。

3.3.1　构造kd树

kd树是一种对k维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。kd树是二叉树，表示对k维空间的一个划分（partition）。构造kd树相当于不断地用垂直于坐标轴的超平面将k维空间切分，构成一系列的k维超矩形区域。kd树的每个结点对应于一个k维超矩形区域。

构造kd树的方法如下：构造根结点，使根结点对应于k维空间中包含所有实例点的超矩形区域；通过下面的递归方法，不断地对k维空间进行切分，生成子结点。在超矩形区域（结点）上选择一个坐标轴和在此坐标轴上的一个切分点，确定一个超平面，这个超平面通过选定的切分点并垂直于选定的坐标轴，将当前超矩形区域切分为左右两个子区域（子结点）；这时，实例被分到两个子区域。这个过程直到子区域内没有实例时终止（终止时的结点为叶结点）。在此过程中，将实例保存在相应的结点上。

通常，依次选择坐标轴对空间切分，选择训练实例点在选定坐标轴上的中位数（median）^[2]为切分点，这样得到的kd树是平衡的。注意，平衡的kd树搜索时的效率未必是最优的。

下面给出构造kd树的算法。

算法3.2（构造平衡kd树）

输入：k维空间数据集T＝{x₁，x₂,…,x_N}，

输出：kd树。

（1）开始：构造根结点，根结点对应于包含T的k维空间的超矩形区域。

选择x⁽¹⁾为坐标轴，以T中所有实例的x⁽¹⁾坐标的中位数为切分点，将根结点对应的超矩形区域切分为两个子区域。切分由通过切分点并与坐标轴x⁽¹⁾垂直的超平面实现。

由根结点生成深度为1的左、右子结点：左子结点对应坐标x⁽¹⁾小于切分点的子区域，右子结点对应于坐标x⁽¹⁾大于切分点的子区域。

将落在切分超平面上的实例点保存在根结点。

（2）重复：对深度为j的结点，选择x^(l)为切分的坐标轴，l＝j(modk)+1，以该结点的区域中所有实例的x^(l)坐标的中位数为切分点，将该结点对应的超矩形区域切分为两个子区域。切分由通过切分点并与坐标轴x^(l)垂直的超平面实现。

由该结点生成深度为j+1的左、右子结点：左子结点对应坐标x^(l)小于切分点的子区域，右子结点对应坐标x^(l)大于切分点的子区域。

将落在切分超平面上的实例点保存在该结点。

（3）直到两个子区域没有实例存在时停止。从而形成kd树的区域划分。

例3.2　给定一个二维空间的数据集：

构造一个平衡kd树^[3]。

解　根结点对应包含数据集T的矩形，选择x⁽¹⁾轴，6个数据点的x⁽¹⁾坐标的中位数是7，以平面x⁽¹⁾＝7将空间分为左、右两个子矩形（子结点）；接着，左矩形以x⁽²⁾＝4分为两个子矩形，右矩形以x⁽²⁾＝6分为两个子矩形，如此递归，最后得到如图3.3所示的特征空间划分和如图3.4所示的kd树。

下面叙述用kd树的最近邻搜索算法。

算法3.3（用kd树的最近邻搜索）

输入：已构造的kd树；目标点x；

输出：x的最近邻。

（1）在kd树中找出包含目标点x的叶结点：从根结点出发，递归地向下访问kd树。若目标点x当前维的坐标小于切分点的坐标，则移动到左子结点，否则移动到右子结点。直到子结点为叶结点为止。

（2）以此叶结点为“当前最近点”。

（3）递归地向上回退，在每个结点进行以下操作：

（a）如果该结点保存的实例点比当前最近点距离目标点更近，则以该实例点为“当前最近点”。

（b）当前最近点一定存在于该结点一个子结点对应的区域。检查该子结点的父结点的另一子结点对应的区域是否有更近的点。具体地，检查另一子结点对应的区域是否与以目标点为球心、以目标点与“当前最近点”间的距离为半径的超球体相交。

如果相交，可能在另一个子结点对应的区域内存在距目标点更近的点，移动到另一个子结点。接着，递归地进行最近邻搜索；

如果不相交，向上回退。

（4）当回退到根结点时，搜索结束。最后的“当前最近点”即为x的最近邻点。

如果实例点是随机分布的，kd树搜索的平均计算复杂度是O(logN)，这里N是训练实例数。kd树更适用于训练实例数远大于空间维数时的k近邻搜索。当空间维数接近训练实例数时，它的效率会迅速下降，几乎接近线性扫描。

 

 # coding:utf-8

 import numpy as np

 import matplotlib.pyplot as plt

 T = [[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]]

 S=[7, 3]

 class node:

     def __init__(self, point):

         self.left = None

         self.right = None

         self.point = point

         self.parent = None

         pass

     def set_left(self, left):

         if left == None: pass

         left.parent = self

         self.left = left

     def set_right(self, right):

         if right == None: pass

         right.parent = self

         self.right = right

 def median(lst):

     m = len(lst) / 2

     return lst[m], m

 def build_kdtree(data, d):

     data = sorted(data, key=lambda x: x[d])

     p, m = median(data)

     tree = node(p)

     del data[m]

     if m > 0: tree.set_left(build_kdtree(data[:m], not d))

     if len(data) > 1: tree.set_right(build_kdtree(data[m:], not d))

     return tree

 def distance(a, b):

     return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) ** 0.5

 def search_kdtree(tree, target,best=[]):

     if len(best)==0: best = [tree.point,distance(tree.point, target)]

     if target[0] < tree.point[0]:

         if tree.left != None:

             return search_kdtree(tree.left, target, best)

     else:

         if tree.right != None:

             return search_kdtree(tree.right, target, best)

     def update_best(t, best):

         if t == None: return

         t = t.point

         d = distance(t, target)

         if d < best[1]:

             best[1] = d

             best[0] = t

     while (tree.parent != None):

         update_best(tree.parent.left, best)

         update_best(tree.parent.right, best)

         tree = tree.parent

     return best[0]

 def showT(tree,d):

     plt.plot(tree.point[0],tree.point[1],'ob')

     if tree.parent==None:

         plt.plot([tree.point[0],tree.point[0]],[0,10])

     elif d:

         if tree.point[0]<tree.parent.point[0]:

             plt.plot([0,tree.parent.point[0]],[tree.point[1],tree.point[1]])

         else:

             plt.plot([tree.parent.point[0],10],[tree.point[1],tree.point[1]])

     else:

         if tree.point[1]<tree.parent.point[1]:

             plt.plot([tree.point[0],tree.point[0]],[0,tree.parent.point[1]])

         else:

             plt.plot([tree.point[0],tree.point[0]],[tree.parent.point[1],10])

     if tree.left != None:

         showT(tree.left,not d)

     if tree.right != None:

         showT(tree.right,not d)

 kd_tree = build_kdtree(T, 0)

 showT(kd_tree,0)

 plt.annotate('S',xy = (S[0],S[1]+0.2))

 plt.plot(S[0],S[1],'^r')

 result=search_kdtree(kd_tree,S)

 print result  #[7, 2]

 plt.show()