【机器学习】7 ——k近邻算法

机器学习7------k近邻

输入:实例的特征向量

输出:类别

懒惰学习(lazy learning)的代表算法


文章目录


1.k近邻

少数服从多数,物以类聚

和这个实例最近的那几个实例,属于哪个类别的多,这个实例就是这个类别的
这个最近。二维举例,就是确定某个距离,画圆,圆内所有实例参与比较

算法

input:训练集T,要判断类别的实例x

output:实例x的类别

步骤:

  1. 根据具体的距离度量,找T中和x最近的k个实例,这k个实例构成Nk(x)判断依据的范围
  2. 根据分类规则,判断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}")
相关推荐
HyperAI超神经2 小时前
【TVM 教程】使用 Tensorize 来利用硬件内联函数
人工智能·深度学习·自然语言处理·tvm·计算机技术·编程开发·编译框架
扫地的小何尚3 小时前
NVIDIA RTX 系统上使用 llama.cpp 加速 LLM
人工智能·aigc·llama·gpu·nvidia·cuda·英伟达
埃菲尔铁塔_CV算法6 小时前
深度学习神经网络创新点方向
人工智能·深度学习·神经网络
艾思科蓝-何老师【H8053】6 小时前
【ACM出版】第四届信号处理与通信技术国际学术会议(SPCT 2024)
人工智能·信号处理·论文发表·香港中文大学
秀儿还能再秀6 小时前
机器学习——简单线性回归、逻辑回归
笔记·python·学习·机器学习
weixin_452600697 小时前
《青牛科技 GC6125:驱动芯片中的璀璨之星,点亮 IPcamera 和云台控制(替代 BU24025/ROHM)》
人工智能·科技·单片机·嵌入式硬件·新能源充电桩·智能充电枪
学术搬运工7 小时前
【珠海科技学院主办,暨南大学协办 | IEEE出版 | EI检索稳定 】2024年健康大数据与智能医疗国际会议(ICHIH 2024)
大数据·图像处理·人工智能·科技·机器学习·自然语言处理
右恩7 小时前
AI大模型重塑软件开发:流程革新与未来展望
人工智能
图片转成excel表格7 小时前
WPS Office Excel 转 PDF 后图片丢失的解决方法
人工智能·科技·深度学习
ApiHug8 小时前
ApiSmart x Qwen2.5-Coder 开源旗舰编程模型媲美 GPT-4o, ApiSmart 实测!
人工智能·spring boot·spring·ai编程·apihug