k近邻理论与实践

保留初心,砥砺前行

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

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

接下来本文将从:

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

三个方面进行阐述。


1. k近邻算法

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

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

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

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

  1. 我们需要输入一个这样的数据集
    T = {(x1,y1),(x2,y2),(x3,y3),···,(xN,yN)}
    其中xi是实例的特征向量,yi是xi这个实例对应的类别,有可能是c1,c2,c3,··· , cK
    然后我们要再输入一个需要被分类的实例的特征向量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与数据集中的某个xi的相似程度,需要通过两个点的距离来反应。

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

Lp距离的定义是:

Lp(xi,xj) = (∑l=1n|xi(l) - xj(l)|p)1/p

其中xi,xj为特征空间中的两个点。上式就代表了xi和xj间的Lp距离。

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

2.2. k值的选择

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

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

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

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

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

k近邻理论与实践_第1张图片

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

2.3. 分类决策规则

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


3. kd

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

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

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

(以下算法描述只为了清晰易懂,并不是严禁的说法)

  • 构造算法:
    输入:k维空间数据集T = {x1, x2, ..., xN},
    其中xi = (xi(1), xi(2), ..., xi(k)), i = 1, 2, 3, ..., N
    输出: kd
  1. 将所有实例点视作根节点。也就是说现在的根节点(为了叙述方便,起个别名叫做节点A)包含了整个k维空间。
  2. 选择一条坐标轴x(1),l = j mod k + 1,其中j为节点的深度,k为空间的维度。
    将节点A中的所有的点的 x(1)轴的中位数找出来,给它起个名字叫做切分点(选择中位数作为切分点叫做平衡kd树)。并且通过切分点画一个与x(1)轴垂直的超平面,将节点A所表示的那个k维空间1分为2。
  3. 把那些被划分到两个子空间的实例点放在2个子节点(节点B和节点C)上(坐标x(1)小于切分点的点放在左子节点,大于的放在右子节点),那些恰巧落在切分超平面上的点,还保留在节点A中。
  4. 上述的2和3步骤,也就是选择坐标轴,选择切分点,划分超平面的动作循环执行下去... ...
    直到,某次划分的两个子区域没有实例点存在,就停止算法。至此,kd树形成。
  • 例题:
    这个例题从低维出发,便于读者想象思考,高维同理。
    使用如下2维空间数据集:
    T = {(2, 3), (5, 4), (9, 6), (4, 7), (8, 1), (7, 2)}
    和上述算法构造一个平衡kd树。

对应上述算法的第1步


k近邻理论与实践_第2张图片
图-1 对应上述算法的第1步

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


k近邻理论与实践_第3张图片
图-2 将根节点1分为2,恰好落在超平面上的点保留在根节点,剩下的点按照划分进入左右子节点

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


k近邻理论与实践_第4张图片
图-3 继续上图的划分,在左右两个子节点的基础上继续划分,落在超平面上的点留下,分到两边的点进入下一层的左右子节点

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


k近邻理论与实践_第5张图片
图-4 最后一次划分,左右子节点已经没有实例点的存在了,算法结束
k近邻理论与实践_第6张图片
图-5 kd树
  • 搜索算法
    输入:经过上边的构造算法构造出来的kd树,目标点x
    输出:x的最近邻点
k近邻理论与实践_第7张图片
图-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=1mI(f(xi)≠yi)
由以上结果可以算出e = 10 / 36
模型精度1 - e


如果你也喜欢机器学习,并且也像我一样在ML之路上努力,请关注我,我会进行不定期更新,总有一些可以帮到你。
k近邻理论与实践_第8张图片

所有图片均来自网络

你可能感兴趣的:(k近邻理论与实践)