统计学习——KNN
作者：互联网
一、KNN基本介绍
KNN，又叫K近邻法（k-nearest neighbor），是一种基本分类与回归方法，本篇主要介绍的分类方面应用。
它的基本原理是“物以类聚”，如果空间中某些样本具有近似的特征属性，则将它们归为一类，于是，训练数据集便把特征空间进行了划分，当有新的输入进来时，便去寻找和它最相似的k个样本，看这k个样本大多数属于哪一个类别，便把新的输入归为该样本。
二、KNN算法
k近邻算法简单、直观：给定一个训练数据集，对新的输入实例，在训练数据集中找到与该实例最邻近的k个实例，这k个实例的多数属于某一类，就把该输入实例分为这个类。下面先叙述k近邻算法，然后在讨论细节。
算法（knn）
输入：训练数据集
其中，\(x_i\in x \subseteq R^n\)为实例的特征向量，\(y_i \in Y = \{c_1,c_2,···,c_k\}\)为实例的类别，\(x\)为输入实例
输出：实例\(x\)所属的类\(y\)
(1) 根据给定的距离度量，在训练集\(T\)中找出与\(x\)最邻近的\(k\)个点，涵盖这\(k\)个点的\(x\)的邻域记作\(N_k(x)\)；
(2) 在\(N_k(x)\)中根据分类决策规则（如多数表决）决定\(x\)的类别\(y\):
这个公式实现的就是如果k个实例的多数属于某一类，就把该输入实例分为这个类。
k近邻法的特殊情况是\(k=1\)，称为最近邻算法。对于输入的实例点\(x\)，最近邻法将训练数据集中与\(x\)最近邻点的类作为\(x\)的类。
注意：k近邻法没有显示的学习过程，也就没有什么经验风险函数。
三、KNN模型
3.1模型
k近邻法，模型确定通常需要确定三个条件，即距离度量（如欧式距离）、k值、分类决策规则（如多数表决）。当这三个条件确定后，便可以对任何一个新的输入实例，它所属的类唯一地确定。其实就是通过上述的三个条件将特征空间划分为一些子空间，确定子空间里的每个点所属的类
3.2距离度量
特征空间中两个实例点的距离是两个实例点相似程度的反映。k近邻模型的特征空间一般是\(n\)维实数向量空间\(R^n\)。使用的距离是欧式距离，也可以是其他距离，如更一般的\(L_p\)距离。
设特征空间\(x\in R^n\)，\(x_i,x_j\in X\)，\(x_i = (x_i^{(1)},x_i^{(2)},···,x_i^{(n)})^T,x_j = (x_j^{(1)},x_j^{(2)},···,x_j^{(n)})^T\)，\(x_i,x_j\)的\(L_p\)距离定义为
这里\(p\geq1\)。当\(p=2\)时，称为欧式距离；当\(p=1\)时，称为曼哈顿距离。当\(p=\infty\)，它是各个坐标距离的最大值，即
\[L_{\infty}(x_i,x_j) = \max_l|x_i^{(l)}-x_j^{(l)}| \]如图给出了二维空间中p取不同值，与原点的\(L_p\)距离为1的点的图形。
例子：已知二维空间的三个点\(x_1 = (1,1)^T,x_2 = (5,1)^T,x_3 = (4,4)^T\)，试求在p取不同值时，\(L_p\)距离下\(x_1\)的最近邻点。
解：因为\(x_1，x_2\)只有第一维上值不同，所以\(p\)为任何值时，\(L_p(x_1,x_2) = 4\)。而
\[L_1(x_1,x_3) = 6,L_2(x_1,x_3) = 4.24,L_3(x_1,x_3) = 3.78,L_4(x_1,x_3) = 3.57 \]于是得到：\(p=1~or~p=2\)，\(x_2\)是\(x_1\)的最近邻点；\(p\geq3\)，\(x_3\)是\(x_1\)的最近邻点。
3.3\(~\)k值选择
k值的选择会对k近邻法的结果产生重大影响。如果选择较小的k值，就相当于用较小的邻域中的训练实例进行预测，“学习”的近似误差会减小，只有与输入实例较近的（相似的）训练实例才会对预测结果起作用。但缺点是“学习”的估计误差会增大，预测结果会对近邻的实例点非常敏感。如果邻近的实例点恰巧是噪声，预测就会出错。换句话说，k值的减小就意味着整体模型变得复杂，容易发生过拟合。
如果选择较大的k值，就相当于用较大邻域中的训练实例进行预测。其优点是可以减少学习的估计误差。但缺点是学习的近似误差会增大。这时与输入实例较远的（不相似的）训练实例也会对预测起作用，使预测发生错误。k值的增大就意味着整体的模型变得简单，会发生模型的欠拟合。
如果k＝N，那么无论输入实例是什么，都将简单地预测它属于在训练实例中最多的类。这时，模型过于简单，完全忽略训练实例中的大量有用信息，是不可取的。
在应用中，k值一般取一个比较小的数值。通常采用交叉验证法来选取最优的k值。
3.4分类决策规则
k近邻法中的分类决策规则往往是多数表决，即由输入实例的k个邻近的训练实例中的多数类决定输入实例的类。
4.KNN算法实现方式
4.1暴力实现
计算预测样本到所有训练集样本的距离，然后选择最小的k个距离即可得到k个最近邻点。缺点在于当特征数比较多、样本数比较多的时候，算法的执行效率比较低。
代码实现python：
取load_iris数据集中的sepal length，sepal width作为两大类，作为输入实例
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from collections import Counter
# data
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target
df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
# data = np.array(df.iloc[:100, [0, 1, -1]])
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()
plt.show()
data = np.array(df.iloc[:100, [0, 1, -1]])
X, y = data[:,:-1], data[:,-1]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
class KNN:
def __init__(self, X_train, y_train, n_neighbors=3, p=2):
"""
parameter: n_neighbors 临近点个数，这里取3
parameter: p 距离度量
"""
self.n = n_neighbors
self.p = p
self.X_train = X_train
self.y_train = y_train
def predict(self, X):
# 取出n个点
knn_list = []
for i in range(self.n):#初始化，先取训练数据中的前3个样本，存入knn_list列表中
dist = np.linalg.norm(X - self.X_train[i], ord=self.p)#求L2距离
knn_list.append((dist, self.y_train[i]))
for i in range(self.n, len(self.X_train)):#取列表中dist最大值与后面逐个比较
max_index = knn_list.index(max(knn_list, key=lambda x: x[0]))
dist = np.linalg.norm(X - self.X_train[i], ord=self.p)
if knn_list[max_index][0] > dist:#如果此时存在比列表中小的dist，则进表，
knn_list[max_index] = (dist, self.y_train[i])
# 统计
knn = [k[-1] for k in knn_list]
count_pairs = Counter(knn)#统计词频
# max_count = sorted(count_pairs, key=lambda x: x)[-1]
max_count = sorted(count_pairs.items(), key=lambda x: x[1])[-1][0]#这里是升序排序，最后要取列表中最后一个的第一个元素，即类别数最大的类别
return max_count
def score(self, X_test, y_test):#计算测试集的准确率
right_count = 0
n = 10
for X, y in zip(X_test, y_test):
label = self.predict(X)
if label == y:
right_count += 1
return right_count / len(X_test)
clf = KNN(X_train, y_train)
print(clf.score(X_test,y_test))
test_point = [6.0, 3.0]
print('Test Point: {}'.format(clf.predict(test_point)))
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.plot(test_point[0], test_point[1], 'bo', label='test_point')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()
plt.show()
4.2\(~\)KD树
为了提高k近邻搜索的效率，可以考虑使用特殊的结构存储训练数据，以减少计算距离的次数。具体方法很多，比如Ball Tree、BBF Tree、MVP Tree，下面介绍kd树的方法
4.2.1构造kd树
kd树是一种对k维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。kd树是二叉树，表示对k维空间的一个划分。构造kd树相当于不断地用垂直于坐标轴的超平面将k维空间切分，构成一系列的k维超矩形区域。kd树的每个结点对应于一个k维超矩形区域。
构造kd树的方法如下：构造根结点，使根结点对应于k维空间中包含所有实例点的超矩形区域；通过下面的递归方法，不断地对k维空间进行切分，生成子结点。在超矩形区域（结点）上选择一个坐标轴和在此坐标轴上的一个切分点，确定一个超平面，这个超平面通过选定的切分点并垂直于选定的坐标轴，将当前超矩形区域切分为左右两个子区域（子结点）；这时，实例被分到两个子区域。这个过程直到子区域内没有实例时终止（终止时的结点为叶结点）。在此过程中，将实例保存在相应的结点上。
通常，依次选择坐标轴对空间切分，选择训练实例点在选定坐标轴上的中位数
为切分点，这样得到的kd树是平衡的。注意，平衡的kd树搜索时的效率未必是最优的。
确实看不懂它在说什么，书上写的啥，下面直接给出算法和例题。
kd树算法
输入：k维空间数据集\(T = \{x_1,x_2,···,x_n\}\)，\(x_i \in R^k\)
(1) 开始：构造根节点，具体方法是选择\(x^{(1)}\)为坐标轴，找所有实例\(x^{(1)}\)坐标的中位数为切分点，然后切分由通过切分点并与坐标轴\(x^{(1)}\)垂直的超平面实现，根节点的切分将对应的超矩形区域切分为两个子区域。
由根节点生成深度为1的左右子节点：左节点对应坐标\(x^{(1)}\)小于切分点的子区域，右子节点对应于坐标\(x^{(1)}\)大于切分点的子区域。将落在切分超平面上的实例点保存在根结点。
(2) 重复：对深度为j的结点，选择\(x^{(l)}\)为切分的坐标轴，\(l=j ~mod ~k +1\)，以该结点的区域中所有实例\(x^{(l)}\)坐标的中位数为切分点，将该结点对应的超矩形区域切分为两个子区域。切分由通过切分点并与坐标轴\(x^{(l)}\)垂直的超平面实现。
(3) 直到两个子区域没有实例存在时停止。从而形成kd树的区域划分。
例子：给定一个二维空间的数据集：
\[T = \{(2,3)^T,(5,4)^T,(9,6)^T,(4,7)^T,(8,1)^T,(7,2)^T\} \]构造一个平衡kd树
解:先找根节点，即找中位数\(x^{(1)}\)的坐标：
\[T = \{(2,3)^T,(4,7)^T,(5,4)^T,(7,2)^T,(8,1)^T,(9,6)^T\} \]确定根节点是\((7,2)^T\)，分为左右子树：
\[Left:T_1=\{(2,3)^T,(4,7)^T,(5,4)^T\} \]\[Right:T_2=\{(8,1)^T,(9,6)^T\} \]在根据\(x^{(2)}\)进行左右子树中位数查询:
\[Left:T_1=\{(2,3)^T,(5,4)^T,(4,7)^T\} \]\[Right:T_2=\{(8,1)^T,(9,6)^T\} \]如此递归，可得如图空间划分图和kd树：
4.2.2\(~\)kd树搜索
下面介绍如何利用kd树进行k近邻搜索。这里介绍最近邻为例。
给定一个目标点，搜索其最近邻。首先找到包含目标点的叶结点；然后从该叶结点出发，依次回退到父结点；不断查找与目标点最邻近的结点。
包含目标点的叶结点对应包含目标点的最小超矩形区域。以此叶结点的实例点作为当前最近点。我们寻找就是还有没有其它的叶结点距离目标点更近，具体寻找方法就是以目标点为中心，半径为当前最近点到目标点的距离作一个超球体，然后看是否有其它叶结点存在于该超球体内部。
例子：给定如图所示的kd树，根节点为A，其子节点为B，C等。树上共存储7个实例点。目标点S，求S的最近邻。
解：首先在kd树中找到包含点S的叶结点D，以点D作为近似最近邻。真正最近邻一定在以点S为中心通过点D的圆的内部。然后返回结点D的父结点B，在结点B的另一子结点F的区域内搜索最近邻。结点F的区域与圆不相交，不可能有最近邻点。继续返回上一级父结点A，在结点A的另一子结点C的区域内搜索最近邻。结点C的区域与圆相交；该区域在圆内的实例点有点E，点E比点D更近，成为新的最近邻近似。最后得到点E是点S的最近邻。
算法（kd树的最近邻搜索）
输入：已构造的kd树；目标点x；
输出：x的最近邻。
(1) 在kd树中找出包含目标点x的叶结点：从根节点出发，递归地向下访问kd树。若目标点x当前维的坐标小于切分点的坐标，则移动到左子结点，否则移动到右子结点。直到子结点为叶结点为止。
(2) 以此叶结点为“当前最近点”。
(3) 递归地向上回退，在每个结点进行一下操作：
(a)如果该结点保存的实例点比当前最近点距离目标点更近，则以该实例点为“当前最近点”。
(b)当前最近点一定存在于该结点一个子结点对应的区域。检查该子结点的父结点的另一子结点对应的区域是否有更近的点。具体地，检查另一子结点对应的区域是否与以目标点为球心、以目标点与“当前最近点”间的距离为半径的超球体相交。
如果相交，可能在另一个子结点对应的区域内存在距目标点更近的点，移动到另一个子结点。接着，递归地进行最近邻搜索；
如果不相交，向上回退。
(4) 当回退到根结点时，搜索结束。最后的“当前最近点”即为x的最近邻点。
如果实例点是随机分布，kd树搜索的平均计算复杂度是\(O(logN)\)，这里\(N\)是训练实例数。kd树更适用于训练实例数远大于空间维数时的k近邻搜索。当空间维数接近训练实例数时，退化成线性扫描；
# kd-tree每个结点中主要包含的数据结构如下
class KdNode(object):
def __init__(self, dom_elt, split, left, right):
self.dom_elt = dom_elt # k维向量节点(k维空间中的一个样本点)
self.split = split # 整数（进行分割维度的序号）
self.left = left # 该结点分割超平面左子空间构成的kd-tree
self.right = right # 该结点分割超平面右子空间构成的kd-tree
class KdTree(object):
def __init__(self, data):
k = len(data[0]) # 数据维度
def CreateNode(split, data_set): # 按第split维划分数据集data_set创建KdNode
if not data_set: # 数据集为空
return None
data_set.sort(key=lambda x: x[split]) # 按要进行分割的那一维数据排序
split_pos = len(data_set) // 2 # 求中位数
median = data_set[split_pos] # 中位数分割点
split_next = (split + 1) % k # 循环重复求下一个分割点
# 递归的创建kd树
return KdNode(
median,
split,
CreateNode(split_next, data_set[:split_pos]), # 创建左子树
CreateNode(split_next, data_set[split_pos + 1:])) # 创建右子树
self.root = CreateNode(0, data) # 从第0维分量开始构建kd树,返回根节点
# KDTree的前序遍历
def preorder(root):
print(root.dom_elt)
if root.left: # 节点不为空
preorder(root.left)
if root.right:
preorder(root.right)
# 对构建好的kd树进行搜索，寻找与目标点最近的样本点：
from math import sqrt
from collections import namedtuple
# 定义一个namedtuple,分别存放最近坐标点、最近距离和访问过的节点数
result = namedtuple("Result_tuple",
"nearest_point nearest_dist nodes_visited")
def find_nearest(tree, point):
k = len(point) # 数据维度
def travel(kd_node, target, max_dist): # target 目标点
if kd_node is None: # kd树空,不存在
return result([0] * k, float("inf"),
0) # python中用float("inf")和float("-inf")表示正负无穷
nodes_visited = 1
s = kd_node.split # 进行分割的维度,一开始是第0维
pivot = kd_node.dom_elt # 进行分割的“轴”
if target[s] <= pivot[s]: # 如果目标点第s维小于分割轴的对应值(目标离左子树更近)
nearer_node = kd_node.left # 下一个访问节点为左子树根节点
further_node = kd_node.right # 同时记录下右子树
else: # 目标离右子树更近
nearer_node = kd_node.right # 下一个访问节点为右子树根节点
further_node = kd_node.left
temp1 = travel(nearer_node, target, max_dist) # 进行遍历找到包含目标点的区域
nearest = temp1.nearest_point # 找到以此叶结点作为“当前最近点”
dist = temp1.nearest_dist # 更新最近距离
nodes_visited += temp1.nodes_visited
if dist < max_dist:
max_dist = dist # 最近点将在以目标点为球心，max_dist为半径的超球体内
#----------------------------------------------------------------------
# 计算目标点与分割点的欧氏距离
temp_dist = sqrt(sum((p1 - p2)**2 for p1, p2 in zip(pivot, target)))
if temp_dist < dist: # 如果“更近”
nearest = pivot # 更新最近点
dist = temp_dist # 更新最近距离
max_dist = dist # 更新超球体半径
# 检查另一个子结点对应的区域是否有更近的点
temp2 = travel(further_node, target, max_dist)
nodes_visited += temp2.nodes_visited
if temp2.nearest_dist < dist: # 如果另一个子结点内存在更近距离
nearest = temp2.nearest_point # 更新最近点
dist = temp2.nearest_dist # 更新最近距离
return result(nearest, dist, nodes_visited)
return travel(tree.root, point, float("inf")) # 从根节点开始递归
data = [[2,3],[5,4],[9,6],[4,7],[8,1],[7,2]]
kd = KdTree(data)
print(preorder(kd.root))
ret = find_nearest(kd, [3,4.5])
print (ret)
[7, 2]
[5, 4]
[2, 3]
[4, 7]
[9, 6]
[8, 1]
Result_tuple(nearest_point=[2, 3], nearest_dist=1.8027756377319946, nodes_visited=4)
from time import perf_counter
from random import random
# 产生一个k维随机向量，每维分量值在0~1之间
def random_point(k):
return [random() for _ in range(k)]
# 产生n个k维随机向量
def random_points(k, n):
return [random_point(k) for _ in range(n)]
N = 400000
t0 = perf_counter()
kd2 = KdTree(random_points(3, N)) # 构建包含四十万个3维空间样本点的kd树
ret2 = find_nearest(kd2, [0.1,0.5,0.8]) # 四十万个样本点中寻找离目标最近的点
t1 = perf_counter()
print ("time: ",t1-t0, "s")
print (ret2)
time: 5.4623788 s
Result_tuple(nearest_point=[0.09929288205798159, 0.4954936771850429, 0.8005722800665575], nearest_dist=0.004597223680778027, nodes_visited=42)
标签：KNN,结点,kd,train,self,学习,实例,split,统计 来源： https://www.cnblogs.com/Ldemon/p/16486263.html