精华内容
下载资源
问答
  • 它指的是使用计算机提取图像信息,决定每个图像的点是否属于一个图像特征特征提取的结果是把图像上的点分为不同的子集,这些子集往往属于孤立的点、连续的曲线或者连续的区域。 案:理解特征提取就是获取依据需求...


    前言:特征提取(feature extraction)是计算机视觉图像处理中的一个概念。它指的是使用计算机提取图像信息,决定每个图像的点是否属于一个图像特征。特征提取的结果是把图像上的点分为不同的子集,这些子集往往属于孤立的点、连续的曲线或者连续的区域。

    案:理解特征提取就是获取依据需求,来获取图像的独有特征值。或者,是将具有相同特质的图像分解的模块进行分类和归类。


    1 基本概念

    1.1 特征定义的应用类型

    特征是一个“有趣”的部分,它是许多计算机图像分析算法的起点。因此一个算法是否成功往往由它使用和定义的特征决定。因此特征提取最重要的一个特性是“可重复性”:同一场景的不同图像所提取的特征应该是相同的。

    1.2 初级运算

    特征提取是图象处理中的一个初级运算,也就是说它是对一个图像进行的第一个运算处理。它检查每个像素来确定该像素是否代表一个特征。假如它是一个更大的算法的一部分,那么这个算法一般只检查图像的特征区域。作为特征提取的一个前提运算,输入图像一般通过高斯模糊核在尺度空间中被平滑。此后通过局部导数运算来计算图像的一个或多个特征。

     

    1.3 寻找特征

    有时,假如特征提取需要许多的计算时间,而可以使用的时间有限制,一个高层次算法可以用来控制特征提取阶层,这样仅图像的部分被用来寻找特征。由于许多计算机图像算法使用特征提取作为其初级计算步骤,因此有大量特征提取算法被发展,其提取的特征各种各样,它们的计算复杂性和可重复性也非常不同。


    2 特征的类型

    典型的特征类型分成以下几种:
    1 边缘

    边缘是组成两个图像区域之间边界(或边缘)的像素。一般一个边缘的形状可以是任意的,还可能包括交叉点。在实践中边缘一般被定义为图像中拥有大的梯度的点组成的子集。一些常用的算法还会把梯度高的点联系起来来构成一个更完善的边缘的描写。这些算法也可能对边缘提出一些限制。局部地看边缘是一维结构。

    2 角

    是图像中点似的特征,在局部它有两维结构。早期的算法首先进行边缘检测,然后分析边缘的走向来寻找边缘突然转向(角)。后来发展的算法不再需要边缘检测这个步骤,而是可以直接在图像梯度中寻找高度曲率。后来发现这样有时可以在图像中本来没有角的地方发现具有同角一样的特征的区域。


    3 区域

    与角不同的是区域描写一个图像中的一个区域性的结构,但是区域也可能仅由一个像素组成,因此许多区域检测也可以用来检测角。一个区域监测器检测图像中一个对于角监测器来说太平滑的区域。

    区域检测可以被想象为把一张图像缩小,然后在缩小的图像上进行角检测。

    4 脊

    长条形的物体被称为脊。在实践中脊可以被看作是代表对称轴的一维曲线,此外局部针对于每个脊像素有一个脊宽度。从灰梯度图像中提取脊要比提取边缘、角和区域困难。在空中摄影中往往使用脊检测来分辨道路,在医学图像中它被用来分辨血管。


    与特征提取

     

    特征被检测后它可以从图像中被抽取出来。这个过程可能需要许多图像处理的计算机。其结果被称为特征描述或者特征向量

    特征提取和特征选择都是从原始特征中找出最有效(同类样本的不变性、不同样本的鉴别性、对噪声的鲁棒性)的特征

    特征提取:将原始特征转换为一组具有明显物理意义(Gabor、几何特征[角点、不变量]、纹理[LBP HOG])或者统计意义或核的特征

    特征选择:从特征集合中挑选一组最具统计意义的特征,达到降维

    两者作用:

    1 减少数据存储和输入数据带宽;

    2 减少冗余;

    3 低纬上分类性往往会提高;

    4 能发现更有意义的潜在的变量,帮助对数据产生更深入的了解。


    特征提取步骤

     

     

    卡方检验

    1. 统计样本集中文档总数(N)。

    2. 统计每个词的正文档出现频率(A)、负文档出现频率(B)、正文档不出现频率)、负文档不出现频率。

    3.计算每个词的卡方值。

    4.将每个词按卡方值从大到小排序,选取前k个词作为特征,k即特征维数。

    信息增益

    1. 统计正负分类的文档数:N1、N2。

    2. 统计每个词的正文档出现频率(A)、负文档出现频率(B)、正文档不出现频率)、负文档不出现频率。

    3. 计算信息熵

    4. 计算每个词的信息增益

    5. 将每个词按信息增益值从大到小排序,选取前k个词作为特征,k即特征维数。


    检测方法

     

    根据对图像信息处理的方法不同,特征点检测一般分为:

    基于模板的方法


      基于模板的方法主要是利用参数模型或模板来进行检测特征点的工作。因为需要构建各种不同的参数模型或模板,所以通常用于检测具备特定类型的特征点,计算速度一般较快。缺点是不适合用于形式比较复杂的模板。

    基于边缘的方法


      基于边缘的方法是把多边形的顶点,或曲率变化较大的物体边缘上的点作为特征点。因为特征点是物体边缘的集合,因此一定程度上对边缘的提取算法要求很高,如果边缘定位出现偏差,就会对检测结果造成很大的影响。

    基于灰度的方法


      基于灰度的方法是利用像素点灰度的局部变化来进行探测,特征点是建立在某种算法上,在该算法上灰度变化最大的像素点。可以利用微分运算来求取像素点周围灰度的导数,以此求出特征点的位置,该方法的缺点是噪声比较大。

    基于空间变换的方法


      基于空间变换的方法利用空间变换获取特性比较容易辨识的特征点,然后在变换空间中进行极值点的检测。通常空间分为尺度空间、频率空间、小波空间等。尺度空间是指在曲率尺度空间或在DOG尺度空间,将搜索到的绝对值最小或最大的点作为特征点。频率空间是将计算得到的局部相位或特定相位最大值当做特征点。小波变换是利用小波系数或模的局部极大值,利用最佳尺度进行极值点检测。 


    Reference:

    1 百度 https://baike.baidu.com/item/%E7%89%B9%E5%BE%81%E6%8F%90%E5%8F%96/8827539?fr=aladdin

    2 特征点提取算法列表 https://blog.csdn.net/sinat_31337047/article/details/69791756

    3 ORB(FAST+BRIEF)特征提取与实现——特征点提取算法分析

    https://blog.csdn.net/qq_32998593/article/details/79221641

    4 【opencv】特征点检测方法--GFTT,SIFT,FAST,SURF

    https://blog.csdn.net/u010141025/article/details/16920567

     

     

     

    展开全文
  • KNN算法基本实例

    2018-06-07 14:15:00
    属于无监督学习领域的算法并且在模式识别,数据挖掘和特征提取领域有着广泛应用。 给定一些预处理数据,通过一个属性把这些分类坐标分成不同组。这就是KNN思路。  下面,举个例子来说明一下。图中数据...

      KNN算法是机器学习领域中一个最基本的经典算法。它属于无监督学习领域的算法并且在模式识别,数据挖掘和特征提取领域有着广泛的应用。

    给定一些预处理数据,通过一个属性把这些分类坐标分成不同的组。这就是KNN的思路。

      下面,举个例子来说明一下。图中的数据点包含两个特征:

     

      现在,给出数据点的另外一个节点,通过分析训练节点来把这些节点分类。没有分来的及诶但我们标记为白色,如下所示:

      直观来讲,如果我们把那些节点花道一个图片上,我们可能就能确定一些特征,或组。现在,给一个没有分类的点,我们可以通过观察它距离那个组位置最近来确定它属于哪个组。意思就是,假如一个点距离红色的组最近,我们就可以把这个点归为红色的组。简而言之,我们可以把第一个点(2.5,7)归类为绿色,把第二个点(5.5,4.5)归类为红色。

      算法流程:

      假设m是训练样本的数量,p是一个未知的节点。

      1 把所有训练的样本放到也数组arr[]中。这个意思就是这个数组中每个元素就可以使用元组(x,y)表示。

      2 伪码

    for i=0 to m:
      Calculate Euclidean distance d(arr[i], p).

      3 标记设置S为K的最小距离。这里每个距离都和一个已经分类的数据点相关。

      4 返回在S之间的大多数标签。

      实际程序C代码:

     

    // C++ program to find groups of unknown
    // Points using K nearest neighbour algorithm.
    #include <bits/stdc++.h>
    using namespace std;
     
    struct Point
    {
        int val;     // Group of point
        double x, y;     // Co-ordinate of point
        double distance; // Distance from test point
    };
     
    // Used to sort an array of points by increasing
    // order of distance
    bool comparison(Point a, Point b)
    {
        return (a.distance < b.distance);
    }
     
    // This function finds classification of point p using
    // k nearest neighbour algorithm. It assumes only two
    // groups and returns 0 if p belongs to group 0, else
    // 1 (belongs to group 1).
    int classifyAPoint(Point arr[], int n, int k, Point p)
    {
        // Fill distances of all points from p
        for (int i = 0; i < n; i++)
            arr[i].distance =
                sqrt((arr[i].x - p.x) * (arr[i].x - p.x) +
                     (arr[i].y - p.y) * (arr[i].y - p.y));
     
        // Sort the Points by distance from p
        sort(arr, arr+n, comparison);
     
        // Now consider the first k elements and only
        // two groups
        int freq1 = 0;     // Frequency of group 0
        int freq2 = 0;     // Frequency of group 1
        for (int i = 0; i < k; i++)
        {
            if (arr[i].val == 0)
                freq1++;
            else if (arr[i].val == 1)
                freq2++;
        }
     
        return (freq1 > freq2 ? 0 : 1);
    }
     
    // Driver code
    int main()
    {
        int n = 17; // Number of data points
        Point arr[n];
     
        arr[0].x = 1;
        arr[0].y = 12;
        arr[0].val = 0;
     
        arr[1].x = 2;
        arr[1].y = 5;
        arr[1].val = 0;
     
        arr[2].x = 5;
        arr[2].y = 3;
        arr[2].val = 1;
     
        arr[3].x = 3;
        arr[3].y = 2;
        arr[3].val = 1;
     
        arr[4].x = 3;
        arr[4].y = 6;
        arr[4].val = 0;
     
        arr[5].x = 1.5;
        arr[5].y = 9;
        arr[5].val = 1;
     
        arr[6].x = 7;
        arr[6].y = 2;
        arr[6].val = 1;
     
        arr[7].x = 6;
        arr[7].y = 1;
        arr[7].val = 1;
     
        arr[8].x = 3.8;
        arr[8].y = 3;
        arr[8].val = 1;
     
        arr[9].x = 3;
        arr[9].y = 10;
        arr[9].val = 0;
     
        arr[10].x = 5.6;
        arr[10].y = 4;
        arr[10].val = 1;
     
        arr[11].x = 4;
        arr[11].y = 2;
        arr[11].val = 1;
     
        arr[12].x = 3.5;
        arr[12].y = 8;
        arr[12].val = 0;
     
        arr[13].x = 2;
        arr[13].y = 11;
        arr[13].val = 0;
     
        arr[14].x = 2;
        arr[14].y = 5;
        arr[14].val = 1;
     
        arr[15].x = 2;
        arr[15].y = 9;
        arr[15].val = 0;
     
        arr[16].x = 1;
        arr[16].y = 7;
        arr[16].val = 0;
     
        /*Testing Point*/
        Point p;
        p.x = 2.5;
        p.y = 7;
     
        // Parameter to decide groupr of the testing point
        int k = 3;
        printf ("The value classified to unknown point"
                " is %d.\n", classifyAPoint(arr, n, k, p));
        return 0;
    }
    View Code

     

      实际程序python代码:

      

     1 # Python3 program to find groups of unknown
     2 # Points using K nearest neighbour algorithm.
     3  
     4 import math
     5  
     6 def classifyAPoint(points,p,k=3):
     7     '''
     8      This function finds classification of p using
     9      k nearest neighbour algorithm. It assumes only two
    10      groups and returns 0 if p belongs to group 0, else
    11       1 (belongs to group 1).
    12  
    13       Parameters - 
    14           points : Dictionary of training points having two keys - 0 and 1
    15                    Each key have a list of training data points belong to that 
    16  
    17           p : A touple ,test data point of form (x,y)
    18  
    19           k : number of nearest neighbour to consider, default is 3 
    20     '''
    21  
    22     distance=[]
    23     for group in points:
    24         for feature in points[group]:
    25  
    26             #calculate the euclidean distance of p from training points 
    27             euclidean_distance = math.sqrt((feature[0]-p[0])**2 +(feature[1]-p[1])**2)
    28  
    29             # Add a touple of form (distance,group) in the distance list
    30             distance.append((euclidean_distance,group))
    31  
    32     # sort the distance list in ascending order
    33     # and select first k distances
    34     distance = sorted(distance)[:k]
    35  
    36     freq1 = 0 #frequency of group 0
    37     freq2 = 0 #frequency og group 1
    38  
    39     for d in distance:
    40         if d[1] == 0:
    41             freq1 += 1
    42         elif d[1] == 1:
    43             freq2 += 1
    44  
    45     return 0 if freq1>freq2 else 1
    46  
    47 # driver function
    48 def main():
    49  
    50     # Dictionary of training points having two keys - 0 and 1
    51     # key 0 have points belong to class 0
    52     # key 1 have points belong to class 1
    53  
    54     points = {0:[(1,12),(2,5),(3,6),(3,10),(3.5,8),(2,11),(2,9),(1,7)],
    55               1:[(5,3),(3,2),(1.5,9),(7,2),(6,1),(3.8,1),(5.6,4),(4,2),(2,5)]}
    56  
    57     # testing point p(x,y)
    58     p = (2.5,7)
    59  
    60     # Number of neighbours 
    61     k = 3
    62  
    63     print("The value classified to unknown point is: {}".\
    64           format(classifyAPoint(points,p,k)))
    65  
    66 if __name__ == '__main__':
    67     main()
    68      
    69 # This code is contributed by Atul Kumar (www.fb.com/atul.kr.007)
    View Code

     

      

      

    转载于:https://www.cnblogs.com/dylancao/p/9150342.html

    展开全文
  • 基于信息增益决策树算法(ID3算法)及python实现 决策树概述 不同于逻辑回归,决策树属于非线性模型,可以用于分类,也可用于回归。它是一种树形结构,可以认为是if-then规则集合,是以实例为基础归纳学习。...

    基于信息增益的决策树算法(ID3算法)及python实现

    决策树概述

    不同于逻辑回归,决策树属于非线性模型,可以用于分类,也可用于回归。它是一种树形结构,可以认为是if-then规则的集合,是以实例为基础的归纳学习。基本思想是自顶向下,以信息增益(或信息增益比,基尼系数等)为度量构建一颗度量标准下降最快的树,每个内部节点代表一个属性的测试,直到叶子节点处只剩下同一类别的样本。它的决策流程如下所示:
    在这里插入图片描述
    决策树的学习包括三个重要的步骤,特征选择,决策树的生成以及决策树的剪枝。

    • 特征选择:常用的特征选择有信息增益,信息增益比,基尼系数等。
    • 生成过程:通过计算信息增益或其它指标,选择最佳特征。从根结点开始,递归地产生决策树,不断的选取局部最优的特征,将训练集分割成能够基本正确分类的子集。
    • 剪枝过程:首先定义决策树的评价指标,对于所有的叶子结点,累加计算每个叶子结点中的(样本数)与其(叶子节点熵值)的乘积,以叶子数目作为正则项(它的系数为剪枝系数)。然后计算每个结点的剪枝系数,它的大概含义是删除该结点的子树,损失不变的前提下,正则项系数的值为多少,这个值越小说明该子树越没有存在的必要。依次选取剪枝系数最小的结点剪枝,得到决策树序列,通过交叉验证得到最优子树。

    信息增益 (Information Gain)理论

    提到信息增益必须先解释一下什么是“信息熵”,因为信息增益是基于信息熵而定义的。我们先给出信息熵的公式定义:
    在这里插入图片描述
    D:表示当前的数据集合。
    k:表示当前数据集合中的第k类,也就是我们目标变量的类型。
    最后,解释一下信息熵公式的由来:
    在这里插入图片描述
    信息论之父克劳德香农总结出信息熵的三条性质:

    • 单调性,发生概率越高的事件,其所携带的信息熵越低。极端案例即是“太阳从东方升起”,因为是确定事件,所以不携带任何信息量。从信息论的角度,认为这句话没有消除任何不确定性。
    • 非负性:信息熵不能为负,因为负的信息,在得知某个信息后,却增加了不确定性是不合理的。
    • 累加性:多个随机事件同时发生存在的总不确定性的量度是可以表示为各事件不确定性的量度的和,即:
      事件X=A,Y=B同时发生,两个时间相互独立,
      在这里插入图片描述
      则信息熵为:
      在这里插入图片描述

    香浓从数学上,严格证明了满足上述三个条件的随机变量不确定性度量函数具有唯一形式:
    在这里插入图片描述
    其中的C为常数,将其归一化为C=1,即得到信息熵公式。
    补充一下:如果两个事件不相互独立,则满足:
    H(A,B)=H(A)+H(B)-I(A,B),其中I(A,B)是互信息,代表一个随机变量包含另一个随机变量信息量的度量。
    信息熵的取值范围为0到1,值越大,越不纯,值越小,集合纯度越高。如下图所示:
    在这里插入图片描述
    上面信息熵只能代表不纯度,并不能代表信息量。但既然我们有了不纯度,我们只要将分类前后的不纯度相减,那就可以得到一种 “纯度提升值” 的指标,我们把它叫做 “信息增益”,公式如下:
    在这里插入图片描述
    在这里插入图片描述

    基于信息增益的决策树特征选择方法

    • 基于特征A对数据集D的划分:
      H(D|A):表示基于特征A(分类后)的信息熵,也称条件熵。
      Di:基于特征A对数据集D划分的子集。
      |Di|/|D|:考虑到特征分类子集的数据量不同,给每个子集赋予了权重。
      n:为特征A的分类总数,即有多少个Di。
    • 基于目标分类对特征类别Di数据集的划分:
      Dik:每个特征分类子集Di中目标分类后的子集。
      K:为目标分类的类别总数,即有多少个Dik。
      |Dik|/|Di|:每个特征分类子集中,各目标分类子子集所占比例。

    简单来说,先基于特征A进行划分,再基于目标变量进行划分,这是一个嵌套的过程。举一个例子说明,红色框内代表决策树中的其中一个分类过程,按照“是否理解内容”这个特征分成两类,树的父集和子集信息熵都已经标出,因此信息增益Gain就可以计算出来。
    在这里插入图片描述
    上面只是描述了针对一个特征的计算信息增益的过程。在实际决策过程中,我们需要将所有的特征分类后的信息增益都计算一遍,然后选择其中最大的一个最为本次的分类特征。因此也就达到了特征选择的目的。ID3算法使用信息增益的方法来选择特征。
    从这个过程,我们可以发现:最开始选择的特征肯定是提供信息量最大的,因为它是遍历所有特征后选择的结果。因此,按照决策过程中特征从上到下的顺序,我们也可以将特征的重要程度进行排序。这也就解释了为什么树模型有feature_importance这个参数了。

    算法的python实现

    # -*- coding: utf-8 -*-
    """
    Created on Sat Mar 30 11:17:53 2019
    
    @author: Auser
    """
    from math import log
    import operator
    
    
    def cal_entropy(dataSet_train):#计算熵
     
        #numEntries为训练集样本数
        numEntries = len(dataSet_train)
        labelCounts = {}
        for featVec in dataSet_train:#遍历训练样本
            label = featVec[-1]#将每个训练样本的类别标签作为类别列表
            if label not in labelCounts.keys():#如果一个训练样本的类别不在类别列表字典中
                labelCounts[label] = 0#将该训练样本类别进行标记
            labelCounts[label] += 1#否则,给类别字典对应的类别+1
        entropy = 0.0#初始化香浓商
        for key in labelCounts.keys():#遍历类别字典的每个类别
            p_i = float(labelCounts[key]/numEntries)#计算每个类别的样本数占总的训练样本数的占比(即某一样本是类i的概率)
            entropy -= p_i * log(p_i,2)#log(x,10)表示以10 为底的对数,计算香浓熵
        return entropy
    
     
    def split_data(dataSet_train,feature_index,value):#按照选出的最优的特征的特征值将训练集进行分裂,并将使用过的特征进行删除
        '''
        划分数据集
        feature_index:用于划分特征的列数,例如“年龄”
        value:划分后的属性值:例如“青少年”
        '''
        data_split=[]#划分后的数据集
        for feature in dataSet_train:#遍历训练集
            if feature[feature_index]==value:#如果训练集的特征索引的值等于划分后的属性值
                reFeature=feature[:feature_index]#删除使用过的特征
                reFeature=list(reFeature)
                reFeature.extend(feature[feature_index+1:])
                data_split.append(reFeature)
        return data_split
    
    def choose_best_to_split(dataSet_train):#
        
        '''
        根据每个特征的信息增益率,选择最大的划分数据集的索引特征
        '''
        
        count_feature=len(dataSet_train[0])-1#特征个数4
        #print(count_feature)#4
        entropy=cal_entropy(dataSet_train)#原数据初始的信息熵
        #print(entropy)#0.9402859586706309
        
        max_info_gain=0.0#信息增益率最大
        split_fea_index=-1#信息增益率最大,对应的特征索引号
        #split_fea_value=0#信息增益率最大没对应的特征的特征值
     
        for i in range(count_feature):#遍历特征
            
            feature_list=[fe_index[i] for fe_index in dataSet_train]#分别获取每每个元组的第i个特征值
            #######################################
     
           # print(feature_list)
            unqval=set(feature_list)#去除每一个特征重复的特征值
            Pro_entropy=0.0#初始化条件熵
            for value in unqval:#遍历该特征下的所有属性的唯一值
                sub_data=split_data(dataSet_train,i,value)#将分裂后的数据作为子数据集,递归使用某一特征i的每个特征值来分裂训练集
                pro=len(sub_data)/float(len(dataSet_train))#某一训练样本是某一子集的概率,分裂后每一个子集占训练集总数的概率
                Pro_entropy+=pro*cal_entropy(sub_data)#在某一属性i下的条件熵
                #print(Pro_entropy)
                
            info_gain=entropy-Pro_entropy#一个训练样本在某一属性下的信息增益
           # print('第%d个特征的增益为%.3f'%(i,info_gain))
            if(info_gain>max_info_gain):#选择值最大的信息增益
                max_info_gain=info_gain
                split_fea_index=i
               # split_fea_value=value
    
        return split_fea_index#返回分裂特征值对应的特征索引
            
            
    ##################################################
    def most_occur_label(classList):
        #sorted_label_count[0][0]  次数最多的类标签
        label_count={}#创建类别标签字典,key为类别,item为每个类别的样本数
        for label in classList:#遍历类列表
            if label not in label_count.keys():#如果类标签不在类别标签的字典中
                label_count[label]=0#将该类别标签置为零
            else:
                label_count[label]+=1#否则,给对应的类别标签+1
                #按照类别字典的值排序
        sorted_label_count = sorted(label_count.items(),key = operator.itemgetter(1),reverse = True)
        return sorted_label_count[0][0]#返回样本量最多的类别标签
    
    
    
    def build_decesion_tree(dataSet_train,featnames):#建立决策树
        '''
        字典的键存放节点信息,分支及叶子节点存放值
        '''
        featname = featnames[:]              ################特证名
        classlist = [featvec[-1] for featvec in dataSet_train]  #此节点的分类情况
        if classlist.count(classlist[0]) == len(classlist):  #全部属于一类
            return classlist[0]
        if len(dataSet_train[0]) == 1:         #分完了,没有属性了
            return  most_occur_label(classlist)       #少数服从多数,返回训练样本数最多的类别作为叶节点
        # 选择一个最优特征的最优特征值进行划分
        bestFeat = choose_best_to_split(dataSet_train)
        bestFeatname = featname[bestFeat]
        del(featname[bestFeat])     #防止下标不准
        DecisionTree = {bestFeatname:{}}
        #print(DecisionTree)
        # 创建分支,先找出所有属性值,即分支数
        allvalue = [vec[bestFeat] for vec in dataSet_train]#将每个训练样本的最优特征值作为分裂时的特征值
        specvalue = sorted(list(set(allvalue)))  #对分支使有一定顺序
        for v in specvalue:#遍历选中的最优特征的每个特征取值
            copyfeatname = featname[:]#复制特证名,在下一轮建造子树时使用
            #print(copyfeatname)
            #递归建造决策树,split——data()对源数据集进行分裂,
            DecisionTree[bestFeatname][v] =  build_decesion_tree(split_data(dataSet_train,bestFeat,v),copyfeatname)
        return DecisionTree
    
    
     
    def classify(Tree, featnames, X):#对测试集使用训练好的决策树进行分类
        #classLabel=' '
        global classLabel
        root = list(Tree.keys())[0]#构建树的根
        #print(root)
        firstDict = Tree[root]#树的根给第一个字典
        #print(firstDict)
        featindex = featnames.index(root)  #根节点的属性下标
        #print(featindex)
        #classLabel='0'
        for key in firstDict.keys():   #遍历每一个子树的关键字的特征值
            if X[featindex] == key:#如果测试样本指定特征索引的特征值等于关键字对应特征的特征值
                if type(firstDict[key]) == type({}):#当一个子树的关键字特征是字典,则说明该子树还有下一级
                    #print(type(firstDict[key]))
                    #print(type({}))
                    classLabel = classify(firstDict[key],featnames,X)#使用递归对下一级进行分类
                else:#否则如果当一个子树的关键字特征不是字典则将该值赋给类别
                    classLabel = firstDict[key]
        return classLabel#返回求得的类别
    
    
    #计算叶结点数
    def getNumLeafs(Tree):
        numLeafs = 0
        firstStr = list(Tree.keys())[0]
        secondDict = Tree[firstStr]
        for key in secondDict.keys():
            if type(secondDict[key]).__name__=='dict':# 测试结点的数据类型是否为字典
                numLeafs += getNumLeafs(secondDict[key])
            else:   numLeafs +=1
        return numLeafs
    
    
    # 计算树的深度
    def getTreeDepth(Tree):
        maxDepth = 0
        firstStr = list(Tree.keys())[0]
        secondDict = Tree[firstStr]
        for key in secondDict.keys():
            if type(secondDict[key]).__name__=='dict':# 测试结点的数据类型是否为字典
                thisDepth = 1 + getTreeDepth(secondDict[key])
            else:   thisDepth = 1
            if thisDepth > maxDepth: maxDepth = thisDepth
        return maxDepth
    
    
    展开全文
  • 本文通过讲解3个基本问题应用,提供了分治算法设计范式实践。第一个例子是对数组中逆序对进行计数的算法(第3.2节)。这个问题与测量两个有序列表相似性有关,适用于根据自己知识向其他人按照他们偏好提供...

    本文通过讲解3个基本问题的应用,提供了分治算法设计范式的实践。第一个例子是对数组中的逆序对进行计数的算法(第3.2节)。这个问题与测量两个有序列表的相似性有关,适用于根据自己的知识向其他人按照他们的偏好提供优质的推荐(称为“协同筛选”)。第二个分治算法的例子是Strassen所发明的令人兴奋的矩阵相乘递归算法,它与迭代方法(第3.3节)相比,性能提升非常明显。第三个算法属于高级的选修知识,用于解决计算几何学的一个基本问题:计算平面上最近的点对(第3.4节)。

    3.1 分治法规范

    我们已经看过分治算法的一个经典例子:MergeSort(第1.4节)。概括地说,分治算法设计范式一般具有3个概念步骤。

    分治范式

    1.把输入划分为更小的子问题。

    2.递归地治理子问题。

    3.把子问题的解决方案组合在一起,形成原始问题的解决方案。

    例如,在MergeSort中,“划分”步骤把输入数组分成左半部分和右半部分,“治理”步骤是由Merge子程序(第1.4.5节)所实现的。在MergeSort和许多其他算法中,需要用到巧妙思维的时机正是在这最后一步。也有些分治算法的巧妙之处出现在第一个步骤(参见第5章的QuickSort)或者出现在递归调用的规格说明中(参见第3.2节)。

    3.2 以O(n log n)时间计数逆序对

    3.2.1 问题

    本节研究对一个数组中的逆序对计数的问题。所谓数组的逆序对,就是指一对元素“乱了序”,也就是出现在数组较前位置的元素比出现在较后位置的元素更大。

    问题:对逆序对进行计数

    输入:一个包含不同整数的数组A

    输出:A中的逆序对数量,即数组中符合i < j并且A[i] > A[j]的(i, j)对的数量。

    例如,已经排序的数组A没有任何逆序对。反过来的说法也是对的,未排序的数组至少有1对逆序对。

    3.2.2 一个例子

    考虑下面这个长度为6的数组:

    d8ac01ca7ab9b80a19002de482b7c259.png

    这个数组有几个逆序对呢?显而易见的一个例子就是5和2(分别对应于i=3和j=4)。这个数组还有另外2对逆序对:3和2以及5和4。

    小测验3.1

    包含6个元素的数组最多可能出现几对逆序对?

    (a)15

    (b)21

    (c)36

    (d)64

    (关于正确答案和详细解释,参见第3.2.13节)

    3.2.3 协同筛选

    为什么需要对数组中的逆序对进行计数呢?一个原因是想要计算一种数值相似度,该数值相似度用于对两个已排序列表之间的相似程度进行量化。例如,读者邀请一位朋友一起对两人都看过的10部电影按照从最喜欢到最不喜欢的顺序进行排列。怎么衡量两人的选择是“相似”或“不同”呢?解决这个问题的一种量化方法是通过一个包含10个元素的数组AA[1]表示读者的朋友从电影列表中所选择的最喜欢的电影,A[2]表示他其次喜欢的电影,以此类推,A[10]表示他最不喜欢的电影。这样,如果读者最喜欢的电影是《星球大战》,而这部电影在读者朋友的列表中只是出现在第5位,那么A[1] = 5。如果两人的排序是相同的,这个数组就是已经排序的,不存在逆序对。这个数组包含的逆序对越多,读者和朋友之间对电影评价的分歧就越多,对电影的偏好也更加不同。

    对已排序列表进行相似性测量的一个原因是进行协同筛选,这是一种用于生成推荐方案的方法。网站怎么推出关于产品、电影、歌曲、新闻故事等内容的建议呢?在协同筛选中,其思路是寻找其他具有相似偏好的用户,然后推荐他们所喜欢的内容。因此协同筛选需要用户之间“相似性”的形式定义,而计算逆序对能够捕捉到这个问题的一些本质。

    3.2.4 穷举搜索法

    计算数组的逆序对数量的速度有多快?如果对此缺乏概念,那可以尝试使用穷举搜索法。

    用穷举搜索法对逆序对进行计数

    输入:包含n个不同整数的数组A

    输出:A中逆序对的数量。

    numInv := 0for i := 1 to n − 1 do  for j := i + 1 to n do    if A[i] > A[j] then      numInv := numInv + 1return numInv

    显然,这是一种正确的算法。它的运行时间是什么?根据小测验3.1的答案,我们知道循环的迭代次数与输入数组的长度n的平方成正比。由于这种算法每次迭代时执行的操作数量是常数级的,因此它的渐进性运行时间是Θ(n2)。记住,经验丰富的算法设计师的座右铭是:“还能做得更好吗?”

    3.2.5 分治法

    答案是肯定的,解决方案是运行时间为O(n log n)的分治算法,它的性能较之穷举搜索法有了很大的提高。它的“划分”步骤和MergeSort算法的完全一样,一个递归调用作用于数组的左半边,另一个递归调用作用于数组的右半边。为了理解这两个递归调用之外所需要完成的剩余工作,我们把一个长度为n的数组A中的逆序对(i, j)分为3类。

    (1)左逆序对:逆序对的ij都位于数组的左半部分(即

    07fd9256760aa6a147673335cf9eb073.gif

    )。

    (2)右逆序对:逆序对的ij都位于数组的右半部分(即

    5b1a96612c7075346f8c051c0014e6e7.gif

    )。

    (3)分离逆序列:逆序对的i位于数组的左半部分,j位于数组的右半部分(即

    06cd9932bdbd23d50c7e2df3ad391202.gif

    )。

    例如,在第3.2.2节的那个6元素数组例子中,3个逆序对都是分离逆序对。

    第1个递归调用作用于输入数组的左半部分,它采用递归的方式对左逆序对进行计数(没有其他任何操作)。类似,第2个递归调用对所有的右逆序对进行计数。剩余的任务是对那些并没有被这两个递归调用所计数的逆序对(即分离逆序对)进行计数。这是这个算法的“组合”步骤,我们需要为它实现一种特殊的线性时间的子程序,类似于MergeSort算法中的Merge子程序。

    3.2.6 高级算法

    我们的分治算法可以翻译为下面的伪码,用于计数分离逆序对的CountSplitInv子程序目前还没有实现。

    CountInv

    输入:包含n个不同整数的数组A

    输出:A中逆序对的数量。

    if n = 0 or n = 1 then // 基本条件  return 0else  leftInv := CountInv(first half of A)  rightInv := CountInv(second half of A)  splitInv := CountSplitInv(A)  return leftInv + rightInv + splitInv

    第一个和第二个递归调用分别对左逆序对和右逆序对进行计数。假如CountSplitInv子程序可以正确地对分离逆序对进行计数,CountInv就可以正确地计算逆序对的总数。

    3.2.7 关键思路:站在MergeSort的肩膀上

    要想使对数组的分离逆序对进行计数的算法具有线性运行时间是个很有雄心的目标。分离逆序对的数量可能很多:如果A按顺序包含了

    ea97ba20715dcb0dd4e7b10a38960049.gif

    ,然后按顺序又包含了

    90014c84747d8df4042c71797d62a38c.gif

    ,那么一共就有

    27627ac4d6a5f6811fe4d7458153ce08.gif

    个分离逆序对。我们怎么才能在线性工作时间内完成平方级数量的工作呢?

    思路就是在设计递归式计数逆序对的算法时站在MergeSort算法的肩膀之上。它除了递归调用之外还需要完成一些任务,才能更方便地计数分离逆序对的数量[2]。每个递归调用不仅负责对指定部分的数组中的逆序对进行计数,而且要返回该数组的排序版本。我们已经知道(通过定理1.2)排序是一种可以尽情使用的基本操作,其运行时间为O(n log n)。因此,如果我们所争取的运行时间上限为O(n log n),那么有什么理由不进行排序呢?我们很快就会看到,对两个已经排序的子数组进行归并这个任务简直就是为对数组中的分离逆序对进行计数这个任务量身定做的。

    下面是第3.2.6节的伪码经过修订的版本,它在计数的同时还对数组进行排序。

    Sort-and-CountInv

    输入:包含n个不同整数的数组A

    输出:包含与A中相同整数的、已经排序的数组B,以及数组A中的逆序对的数量。

    if n = 0 or n = 1 then // 基本条件  return (A; 0)else  (C; leftInv) := Sort-and-CountInv(first half of A)  (D; rightInv) := Sort-and-CountInv(second half of A)  (B; splitInv) := Merge-and-CountSplitInv(C;D)  return (B; leftInv + rightInv + splitInv) 

    我们仍然需要实现Merge-and-CountSplitInv子程序。我们知道如何用线性时间对两个已经排序的列表进行归并,但是怎么才能利用这个成果对分离逆序对进行计数呢?

    3.2.8 重温Merge

    为了观察为什么合并已经排序的数组可以自然地发现分离逆序对,我们重新回顾一下Merge子程序的伪码。

    Merge

    输入:已经排序的数组CD(长度分别为n/2)。

    输出:已经排序的数组B(长度为n)。

    用于简化问题的先决条件:n是偶数。

    i := 1, j := 1for k := 1 to n do  if C[i] < D[j] then    B[k] := C[i], i := i + 1  else             // D[j] < C[i]    B[k] := D[j], j := j + 1

    重温一下,Merge子程序根据索引平行地(用i访问C,用j访问D)访问每个已经排序的子数组,并按从左向右的排序顺序生成输出数组B(使用索引k)。

    在循环的每次迭代中,这个子程序寻找目前为止尚未被复制到B中的最小元素。由于CD都已经排序,所以C[i]和D[j]之前的所有元素都已经被复制到B中,仅有的两个候选元素就是C[i]和D[j]。Merge子程序判断这两个元素哪个更小,并把它复制到输出数组的下一个位置。

    如果需要计算分离逆序对的数量,Merge子程序需要做些什么呢?我们首先讨论一种特殊的情况,就是数组A中不包含任何分离逆序对,A中的每个逆序对要么是左逆序对,要么是右逆序对。

    小测验3.2

    假设输入数组A不存在分离逆序对,那么已经排序的子数组CD之间存在什么关系?

    (a)C包含A中最小的元素,D包含第二小的,C包含第三小的,依次类推。

    (b)C的所有元素都小于D的任何元素。

    (c)C的所有元素都大于D的任何元素。

    (d)没有足够的信息可以回答这个问题。

    (关于正确答案和详细解释,参见第3.2.13节)

    在解决了小测验3.2之后,我们可以看到Merge在数组不存在分离逆序对时会执行一些特别无聊的操作。由于C的每个元素都小于D的每个元素,所以最小的元素总是出现在C中(除非C中不再剩下任何元素)。因此Merge子程序只是把CD连接在一起,它首先复制C的所有元素,然后复制D的所有元素。这是不是意味着当D的一个元素被复制到输出数组时,分离逆序对与C中剩余元素的数量有关呢?

    3.2.9 Merge和分离逆序对

    为了进一步证明自己的直觉,我们考虑对一个包含6个元素的数组A={1, 3, 5, 2, 4, 6}(来自第3.2.2节)运行MergeSort算法,参见图3.1。这个数组的左半部分和右半部分都已经排序,因此不存在左逆序对和右逆序对,两个递归调用都返回0。在Merge子程序的第1次迭代时,C的第1个元素(1)被复制到B。此时没有任何与分离逆序对有关的信息,事实上这个元素也与分离逆序对没有任何关系。但是,在第2次迭代时,“2”被复制到输出数组中,但此时C中仍然剩下元素3和5。这就说明了A中有2个分离逆序对,也就是与2相关联的两个逆序对。在第3次迭代时,3从C被复制到B,此时没有其他分离逆序对与这个元素有关。当4从D被复制到B时,数组C中仍然还有一个元素5,提示A中还有第3个也就是最后一个分离逆序对(元素5和元素2)。

    b1cf850a90c2e266b3566455433b3e53.png

    图3.1 Merge子程序的第4次迭代面对的是已经排序的子数组{1, 3, 5}和{2, 4, 6}。从D复制元素“4”,此时“5”仍然留在C中,显示了与这两个元素相关的分离逆序对

    下面这个辅助结论表示上面这个例子的模式可以推及到一般情况:在Merge子程序把第2个子数组D中的元素y复制到输出数组的当次迭代时,与y有关的分离逆序对的数量就是此时C中仍然剩余的元素的数量。

    辅助结论3.1  假设A是个数组,CD分别是该数组左半部分和右半部分已经排序的子数组。A中左半部分的元素xA中右半部分的元素y当且仅当下面这种情况成立时才能构成一对逆序对:在Merge子程序中输入CDyx之前被复制到输出数组。

    证明:由于输出数组是按从左向右的顺序生成的,因此xy中较小的那个先被复制。由于x位于A的左半部分,y位于右半部分,因此当且仅当x > yxy才会构成一对逆序对,也就是当且仅当yx之前被复制到输出数组中时xy才会构成一对逆序对。Q.e.d.

    3.2.10 Merge_and_CountSplitInv

    根据辅助结论3.1所提供的结论,我们可以对Merge的实现进行扩展,实现Merge-and-CountSplitInv。

    我们用一个变量记录分离逆序对的当前计数,每次当一个元素从右半部分的子数组D复制到输出数组B时,就把当前计数加上左半部分的子数组C中仍然剩余的元素数量。

    Merge-and-CountSplitInv

    输入:已经排序的数组CD(长度均为n/2)。

    输出:已经排序的数组B(长度为n)以及分离逆序对的数量。

    用于简化问题的先决条件:n是偶数。

    i := 1, j := 1, splitInv := 0for k := 1 to n do  if C[i] < D[j] then    B[k] := C[i], i := i + 1  else              // D[j] < C[i]    B[k] := D[j], j := j + 1    splitInv := splitInv + 
    dd24c7da871d1b70fecc63aef502c458.gif
                   #C中剩余元素的数量return (B; splitInv)

    3.2.11 正确性

    Merge-and-CountSplitInv的正确性是由辅助结论3.1所保证的。每个分离逆序对只涉及第2个子数组中的1个元素,并且当y被复制到输出数组时,这个逆序对正好被计数1次。整个Sort-and-CountInv算法(第3.2.7节)的正确性取决于下面的条件是否都得到满足:第1个递归调用正确地计算左逆序对的数量,第2个递归调用正确地计算右逆序对的数量,Merge-and- CountSplitInv返回剩余逆序对(分离逆序对)的正确数量。

    3.2.12 运行时间

    我们还可以借助前面已经完成的MergeSort算法运行时间的分析,对Sort-and- CountInv算法的运行时间进行分析。首先考虑单次调用Merge-and-CountSplitInv的运行时间,提供给它的是2个长度为

    7cf9990653c38affbc2d0024eb502352.gif

    的子数组。和Merge子程序一样,它在循环的每次迭代时执行常数级的操作,另外还有一些常数级的其他操作,运行时间为O(

    dd55d071927324a2b304921fd474d8b1.gif

    )。

    回顾第1.5节对MergeSort算法运行时间的分析,我们可以看到这个算法具有3个重要的属性,导致它的运行时间上界是O(n log n)。首先,这个算法的每次调用都产生两个递归调用。其次,每一层递归调用的输入长度只有上一层的一半。最后,每个递归调用所完成的工作与输入长度呈正比(不包括下层递归调用所完成的工作)。

    由于Sort-and-CountInv算法具有这些属性,所以第1.5节的分析对它也是适用的,因此它的运行时间上界是O(n log n)。

    定理3.2(计数逆序对)对于长度大于等于1的数组A,Sort-and-CountInv算法计算A中逆序对的数量运行时间是O(n log n)。

    3.2.13 小测验3.1~3.2的答案

    小测验3.1的答案

    正确答案(a)。这个问题的正确答案是15。逆序对的最大可能数量就是

    a44e167a8d99f62f8b7a0659bc8a372c.gif

    中满足i<j的( ij ) 对的数量。这个数量用

    876f2dfcb46c5c30488f0f8052750cc6.gif

    表示,意思是“6中选2”。一般而言

    093f38f7aa57c42a44cdc90256ce285c.gif

    ,因此

    876f2dfcb46c5c30488f0f8052750cc6.gif

    =15[3]。在一个反序排列的6元素数组(6, 5, 4, 3, 2, 1)中,每一对元素都是逆序的,因此这个数组一共有15个逆序对。

    小测验3.2的答案

    正确答案(b)。在不包含分离逆序对的数组中,左半部分数组中的所有元素都小于右半部分数组中的所有元素。如果左半部分数组中的某个元素A[i](

    4a9c0f059f8ebdd2ffa6f26cc11260d9.gif

    )大于右半部分数组中的某个元素A[j](

    33107b12f3b1e266c38dba5ed45c6dfa.gif

    ),则(i, j)就构成分离逆序对。

    3.3 Strassen的矩阵相乘算法

    本节把分治算法设计范式应用于矩阵相乘这个问题,这类算法的巅峰无疑是Strassen的矩阵相乘算法,它的运行时间令人吃惊,竟然低于立方级。这个算法是精巧的算法设计发挥神奇威力的一个典型例子。它可以让我们看到精妙的算法是怎样把简单解决方案远远抛在身后的,即使是对于极端基本的问题。

    3.3.1 矩阵相乘

    假设XY

    4f71f24db96ed6f92d6e5e14fedf8df3.gif

    的整数矩阵,每个矩阵包含

    b52efdafa7be015cc31de0c9ca5e88e5.gif

    个元素。在矩阵的乘积·中,Z中第i行第j列的元素Zij被定义为X的第i行和Y的第j列的数量积[4] (见图3.2)。即

    5ab886f4c57d89c7c684ee38cd52db6f.gif

    (3.1)

    468f3103a9b99bcef7140dbde2039329.png

    图3.2 矩阵乘积X · Y的(i, j)项是X的第i行和Y的第j列的数量积

    3.3.2 例子(n = 2)

    现在我们来深入探讨n = 2这种情况。我们可以用8个参数来描述两个2×2的矩阵:

    ccba0157a9728f3770e9f5c29563f022.gif

    在矩阵的乘积X · Y中,左上角的元素是X的第1行和Y的第1列的数量积,即

    0b2f4148f8adbb024f8c18f7852c8256.gif

    。一般而言,对于像上面这样的矩阵XY

    eb75d442a54814f629053f1fd6c54165.gif

    (3.2)

    959bddddebbe25c1923370497d9c9806.png

    《算法详解(卷1)——算法基础》

    作者:[美] 科里•奥尔索夫(Cory Althoff)

    这本书在美亚评分4.7,在作者的在线算法课程的基础之上编写的,是四卷本系列的第1卷。这个在线课程2012年起就定期更新,它建立在作者在斯坦福大学教授多年的本科课程的基础之上。也许你有所耳闻,这本书就是《算法详解(卷1)——算法基础》。如果你更喜欢听和看,可以在YouTobe上搜索这本书的主题课程,免费观看。

    《算法详解(卷1)——算法基础》作者蒂姆·拉夫加登(Tim Roughgarden)是斯坦福大学计算机科学系的教授,也是该校管理科学和工程系的客座教授,他从2004年开始教授和研究算法。本书是他的《算法详解》四部曲的第一卷。

    这本书详细讲解算法基础,展现算法本质 ,是一本囊括基本算法知识的详解指南。集斯坦福大学教授多年教学经验,深入浅出,通俗易懂。

    展开全文
  • K近邻算法是一种自动判别测试数据类型的算法,它是基于数据集的特征来进行分类,并不需要计算出数据预测模型,属于惰性算法算法介绍: 简单来说就是将测试数据与不用类别之间向量距离进行计算来进行分类 优点:...
  • 摘自本人毕业论文《肺结节CT影像特征提取算法研究》 ...肺结节CT影像特征提取也是属于医学图像特征提取领域一个部分,有着医学图像特征提取的基本要求。既有其他医学图像特征提取方法,也有针...
  • 模板方法模式(Template Method Pattern)又简称模板模式,属于行为型设计模式,它主要是在父类中定义一个统一操作的算法框架,而将具体实现延迟到子类中,使得不同子类按照父类已定义好框架结构进行实现不同...
  • 图像特征基本介绍

    2015-05-30 00:10:25
    它指的是使用计算机提取图像信息,决定每个图像的点是否属于一个图像特征。特征提取的结果是把图像上的点分为不同的子集,这些子集往往属于孤立的点、连续的曲线或者连续的区域。 特征的定义  至今为止...
  • CLD,全称是颜色布局描述子(Color Layout Descriptor)是mpeg-7多媒体内容标准描述中一种高效局部颜色特征描述,具有计算成本低、匹配计算速度快等优点,属于简单易懂图像特征提取算法。 以下内容翻译自Wiki...
  • KNN算法和sklearn中KNN算法

    千次阅读 2018-09-09 15:45:06
    思路是:如果一个样本在特征空间中k个最相似(即特征空间中最邻近)样本中大多数属于某一个类别,则该样本也属于这个类别,其中K通常是不大于20整数。KNN算法中,所选择邻居都是已经正确分类对象。该...
  • 本文作者通过Knn算法进行了一次用户判断预测流程,文章为作者根据自身经验所做出总结,...knn的基本思路是:如果一个样本在特征空间中k个最相似(即特征空间中最邻近)样本中大多数属于某一个类别,则该样...
  • ​背景在很多机器学习...从笔者个人经验来看有如下几个方面导致了这样局面:大部分机器学习算法本身具有特征选择功能,是机器学习算法的一项副产品。特征选择属于数据科学的特征工程范畴,面对不同场景方...
  • 该方法思路是:在特征空间中,如果一个样本附近k个最近(即特征空间中最邻近)样本大多数属于某一个类别,则该样本也属于这个类别。。 一、KNN的基本思路 所谓K近邻算法,即是给定一个训练数据集,对新输入...
  • K近邻算法的那点事

    2020-11-09 21:33:08
    输出为特征的类别,可以取多分类。k近邻算法假设给定一个训练数据集,其中的实例类别已定。分类时,对新的实例,根据其k个最近邻的实例的类别,用过多数表决等方式进行预测。因此k近邻算法不具有显示的学习过程。k...
  • 分类算法-k近邻算法

    2020-11-10 15:16:32
    k近邻算法定义: 如果一个样本在特征空间中k个最相似(即特征空间中最邻近)样本中大多数属于某一个类别,则该样本也属于这个类别。 来源: KNN算法最早是由Cover和Hart提出一种分类算法 计算距离公式: 两个...
  • 贪心算法和哈夫曼算法

    千次阅读 2017-07-22 14:41:05
    贪心算法的特征: 将每一个配对集看成一个局部解决方案 1.先列出可能配对方案,并将其合拍度按降序排列。...哈弗曼算法属于贪心法一种,其基本思路是:编码以字符出现频率作为权重,每次选权重最小两个节
  • 聚类:事先不知道数据的类别,根据特征的相似度对数据进行聚类,属于非监督学习。 K-means算法基本思想: 在数据集中选择K个点作为每个簇的初始中心,然后观察剩余的数据,将数据划分到距离这K个点最近的簇中,...
  • KNN算法

    2018-01-23 20:18:35
     kNN算法的核心思想是如果一个样本在特征空间中k个最相邻样本中大多数属于某一个类别,则该样本也属于这个类别,并具有这个类别上样本特性。该方法在确定分类决策上只依据最邻近一个或者几个样本类别来...
  • 人脸检测和人脸识别都是属于典型机器学习方法,但是他们使用方法却相差很大。...作者详细分析了Adaboost算法在人脸检测中具体执行过程,尤其是关于弱分类器Haar特征选取过程,描述相当清晰。
  • 特征点检测和描述算法的应用比较广泛。在OpenCV中,除了SIFT和SURF之外,还有一些特征点检测...在这些算法中,BRIEF、FREAK属于特征点描述算子,其他一般都是检测特征点和描述特征点一起。SIFT和SURF的特征点...
  • 它是一种有监督学习,它是根据不同特征值之间距离来进行分类一种简单机器学习方法。算法介绍网上很多,我也是参考网上描述,下面有一个python实现简单knn算法大体描述: 事先有样本数据,每个数据都有...
  • k-近邻(k-Nearest Neighbour,简称KNN)是一种基本分类与回归方法,属于是有监督学习中分类算法。 二、 算法介绍 2.1 思路 k近邻算法的输入为实例的特征向量,对应于特征空间点;输出为实例类别,可以取多类...
  • 在得到森林之后,当有一个新输入样本进入时候,就让森林中每一棵决策树分别进行一下判断,看看这个样本应该属于哪一类(对于分类算法),然后看看哪一类被选择最多,就预测这个样本为那一类。我们可以这样比喻...
  • 该方法思路是:在特征空间中,如果一个样本附近k个最近(即特征空间中最邻近)样本大多数属于某一个类别,则该样本也属于这个类别。。一、KNN的基本思路所谓K近邻算法,即是给定一个训练数据集,对新输入实例...
  • 决策树算法

    2021-02-14 17:17:26
    Decision Tree是属于监督学习中一种算法,并且是一种基本的分类与回归的算法,也就是说,决策树有两种:分类树和回归树。 ​ 决策树算法的本质是树形结构。我们可以把决策树看作是一个if-then规则集合。将决策树...
  • 第一章程序设计基础知识 单项选择题 1以下( )是面向过程的程序设计...C)编写程序 D)调试和运行程序 3以下常用算法中适合计算等差级数的算法是( ) A)枚举法 B)递推法 C)分治法 D)排序法 4以下不属于算法基本特征的是( )
  • k近邻算法

    2018-12-26 21:23:49
    该方法思路是:如果一个样本在特征空间中k个最相似(即特征空间中最邻近)样本中大多数属于某一个类别,则该样本也属于这个类别。 K近邻算法简单,直观。给定一个训练数据集,对于新输入实例,在训练数据...
  • K近邻算法

    2019-06-24 19:18:17
    K近邻算法详解 近朱者赤,近墨者黑。 KNN简介 KNN原理 ...该方法的基本思路是:如果一个待分类样本在特征空间中k个最相似(即特征空间中K近邻)样本中大多数属于某一个类别,则该样本也属于这个...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 354
精华内容 141
关键字:

属于算法基本特征的是