标签：KNN 结点 kd train self 学习 实例 split 统计
一、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
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。