机器学习入门之K近邻法

Posted 2022-11-24 Jarlene

K近邻法

K-近邻法是一种基本分类与回归算法。K-近邻法的输入为实例特征向量，对应于特征空间的点；输出为实例的类别，可以去多类。
K-近邻算法直观、简单：给定一个训练数据集，对新的输入实例，在训练实例中找到与该实例最邻近的k个实例，这k个实例多数属于某一类别，就把该输入实例分为该实例。

K近邻法模型

---

K近邻法使用的模型实际上对应的是特征空间的划分。模型有三个基本要素：距离度量，k值的选择，分类决策规则。
K近邻法中，当训练数据集、距离度量、k值、分类决策规则确定后，对于任意一个新的输入实例，它所属的类别是唯一确定的。这相当于更加上述要素将特征空间划分为一个个的子空间。确定子空间每个实例点所属类别。
在特征空间中，对于每一个训练的实例点，距离改点比其他点更近的点组成一个区域叫做单元（Cell）。每一个实例点都拥有一个单元。所有实例点的单元构成对整个特征空间的划分。最邻近法是将实例的类作为其单元中所有点的类标记（class label）。这样每个实例点类别就是确定的。如图所示。

1、距离度量

特征空间中，两个实例点的距离是两个实例点相似度的反映，k邻近模型的特种空间一般是n维实数向量空间Rn. 使用的距离是欧式距离，但也可以使用其他的距离，更一般的Lp距离和Minkowski距离。

2、k值选择

k值的选择会对k邻近法的结果产生重大的影响，
当k值较小，就相当于用较小的邻域中中训练的实例进行预测，学习的近似误差会减小，只有于输入实例较近训练实例才会对预测结果起作用，但缺点是学习的估计误差会增大，预测结果会对邻近实例点非常敏感。K值的较小意味着整体模型的复杂，容易发生过拟合。
当k值较大，就相当于用较大邻域中的训练实例数据进行预测。其优点是可以减少学习估计误差，但缺点是学习的近似误差会增大， 离实例点较远的训练实例也会对预测起作用。K值增大意味着模型简单。
在实际应用中，k值一般取一个较小的数值，通常采用交叉验证法来取最优k值。

3、分类决策规则

k邻近法中，分类决策规则往往是多数表决。多数表决法解释：如果分类的损失函数为0-1损失函数，分类函数为：

那么误差概率为：

对给定的实例x∈X，其最邻近的k个训练实例点构成集合N_k(x).如果N_k(x)涵盖的区域类别为Cj，那么误分类的概率是：

要使误分类率最小即经验风险最小，那么

就要最大。所以多数表决规则等价于经验风险最小化。

Kd树

---

实现k近邻法时，主要考虑的问题是如何对训练数据进行快速的k近邻搜索，这点在特征空间的维数大及训练数据容量大时尤其必要。
k近邻法最简单的实现就是线性扫描。这时需要计算输入实例于每一个训练实例的距离，当训练数据集特别大的时候，这是非常耗时的。为了提高k近邻法搜索效率，可以使用特殊的结构存储训练数据。以减少计算距离的次数。也就是我们kd树。

1、构造kd树

kd树是一种对k维空间中实例点进行存储以便对其进行快速检索的树形数据结构。Kd树是二叉树，表示对k维空间的一个划分，构造kd树相当于不断用垂直于坐标轴的超平面将k维空间切分，构成一序列的k维超矩形区域，kd树的每个节点对应一个k维超矩形区域。
构造kd树的方法如下：
构造根结点，使根结点对应于k维空间中包含所有实例的超矩形区域；通过递归方法不断对k维空寂进行切分，生成子结点。
在超矩形区域上选择一个坐标轴和在此坐标轴上的一个切分点，确定一个超平面，这个超平面通过选定的切分点并垂直于选定的坐标轴，将当前的超矩形区域切分为左右两个区域；这时实例被分到来年各个子区域中，这个过程直到子区域内没有实例时终止。在此过程中将实例保存在相应的结点上。
通常，依次选择坐标轴对空间切分，庁训练实例点在选定坐标轴上的中位数为切分点，这样得到的kd树是平衡的，平衡的kd树搜索时的效率未必最优。
构造平衡kd树算法：
输入：k维空间数据集

其中

输出：kd树
（1） 开始：构造根结点，根结点对应于包含T的k维空间的超矩形区域。
选择为坐标轴，以T中所以实例的坐标的中位数切分点，将根结点对应的超矩形区域切分为两个子区域。切分由通过切分点与坐标轴垂直的超平面实现。由根结点生成深度为1的左右子结点：左子结点对应坐标小于切分点的子区域，右子结点对应于坐标大于切分点子区域。将落在切分超平面上的实例点保存在根结点。
（2） 重复：对深度为j的结点，选择为切分的坐标轴，l=j(mod k) + 1,
以该结点的区域中所有实例的坐标的中位数为切分点。将该结点对应的超矩形区域切分为两个子区域。切分由通过切分点并与坐标轴垂直的超平面实现。由该结点生成深度为j+1的左、右子结点：左子结点对应坐标小于切分点区域，右子结点对应于坐标大于切分点子区域。
（3） 直到两个子区域没有实例存在时停止，从而形成kd树的区域划分。

kd树搜索

---

