机器学习笔记之KNN

KNN

k近邻法(k-nearest neighbor,k-NN) 是一种基本分类与回归方法。其算法如下：

K近邻模型

k近邻算法中，当训练集、距离度量、k值及分类决策规则确定之后，对于任何一个新的输入的实例，它所属的类唯一地确定。这相当于根据上述将特征空间划分为一些子空间，确定子空间的每个点所属的类。特征空间中，对每个训练实例点 $x_i$， 距离该点比其他点更近的所有点组成一个区域，叫做单元。每个训练实例点拥有一个单元，所有训练实例点的单元构成特征空间的一个划分。最近邻法（k=1时）将实例 $x_i$ 的类 $y_i$ 作为七单元中所有点的类标记。这样每个单元实例点的类别都是确定的。

KNN三要素

距离的度量

设特征空间 $\mathcal{X}$ 是n维实数向量空间 $R^n$, $x_i,x_j \in \mathcal{X}, x_i = {(x_i^{1},\cdots,x_i^n)^\top},x_j = {(x_j^1,\cdots,x_j^n)^\top}$, $x_i,x_j$ 的 $L_p$ 距离定义为：

$$L_p(x_i,x_j) = \big(\sum_{l=1}^n \big| x_i^l - x_j^l \big|^p\big)^{\frac{1}{p}}$$

• 当 $p = 1$ 时，称为曼哈顿距离(Manhattan distance)

• 当 $p = 2$ 时，称为欧式距离(Euclidean distance)

• 当 $p = \infty$ 时，就是去各个坐标的最大值，即:

$$L_\infty (x_i,x_j) = max{\big |x_i^l - x_j^l\big|}$$

用图表示如下：

k值的选择

k值较小意味着整体模型变得复杂，容易发生过拟合
k值较大相当于用较大邻域中的训练实例进行预测，较远的实例也会对预测起作用，容易使预测发生错误

分类决策规则

分类的损失函数为 0-1损失函数

误分类率为：

$$\frac{1}{k} \sum_{x_i \in N_k(x)} I(y_i \neq c_j) = 1 - \frac{1}{k} \sum_{x_i \in N_k(x)} I(y_i = c_j)$$

要使误分类率最小即经验最小，就要是的分类准确率最大即 $\frac{1}{k} \sum_{x_i \in N_k(x)} I(y_i = c_j)$ 最大，所以多数表决规则等价于经验风险最小化

kd-tree算法

输入： k维空间数据集 $T$
输出：kd-tree

1. 构造根节点，根节点对应于包含 $T$ 的 $k$维空间的超矩形区域. 选择$x^{(1)}$ 为坐标轴，以 $T$ 中所有实例的 $x^{(1)}$ 坐标的中位数为切分点，将根节点对应的超矩形区域切分为两个子区域。切分由通过切分点与坐标轴 $x^{(1)}$ 垂直的超平面实现，则左子节点对应坐标 $x^{(1)}$ 小于切分点的子区域，右节点对应的坐标则大于切分点的子区域
2. 递归的继续划分区域，直到两个子区域没有实例则停止

代码如下：

import os
class node(object):

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

def median(data):
    m = len(data)/2

    return data[m], m

def build_kd_tree(data,flag):

    data = sorted(data,key = lambda x: x[flag])

    print(data)

    p,m = median(data)

    tree = node(p)

    del data[m]

    if (m > 0):
        tree.left = build_kd_tree(data[:m],not flag)

    if (len(data) > 1):
        tree.right = build_kd_tree(data[m:],not flag)
    return tree

if __name__ == '__main__':

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

    kd_tree = build_kd_tree(T,0)

    print(kd_tree)

代码参考http://www.hankcs.com/ml/k-nearest-neighbor-method.html

搜索kd-tree

给定一个目标点，搜索其最近邻。首先找到包含目标点的叶节点；然后从该叶节点出发，一次回退到父节点；不断查找与目标节点最近邻的节点，当确定不可能存在更近的节点时终止，这样搜索就被限制在空间的局部区域上，效率大为提高。

搜索跟二叉树一样来，是一个递归的过程。先找到目标点的插入位置，然后往上走，逐步用自己到目标点的距离画个超球体，用超球体圈住的点来更新最近邻（或k最近邻）

import os

class node(object):

    def __init__(self,point):

        self.point = point
        self.left = None
        self.right = None
        self.parent = None

    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(data):
    m = len(data) / 2

    return data[m],m

def build_kd_tree(data,flag):

    data = sorted(data,key = lambda x: x[flag])

    p,m = median(data)

    tree = node(p)

    del data[m]

    if m > 0:

        tree.set_left(build_kd_tree(data[:m],not flag))

    if (len(data) > 1):

        tree.set_right(build_kd_tree(data[m:],not flag))

    return tree

def distance(x,y):

    return ((x[0]-y[0]) ** 2 + (x[1] - y[1]) ** 2) **0.5

def search_kd_tree(tree,d,target):

    if target[d] < tree.point[d]:
        if tree.left != None:
            return search_kd_tree(tree.left,not d,target)
    else:
        if tree.right != None:
            return search_kd_tree(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]



if __name__ == '__main__':
    T = [[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]]

    tree = build_kd_tree(T,0)


    print(search_kd_tree(tree,0,[5,6]))

##查找[5,6]的最近邻输出结果为[4,7]