统计学习方法——第三章K近邻

【K近邻算法】

       一个少数服从多数的投票模型，可以用在多分类的情况。

算法描述：

       KNN是根据点与点之间的关系来进行判断，所以有些噪声可能会对结果有些影响。还有KNN并不需要训练，但需要遍历整个训练集，所以预测会比较慢。

【代码中用到的方法】

np.linalg.norm(a-b)     #欧氏距离

np.dot(a,b)                #按照矩阵乘法规则来运算

【算法举例】

 【代码】

链接：
http://blog.csdn.net/wds2006sdo/article/details/51933044
http://blog.csdn.net/haluoluo211/article/details/78177510

-----------------------------------------------------------------------------------------------------------------------------------------------

【KD-树】

       更详细参见文章

http://blog.csdn.net/yan456jie/article/details/52074141

http://www.cnblogs.com/v-July-v/archive/2012/11/20/3125419.html

       是对数据点在k维空间（如二维(x，y)，三维(x，y，z)，k维(x1，y，z..)）中划分的一种数据结构，主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。就是把整个空间划分为特定的几个部分，然后在特定空间的部分内进行相关搜索操作。

【算法举例】

       6个二维数据点{(2,3)，(5,4)，(9,6)，(4,7)，(8,1)，(7,2)}构建kd树的具体步骤为：

• 确定：split域=x。具体是：6个数据点在x，y维度上的数据方差分别为39，28.63，所以在x轴上方差更大，故split域值为x；
• 确定：Node-data = （7,2）。具体是：根据x维上的值将数据排序，6个数据的中值(所谓中值，即中间大小的值)为7，所以Node-data域位数据点（7,2）。这样，该节点的分割超平面就是通过（7,2）并垂直于：split=x轴的直线x=7；
• 确定：左子空间和右子空间。具体是：分割超平面x=7将整个空间分为两部分：x<=7的部分为左子空间，包含3个节点={(2,3),(5,4),(4,7)}；另一部分为右子空间，包含2个节点={(9,6)，(8,1)}；

【基本算法】

A. k-d树的数据结构      # class KD_node

代码：

class KD_node:    def __init__(self,elt=None,split=None,LL=None,RR=None):        """        elt:样本点，即根节点        split:划分域        LL,RR:左右子空间内数据点构成的kd-tree        """        self.elt = elt        self.split = split        self.left = LL        self.right = RR

B.划分维度的原理   # computeVariance(arr)

       （基于方差的选择方法）尽可能将相似的点放在一颗子树里面，所以kd-tree采取的思想就是计算所有数据点在每个维度上的数值的方差，然后方差最大的维度就作为当前节点的划分维度。

代码：

def computeVariance(arr):    """    var = E[X^2] - (E(X))^2    """    sum1 = sum(arr)    mean = sum1/arr.size    arr2 = arr * arr  #list不能相乘    sum2 = sum(arr2)        return sum2/arr.size - mean ** 2

C.k-d树的创建  # createKDTree(root,data_list)

代码：

def createKDTree(root,data_list):    """    root:当前树的根节点      data_list:数据点的集合(无序)      return:构造的KDTree的树根        LEN:数据点的个数    demension:数据点的维数    """    if len(data_list) == 0:        return        LEN = len(data_list)    demension = len(data_list[0])        var_max = 0    split = 0    for d in range(demension):        arr1 = np.array(demension)[:,d]        var = computeVariance(arr1)                #找出方差最大的那一维,记为split        if var_max < var:            var_max = var            split = d            #根据选择的划分域对数据点进行排序,方便分配左右儿子    data_list = sorted(data_list,key = lambda x:x[split])    elt = data_list[LEN//2]        root = KD_node(elt,split)    root.left = createKDTree(root.left,data_list[:LEN//2])    root.right = createKDTree(root.right,data_list[LEN//2+1:])        return root

D.利用kd-tree进行最近邻的查找#findNN(root,query)

1.二叉查找：

       从根节点开始进行查找，直到叶子节点；在这个过程中，记录最短的距离，和对应的数据点；同时维护一个栈，用来存储经过的节点

2.回溯查找：

       通过计算查找点到分割平面的距离(这个距离比较的是分割维度上的值的差，并不是分割节点到分割平面上的距离，虽然两者的值是相等的)与当前最短距离进行比较，决定是否需要进入节点的相邻子空间进行查找

e.g

已知：

• 图中的黑点为kd-tree中的数据点，五角星为查询点；
• 通过kd-tree的分支决策会将它分到坐上角的那部分空间，但并不是意味着它到那个空间中的点的距离最近

步骤：

1）首先扫描到叶子节点，扫描过程中记录的最近点为p（5，4），最短距离为d；

2）现在开始回溯，假设分割的维度为ss，其实回溯的过程就是确定是否有必要进入相邻子空间进行搜索，确定的依据就是当前点到最近点的距离d是否大于当前点到分割面（在二维空间中实际上就是一条线）的距离L，如果d < L,那么说明完全没有必要进入到另一个子空间进行搜索，直接继续向上一层回溯；如果有d > L,那么说明相邻子空间中可能有距查询点更近的点。

代码：

def findNN(root,query):    """    root:KDTree的树根     query:查询点     return:返回距离data最近的点NN，同时返回最短距离min_dist         nodeList:用来存储二分查找经过的节点，先进后出，方便回溯查找    back_elt:回溯查找找弹出的节点    ss:分割的维度    """    NN = root.elt    min_dist = np.linalg.norm(np.array(NN)-np.array(query))        nodeList = []    temp_root = root    #二叉查找,直到叶子节点    while temp_root:        nodeList.append(temp_root)        dist = np.linalg.norm(np.array(temp_root.elt)-np.array(query))                if dist < min_dist:            NN = temp_root.elt            min_dist = dist                    #当前节点的划分域          ss = temp_root.split        if query[ss] < temp_root[ss]:            temp_root = temp_root.left        else:            temp_root = temp_root.right        #回溯查找,将nodeList遍历一遍    while nodeList:        back_root = nodeList.pop()        back_elt = back_root.elt        ss = back_root.split                """        if min大于query到分割面的距离:            相邻子空间可能存在更近的点        """        if abs(query[ss] - back_elt[ss]) < min_dist:             if query[ss] > back_elt[ss]:                temp_root = back_root.left            else:                temp_root = back_root.right            #类似二分查找            if temp_root:                nodeList.append(temp_root)                        #相邻子空间找更近的点                dist = np.linalg.norm(np.array(temp_root.elt)-np.array(query))                            if dist < min_dist:                    NN = temp_root.elt                    min_dist = dist    return NN,min_dist