以最近邻为例：给定一个目标，搜索其最邻近。首选找到包含目标点的叶结点。然后从该叶结点出发，一次回退到父结点；不断查找与目标最邻近的结点，当确定不可能存在更近的结点时终止。这样就搜索被限制在空间的局部区域上，大大提高效率。
用kd树最近邻搜索算法：
输入：已构造的kd树，目标点x
输出：x最近邻
（1） 在kd树中找出包含目标点x的叶结点；从根结点出发，递归地向下访问kd树，若目标点x当前的维的坐标小于切分点的坐标，则移动到左子结点，否则移到右子结点，直到子结点为叶结点为止。
（2） 以此叶结点为“当前最近点”
（3） 递归地向上回退，在每个节点进行以下操作：
（a）如果该结点保存的实例点比当前最近点距离目标点更近，则以该实例点为“当前最近点”
（b）当前最近点一定存在于该结点一个子结点对应的区域。检查该子结点的父结点的另一个子结点对应的区域是否有更近点。具体地，检查另一子结点对应的区域是否与目标点为球鞋，以目标点与“当前最近点”间的距离为班级超球体相交。如果相交，可能在另一个子结点对应的区域内存在距目标点更近的点，移动到另一个子结点，接着递归地进行最近邻搜索；如果不相交，向上回退。
当回退到根结点时，搜索结束。最后的“当前最近点”即为x的最近邻点。
如果实例点是随机分布的，kd树搜索的平均计算复杂度是O(logN)，这里N是训练实例数。kd树更适用于训练实例数远大于空间维数时的k近邻搜索。当空间维数接近训练实例数时，它的效率会迅速下降，几乎接近线性扫描。

最后附上kd树pyhton代码和搜索kd树python代码：

import copy
import itertools
from matplotlib import pyplot as plt
from matplotlib.patches import Rectangle
from matplotlib import animation

T = [[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2], [3, 5], [7, 2], [2, 7], [2, 5], [8, 2], [5, 9]]


def draw_point(data):
    X, Y = [], []
    for p in data:
        X.append(p[0])
        Y.append(p[1])
    plt.plot(X, Y, 'bo')


def draw_line(xy_list):
    for xy in xy_list:
        x, y = xy
        plt.plot(x, y, 'g', lw=2)


def draw_square(square_list):
    currentAxis = plt.gca()
    colors = itertools.cycle(["r", "b", "g", "c", "m", "y", '#EB70AA', '#0099FF'])
    for square in square_list:
        currentAxis.add_patch(
            Rectangle((square[0][0], square[0][1]), square[1][0] - square[0][0], square[1][1] - square[0][1],
                      color=next(colors)))


def median(lst):
    m = len(lst) / 2
    return lst[m], m


history_quare = []


def build_kdtree(data, d, square):
    history_quare.append(square)
    # sort
    data = sorted(data, key=lambda x: x[d])
    # balance point
    p, m = median(data)

    # delete point
    del data[m]
    print data, p

    if m >= 0:
        sub_square = copy.deepcopy(square)
        if d == 0:
            sub_square[1][0] = p[0]
        else:
            sub_square[1][1] = p[1]
        history_quare.append(sub_square)
        if m > 0:
            build_kdtree(data[:m], not d, sub_square)
    if len(data) > 1:
        sub_square = copy.deepcopy(square)
        if d == 0:
            sub_square[0][0] = p[0]
        else:
            sub_square[0][1] = p[1]
        build_kdtree(data[m:], not d, sub_square)


build_kdtree(T, 0, [[0, 0], [10, 10]])
print history_quare

# draw an animation to show how it works, the data comes from history
# first set up the figure, the axis, and the plot element we want to animate
fig = plt.figure()
ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
line, = ax.plot([], [], 'g', lw=2)
label = ax.text([], [], '')


# initialization function: plot the background of each frame
def init():
    plt.axis([0, 10, 0, 10])
    plt.grid(True)
    plt.xlabel('x_1')
    plt.ylabel('x_2')
    plt.title('build kd tree')
    draw_point(T)


currentAxis = plt.gca()
colors = itertools.cycle(["#FF6633", "g", "#3366FF", "c", '#EB70AA', "y",  '#0099FF', '#66FFFF', "m",])


# animation function.  this is called sequentially
def animate(i):
    square = history_quare[i]
    currentAxis.add_patch(
        Rectangle((square[0][0], square[0][1]), square[1][0] - square[0][0], square[1][1] - square[0][1],
                  color=next(colors)))
    return


# call the animator.  blit=true means only re-draw the parts that have changed.
anim = animation.FuncAnimation(fig, animate, init_func=init, frames=len(history_quare), interval=1000, repeat=False, blit=False)
plt.show()

T = [[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]]


class node:
    def __init__(self, point):
        self.left = None
        self.right = None
        self.point = point
        self.parent = None
        pass

    def set_left(self, left):
        if left == None: pass
        left.parent = self
        self.left = left

    def set_right(self, right):
        if right == None: pass
        right.parent = self
        self.right = right


def median(lst):
    m = len(lst) / 2
    return lst[m], m


def build_kdtree(data, d):
    data = sorted(data, key=lambda x: x[d])
    p, m = median(data)
    tree = node(p)

    del data[m]

    if m > 0: tree.set_left(build_kdtree(data[:m], not d))
    if len(data) > 1: tree.set_right(build_kdtree(data[m:], not d))
    return tree


def distance(a, b):
    print a, b
    return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) ** 0.5


def search_kdtree(tree, d, target):
    if target[d] < tree.point[d]:
        if tree.left != None:
            return search_kdtree(tree.left, not d, target)
    else:
        if tree.right != None:
            return search_kdtree(tree.right, not d, target)

    def update_best(t, best):
        if t == None: return
        t = t.point
        d = distance(t, target)
        if d < best[1]:
            best[1] = d
            best[0] = t

    best = [tree.point, 100000.0]
    while (tree.parent != None):
        update_best(tree.parent.left, best)
        update_best(tree.parent.right, best)
        tree = tree.parent
    return best[0]


kd_tree = build_kdtree(T, 0)
print search_kdtree(kd_tree, 1, [9, 4])