机器学习7------k近邻
输入:实例的特征向量
输出:类别
懒惰学习(lazy learning)的代表算法
文章目录
- 机器学习7------k近邻
- 1.k近邻
- 2.模型------距离,k,分类规则
-
- 2.1距离------相似程度的反映
- [2.2 k值](#2.2 k值)
- 分类规则
- 算法实现------kd树
1.k近邻
少数服从多数,物以类聚
和这个实例最近的那几个实例,属于哪个类别的多,这个实例就是这个类别的
这个最近。二维举例,就是确定某个距离,画圆,圆内所有实例参与比较
算法
input:训练集T,要判断类别的实例x
output:实例x的类别
步骤:
- 根据具体的距离度量,找T中和x最近的k个实例,这k个实例构成Nk(x)
判断依据的范围
- 根据分类规则,判断x的类别
2.模型------距离,k,分类规则
2.1距离------相似程度的反映
2.2 k值
决定了那些实例决定判断结果
过小的k值会使模型对噪声敏感,容易过拟合
近似误差 :简化了模型
主要源于近似模型的局限性。由于真实模型往往非常复杂,难以直接求解或处理,所以采用较为简单的近似模型。而这种简化过程必然会导致与真实模型存在一定的偏差。
例如,在数值计算中,用有限项的泰勒级数去逼近一个函数,由于舍去了高阶无穷小项,就会产生近似误差。
估计误差 :一方面是由于样本的随机性。我们通常只能通过有限的样本数据来进行估计,而样本只是总体的一个部分,具有随机性,不能完全代表总体,从而导致估计值与真实值之间存在误差。
另一方面,估计方法的选择也会影响估计误差。不同的估计方法可能会产生不同大小的估计误差。
分类规则
通常是多数表决
算法实现------kd树
kd树:组织k维数据的二叉树,常用于高维空间的最近邻搜索、范围查询等问题。它通过将数据集递归划分为不同的维度,构建一棵可以快速查询的树结构。
对特征空间的划分
构造平衡kd树
-
选择维度 :从数据集中选择一个轴(或维度)来划分数据。
常见的策略是每次选择不同的维度,以轮流划分不同的维度空间。
通常,这个轴是数据点的某个坐标轴,例如 x 轴或 y 轴。在每一层递归中,选择的轴通常是当前节点深度d对n取余的结果,其中 n 是数据的维度。 -
选择分割点 :在选定的轴上,找到一个切分点,该切分点将数据集分为两部分。常见的选择是中位数
这可以平衡树的构造,使得左右子树中的数据量大致相同。
-
创建节点:用选定的切分点创建一个 kd 树的节点,并将数据集分为两部分,一部分包含所有在该轴上小于切分点的点,另一部分包含所有在该轴上大于切分点的点。
-
递归构建:将数据点按中位数划分为两部分,左子树包含小于中位数的点,右子树包含大于中位数的点。然后在剩余的数据上重复此过程,选择下一个维度继续递归构建。
示例
假设我们有一系列二维点:points = [(3, 6), (17, 15), (13, 15), (6, 12), (9, 1), (2, 7), (10, 19)]
- 首先,我们选择 x 轴作为第一层的划分轴,因为当前深度d=0,n=2,d%n=0对应 x 轴。
这里有的时候也会叫做第0层
根据x轴的数值排序[(2, 7), (3, 6), (6, 12), (9, 1), (10, 19), (13, 15), (17, 15)],中位数点为 (9, 1),作为根节点。如果双数的数据量,中间两个随便哪个都可以,但整个过程最好都一致,比如都选右侧的
- 第2层(选择y轴,即第2维度);
左子树:[(2, 7), (3, 6), (6, 12)]------对左子树按y轴排序,中位数点为 (2, 7)
右子树:[(10, 19), (13, 15), (17, 15)]------对右子树按y轴排序,中位数点为 (13, 15)- 第3层(选择x轴)左子树继续递归:
[(3, 6), (6, 12)]------中位数点为 == (6, 12)==
右子树为 == (17, 15)==
p
结果
x (9, 1)
/ \
y (2, 7) (13, 15)
/ / \
x (6, 12) (10, 19) (17, 15)
/
y(3, 6)
代码
python
class Node:
def __init__(self, point, left=None, right=None):
self.point = point # 节点存储的点
self.left = left # 左子树
self.right = right # 右子树
def create_kd_tree(data, depth=0):
if not data:
return None
# 选择切分轴(根据深度选择维度)
k = len(data[0]) # 数据的维度
axis = depth % k # 当前的切分轴
# 对数据按照切分轴的值进行排序,并选择中位数对应的点作为切分点
data.sort(key=lambda x: x[axis])
median = len(data) // 2 # 中位数的索引
# 创建节点,并递归地创建子树
return Node(
point=data[median],
left=create_kd_tree(data[:median], depth + 1),
right=create_kd_tree(data[median + 1:], depth + 1)
)
# 示例数据(每个点是二维空间中的一个坐标)
points = [(2, 3), (5, 4), (1, 8), (4, 7), (6, 3), (5, 2)]
kd_tree = create_kd_tree(points)
# 函数用于打印Kd树(递归)
def print_kd_tree(node, depth=0, prefix="Root"):
if node is not None:
print(f"{prefix}('x{depth % 2 + 1}': {node.point})")
print_kd_tree(node.left, depth + 1, prefix="L---")
print_kd_tree(node.right, depth + 1, prefix="R---")
# 打印Kd树
print_kd_tree(kd_tree)
搜索kd树------最近邻搜索
- 从根节点开始:将查询点与根节点进行比较。
- 决定搜索方向:根据查询点在当前分割轴上的值与节点在该轴上的值的比较结果,决定是向左子树搜索还是向右子树搜索
- 递归搜索:在选定的子树中递归地执行步骤1和2,直到达到叶子节点。
- 回溯:在回溯过程中,检查是否有可能在之前跳过的子树中找到更近的邻居。这通常涉及到检查当前节点的另一个子树(如果之前没有搜索过),并考虑是否有可能在该子树中找到比当前最近点更近的点。这通常通过计算一个"边界框"的距离来实现,该边界框包围了未搜索的子树中的所有点。
- 更新最近点:如果在搜索过程中找到了比当前最近点更近的点,则更新最近点。
- 继续回溯:继续回溯,直到回到根节点。
假设我们使用KD树进行最近邻查找,查询点是 (12, 8)。具体过程如下:
p
x (9, 1)
/ \
y (2, 7) (13, 15)
/ / \
x (6, 12) (10, 19) (17, 15)
/
y(3, 6)
根节点比较 :我们在x轴上选择 (9, 1) 作为根节点,比较 (12, 8) 在右边12>9,因此进入右子树。
第二层比较 :在y轴上比较,选择的点是 (13, 15),查询点 (12, 8) 位于左侧8<15,因此进入左子树。
第三层比较 :进入x轴上选择 (10, 19),查询点 (12, 8) 在右侧12>10,进入右子树(没有,开始回溯)。
叶节点返回 :到达叶节点后,返回当前最近邻点(此时为 (10, 19))。
回溯 :回溯到(13, 15),发现更近,更新当前最近邻点(此时为(13, 15))
查看另一子树 :查看(17, 15),不更新,继续回溯
到根节点: (9, 1),还是(13, 15),所以结果是(13, 15)
python
# 导入数学库用于计算距离
import math
# 定义KD树节点类
class KDNode:
def __init__(self, point, axis=0):
# 节点存储的数据点
self.point = point
# 左子树
self.left = None
# 右子树
self.right = None
# 划分维度
self.axis = axis
# 构建KD树
def build_kd_tree(points, depth=0):
# 如果当前数据集为空,则返回空节点
if not points:
return None
# 根据深度确定划分维度
axis = depth % len(points[0])
# 按照当前维度排序数据点
points.sort(key=lambda point: point[axis])
# 找到中位数的位置
median_idx = len(points) // 2
# 创建当前维度的节点
node = KDNode(points[median_idx], axis)
# 递归构建左子树
node.left = build_kd_tree(points[:median_idx], depth + 1)
# 递归构建右子树
node.right = build_kd_tree(points[median_idx + 1:], depth + 1)
# 返回当前节点
return node
# 打印KD树结构
def print_kd_tree(node, depth=0):
if node is None:
return
# 缩进显示层次结构
indent = " " * depth
print(f"{indent}Point: {node.point}, Axis: {node.axis}")
# 递归打印左子树
print_kd_tree(node.left, depth + 1)
# 递归打印右子树
print_kd_tree(node.right, depth + 1)
# 在KD树中搜索最近邻点
def search_kd_tree(node, target, best=None):
if node is None:
return best
# 当前节点的划分维度
axis = node.axis
# 根据目标点与当前节点在划分维度上的值决定先访问哪一侧
if target[axis] < node.point[axis]:
next_node = node.left
other_node = node.right
else:
next_node = node.right
other_node = node.left
# 递归搜索下一层
best = search_kd_tree(next_node, target, best)
# 更新最佳结果
if best is None or distance(target, node.point) < distance(target, best):
best = node.point
# 计算目标点与当前节点在划分维度上的距离
dist = abs(target[axis] - node.point[axis])
# 如果这个距离小于当前最佳结果的距离,则需要检查另一侧
if dist < distance(target, best):
best = search_kd_tree(other_node, target, best)
return best
# 计算两点之间的欧氏距离
def distance(p1, p2):
return math.sqrt(sum((a - b)**2 for a, b in zip(p1, p2)))
# 定义一组二维数据点
points = [(3, 6), (17, 15), (13, 15), (6, 12), (9, 1), (2, 7), (10, 19)]
# 构建KD树
root = build_kd_tree(points)
# 打印KD树结构
print("KD Tree:")
print_kd_tree(root)
# 定义一个目标点
target_point = (12, 8)
# 在KD树中搜索最近邻点
result = search_kd_tree(root, target_point)
# 输出结果
print(f"Nearest point to {target_point}: {result}")