精华内容
下载资源
问答
  • 本文实例为大家分享了python实现决策树分类算法的具体代码,供大家参考,具体内容如下1、概述决策树(decision tree)——是一种被广泛使用的分类算法。相比贝叶斯算法,决策树的优势在于构造过程不需要任何领域知识...

    本文实例为大家分享了python实现决策树分类算法的具体代码,供大家参考,具体内容如下

    1、概述

    决策树(decision tree)——是一种被广泛使用的分类算法。

    相比贝叶斯算法,决策树的优势在于构造过程不需要任何领域知识或参数设置

    在实际应用中,对于探测式的知识发现,决策树更加适用。

    2、算法思想

    通俗来说,决策树分类的思想类似于找对象。现想象一个女孩的母亲要给这个女孩介绍男朋友,于是有了下面的对话:

    女儿:多大年纪了?

    母亲:26。

    女儿:长的帅不帅?

    母亲:挺帅的。

    女儿:收入高不?

    母亲:不算很高,中等情况。

    女儿:是公务员不?

    母亲:是,在税务局上班呢。

    女儿:那好,我去见见。

    这个女孩的决策过程就是典型的分类树决策。

    实质:通过年龄、长相、收入和是否公务员对将男人分为两个类别:见和不见

    假设这个女孩对男人的要求是:30岁以下、长相中等以上并且是高收入者或中等以上收入的公务员,那么这个可以用下图表示女孩的决策逻辑

    20171221154736801.jpg?20171121154754

    上图完整表达了这个女孩决定是否见一个约会对象的策略,其中:

    ◊绿色节点表示判断条件

    ◊橙色节点表示决策结果

    ◊箭头表示在一个判断条件在不同情况下的决策路径

    图中红色箭头表示了上面例子中女孩的决策过程。

    这幅图基本可以算是一颗决策树,说它“基本可以算”是因为图中的判定条件没有量化,如收入高中低等等,还不能算是严格意义上的决策树,如果将所有条件量化,则就变成真正的决策树了。

    决策树分类算法的关键就是根据“先验数据”构造一棵最佳的决策树,用以预测未知数据的类别

    决策树:是一个树结构(可以是二叉树或非二叉树)。其每个非叶节点表示一个特征属性上的测试,每个分支代表这个特征属性在某个值域上的输出,而每个叶节点存放一个类别。使用决策树进行决策的过程就是从根节点开始,测试待分类项中相应的特征属性,并按照其值选择输出分支,直到到达叶子节点,将叶子节点存放的类别作为决策结果。

    3、决策树构造

    假如有以下判断苹果好坏的数据样本:

    样本 红 大 好苹果

    0 1 1 1

    1 1 0 1

    2 0 1 0

    3 0 0 0

    样本中有2个属性,A0表示是否红苹果。A1表示是否大苹果。假如要根据这个数据样本构建一棵自动判断苹果好坏的决策树。

    由于本例中的数据只有2个属性,因此,我们可以穷举所有可能构造出来的决策树,就2棵,如下图所示:

    2017122115461127.png

    显然左边先使用A0(红色)做划分依据的决策树要优于右边用A1(大小)做划分依据的决策树。

    当然这是直觉的认知。而直觉显然不适合转化成程序的实现,所以需要有一种定量的考察来评价这两棵树的性能好坏。

    决策树的评价所用的定量考察方法为计算每种划分情况的信息熵增益:

    如果经过某个选定的属性进行数据划分后的信息熵下降最多,则这个划分属性是最优选择

    属性划分选择(即构造决策树)的依据:

    简单来说,熵就是“无序,混乱”的程度。

    通过计算来理解:

    1、原始样本数据的熵:

    样例总数:4

    好苹果:2

    坏苹果:2

    熵: -(1/2 * log(1/2) + 1/2 * log(1/2)) = 1

    信息熵为1表示当前处于最混乱,最无序的状态。

    2、两颗决策树的划分结果熵增益计算

    树1先选A0作划分,各子节点信息熵计算如下:

    0,1叶子节点有2个正例,0个负例。信息熵为:e1 = -(2/2 * log(2/2) + 0/2 * log(0/2)) = 0。

    2,3叶子节点有0个正例,2个负例。信息熵为:e2 = -(0/2 * log(0/2) + 2/2 * log(2/2)) = 0。

    因此选择A0划分后的信息熵为每个子节点的信息熵所占比重的加权和:E = e1*2/4 + e2*2/4 = 0。

    选择A0做划分的信息熵增益G(S, A0)=S - E = 1 - 0 = 1.

    事实上,决策树叶子节点表示已经都属于相同类别,因此信息熵一定为0。

    树2先选A1作划分,各子节点信息熵计算如下:

    0,2子节点有1个正例,1个负例。信息熵为:e1 = -(1/2 * log(1/2) + 1/2 * log(1/2)) = 1。

    1,3子节点有1个正例,1个负例。信息熵为:e2 = -(1/2 * log(1/2) + 1/2 * log(1/2)) = 1。

    因此选择A1划分后的信息熵为每个子节点的信息熵所占比重的加权和:E = e1*2/4 + e2*2/4 = 1。也就是说分了跟没分一样!

    选择A1做划分的信息熵增益G(S, A1)=S - E = 1 - 1 = 0.

    因此,每次划分之前,我们只需要计算出信息熵增益最大的那种划分即可。

    先做A0划分时的信息熵增益为1>先做A1划分时的信息熵增益,所以先做A0划分是最优选择!!!

    4、算法指导思想

    经过决策属性的划分后,数据的无序度越来越低,也就是信息熵越来越小

    5、算法实现

    梳理出数据中的属性

    比较按照某特定属性划分后的数据的信息熵增益,选择信息熵增益最大的那个属性作为第一划分依据,然后继续选择第二属性,以此类推

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • 决策树分类

    2018-01-30 22:12:33
    sklearn.tree模块提供了决策树模型,用于解决分类问题和回归问题。 使用的是DecisionTreeClassifier和export_graphviz,前者用于决策树构建,后者用于决策树可视化。DecisionTreeClassifier一共有12个参数: class...

    一、函数说明


    sklearn.tree模块提供了决策树模型,用于解决分类问题和回归问题。


    使用的是DecisionTreeClassifier和export_graphviz,前者用于决策树构建,后者用于决策树可视化。DecisionTreeClassifier一共有12个参数:

    class sklearn.tree.DecisionTreeClassifier(criterion='gini', splitter='best', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, class_weight=None, presort=False)


    参数说明如下:

    • criterion:特征选择标准,可选参数,默认是gini,可以设置为entropygini是基尼不纯度。entropy是香农熵。ID3算法使用的是entropy,CART算法使用的则是gini
    • splitter:特征划分点选择标准,可选参数,默认是best,可以设置为random。默认的”best”适合样本量不大的时候,而如果样本数据量非常大,此时决策树构建推荐”random”。主要考虑计算量。
    • max_features:划分时考虑的最大特征数,可选参数,默认是None。寻找最佳切分时考虑的最大特征数(n_features为总共的特征数),有如下6种情况: 
      • 如果max_features是整型的数,则考虑max_features个特征;
      • 如果max_features是浮点型的数,则考虑int(max_features * n_features)个特征;
      • 如果max_features设为auto,那么max_features = sqrt(n_features);
      • 如果max_features设为sqrt,那么max_featrues = sqrt(n_features),跟auto一样;
      • 如果max_features设为log2,那么max_features = log2(n_features);
      • 如果max_features设为None,那么max_features = n_features,也就是所有特征都用。
      • 一般来说,如果样本特征数不多,比如小于50,我们用默认的”None”就可以了,如果特征数非常多,我们可以灵活使用刚才描述的其他取值来控制划分时考虑的最大特征数,以控制决策树的生成时间。
    • max_depth:决策树最大深度,即层数,可选参数,默认是None(即不会限制子树的深度)。一般来说,数据少或者特征少的时候可以不管这个值。或者如果设置了min_samples_slipt参数,那么直到少于min_smaples_split个样本为止。如果模型样本量多,特征也多的情况下,推荐限制这个最大深度,常用的可以取值10-100之间。建议先限制决策树的深度,这样可以先观察下生成的决策树里数据的初步拟合情况,然后再决定是否要增加深度。
    • min_samples_split:内部节点再划分所需最小样本数,可选参数,默认是2。这个值限制了子树继续划分的条件。如果min_samples_split为整数,那么在切分内部结点的时候,min_samples_split作为最小的样本数,也就是说,如果样本已经少于min_samples_split个样本,则停止继续切分。如果min_samples_split为浮点数,那么min_samples_split就是一个百分比,ceil(min_samples_split * n_samples),数是向上取整的。如果样本量不大,不需要管这个值。如果样本量数量级非常大,则推荐增大这个值。
    • min_weight_fraction_leaf:叶子节点最小的样本权重和,可选参数,默认是0。这个值限制了叶子节点所有样本权重和的最小值,如果小于这个值,则会和兄弟节点一起被剪枝。一般来说,如果我们有较多样本有缺失值,或者分类树样本的分布类别偏差很大,就会引入样本权重,这时我们就要注意这个值了。
    • max_leaf_nodes:最大叶子节点数,可选参数,默认是None。通过限制最大叶子节点数,可以防止过拟合。如果加了限制,算法会建立在最大叶子节点数内最优的决策树。如果特征不多,可以不考虑这个值,但是如果特征分成多的话,可以加以限制,具体的值可以通过交叉验证得到。
    • class_weight:类别权重,可选参数,默认是None,也可以字典、字典列表、balanced。指定样本各类别的的权重,主要是为了防止训练集某些类别的样本过多,导致训练的决策树过于偏向这些类别。类别的权重可以通过{class_label:weight}这样的格式给出,这里可以自己指定各个样本的权重,或者用balanced,如果使用balanced,则算法会自己计算权重,样本量少的类别所对应的样本权重会高。当然,如果你的样本类别分布没有明显的偏倚,则可以不管这个参数,选择默认的None
    • random_state:可选参数,默认是None。随机数种子。如果是证书,那么random_state会作为随机数生成器的随机数种子。随机数种子,如果没有设置随机数,随机出来的数与当前系统时间有关,每个时刻都是不同的。如果设置了随机数种子,那么相同随机数种子,不同时刻产生的随机数也是相同的。如果是RandomState instance,那么random_state是随机数生成器。如果为None,则随机数生成器使用np.random。
    • min_impurity_split:节点划分最小不纯度,可选参数,默认是1e-7。这是个阈值,这个值限制了决策树的增长,如果某节点的不纯度(基尼系数,信息增益,均方差,绝对差)小于这个阈值,则该节点不再生成子节点。即为叶子节点 。
    • presort:数据是否预排序,可选参数,默认为False不排序。一般来说,不用理它就可以了。

    此外还提供了一些函数:




    详见官网


    二、使用


    预测隐形眼镜

    大致流程:


    1、构建训练集(mxn,m个样本,每个样本有n个特征)和标签集(mx1,m个训练样本的类别),并序列化

    2、若有必要,可对训练集进行预先的处理(标准化、区间缩放、归一化、二值化等。博客: 点击打开链接,官网: 点击打开链接

    3、构建分类器(DecisionTreeClassifier,返回分类器)

    4、模型拟合(分类器.fit(训练集,标签集),无返回值)

    5、预测(分类器.predict(一个测试样本),返回样本分类的类别)

    2.1 数据预处理


    因为在fit()函数不能接收string类型的数据,在使用fit()函数之前,我们需要对数据集进行编码,这里可以使用sklearn.preprocessing中的两种方法:

        为了对string类型的数据序列化,需要先生成pandas数据,这样方便我们的序列化工作。这里我使用的方法是,原始数据->字典->pandas数据->序列化,编写代码如下:

    #coding:utf-8
    from sklearn.preprocessing import LabelEncoder, OneHotEncoder
    from sklearn import tree
    import pandas as pd
    
    def createData():
        #加载文件
        with open('lenses.txt', 'r') as fr:
            #处理文件
            lenses = [inst.strip().split('\t') for inst in fr.readlines()]
        #提取每组数据的类别,保存在列表里
        lenses_target = []                                                        
        for each in lenses:
            lenses_target.append(each[-1])
    
        #原始数据->字典
        lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']#特征标签       
        lenses_list = []#保存lenses数据的临时列表
        lenses_dict = {}#保存lenses数据的字典,用于生成pandas
        for each_label in lensesLabels:#提取信息,生成字典
            for each in lenses:
                lenses_list.append(each[lensesLabels.index(each_label)])
            lenses_dict[each_label] = lenses_list
            lenses_list = []
    
        #字典->pandas数据                             
        lenses_pd = pd.DataFrame(lenses_dict)
        print(lenses_pd)
        
        #创建LabelEncoder()对象,用于序列化 
        le = LabelEncoder()
        #序列化
        for col in lenses_pd.columns:                                            
            lenses_pd[col] = le.fit_transform(lenses_pd[col])
        print(lenses_pd)                                                 
    
        return lenses_pd, lenses_target





    2.2 分类

    #coding:utf-8
    from sklearn.preprocessing import LabelEncoder, OneHotEncoder
    from sklearn import tree
    import pandas as pd
    
    def createData():
        #加载文件
        with open('lenses.txt', 'r') as fr:
            #处理文件
            lenses = [inst.strip().split('\t') for inst in fr.readlines()]
        #提取每组数据的类别,保存在列表里
        lenses_target = []                                                        
        for each in lenses:
            lenses_target.append(each[-1])
    
        #原始数据->字典
        lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']#特征标签       
        lenses_list = []#保存lenses数据的临时列表
        lenses_dict = {}#保存lenses数据的字典,用于生成pandas
        for each_label in lensesLabels:#提取信息,生成字典
            for each in lenses:
                lenses_list.append(each[lensesLabels.index(each_label)])
            lenses_dict[each_label] = lenses_list
            lenses_list = []
    
        #字典->pandas数据                             
        lenses_pd = pd.DataFrame(lenses_dict)
        print(lenses_pd)
        
        #创建LabelEncoder()对象,用于序列化 
        le = LabelEncoder()
        #序列化
        for col in lenses_pd.columns:                                            
            lenses_pd[col] = le.fit_transform(lenses_pd[col])
        print(lenses_pd)                                                 
    
        return lenses_pd, lenses_target
    
    def classifier0(data, labels):
        #创建DecisionTreeClassifier()类
        clf = tree.DecisionTreeClassifier(criterion='entropy', min_samples_split=3)
        #使用数据,构建决策树
        clf = clf.fit(data.values.tolist(), labels)
        print(clf)
        #预测
        print(clf.predict([[1,1,1,0]]))
        #绘制决策树
        tree.export_graphviz(clf,
                            #out_file = None,
                            feature_names = data.keys(),
                            class_names = clf.classes_,)
                            
    
    if __name__ == '__main__':
        data, labels = createData()
        classifier0(data, labels)
    


    此时的在当前目录下生成了tree.dot文件,保存了各节点的信息。

    注意:该算法只能做到二叉树,树的左枝为True,右枝为False。




    展开全文
  • 决策树模型就是需要通过样本数据构建一棵树,数中...决策树是一种基本的分类和回归的方法,所以可以分为分类决策树和回归决策树分类决策树主要适用于标称型数据(如苹果的颜色、形状、口味等特征数据),可以理解...

    决策树模型就是需要通过样本数据构建一棵树,数中除了叶子节点的每个节点都是一个数据特征的划分点,将待测数据的对应的特征和该节点上的划分特征做对比,然后将待测节点分到该节点的某个子节点上,然后再进行对比,直到叶子节点为止,然后判断待测数据的类型集合。

    决策树是一种基本的分类和回归的方法,所以可以分为分类决策树和回归决策树。分类决策树主要适用于标称型数据(如苹果的颜色、形状、口味等特征数据),可以理解为非数值化的,回归树就适用于数值型数据,可以是连续型的数据。

    决策树的学习过程是利用样本数据,依据损失函数最小化的原则建立决策树模型,其学习过程分为特征选择、决策树生成、决策树剪枝。特征选择就是依据损失最小化选择当前节点的划分标准是依据那个特征划分的;决策树的生成就是对每个节点选择合适的划分特征,直到结束的过程;决策树的剪枝就是防止过拟合,增加决策树泛化能力的过程。

    下面先介绍分类回归树:

    1. 特征选择

        特征选择就是为当前节点选择合适的划分属性,以符合损失最小的原则。通常在分类回归树的特征选择过程用到的是信息增益熵和信息增益比。

    信息增益熵:

        先从信息熵说起。在信息论与统计中,熵是随机变量不确定的度量。设X为随机变量,其概率分布为P(X=xi) = pi则X对应的信息熵为

                 

    从等式的右侧我们可以看出,熵的大小只与p值有关,所以修改上面的信息熵的形式:

           

    熵越大,随机变量的不确定性越大,也就越不能用该属性来分类。

    条件熵H(Y|X)是衡量在随机条件X的情况下,随机条件Y的不确定性。其定义为X给定条件下Y的条件概率分布的熵对X的数学期望

    这里还用区分苹果和梨的例子,假设一共100个水果样本。

    这里的n表示对应特征的值的种类数(样本的颜色特征:红色,绿色,灰色,黄色),此时n=4,pi表示第i个特征值占总的样本的频率,如果绿色的水果一共10个,那么绿色特征的p=1/10。后面的H(Y|X=xi)表示该特征值的信息熵,表示绿色水果对应的信息熵。各个特征值的频率乘以对应特征值的信息熵,然后求和就得到了该特征的信息熵,也就是颜色特征的信息熵。

    信息增益

        我们上面说了信息熵和条件信息熵,这些都是对于单个属性来说的,怎样衡量所有特征之间的比较关系以及对整体的影响,就是下来要说的信息增益的概念:

    特征A对训练数据集D的信息增益g(D,A),定义为集合D的经验熵H(D)与特征A给定条件下D的经验条件熵H(D|A)之差,即:

    信息熵H(D)表示对于数据集D进行分类的额不确定性,而经验条件熵表示在特征A给定的条件下对数据及D进行分类的不确定性,他们的差就是信息增益,表示由于特征A而使得对数据集D的分类的不确定性的减少程度。显然信息增益熵越大,对数据集D不确定性减少越多,也就是我们希望选择的分类特征。

    信息增益作为划分训练数据集的特征,存在偏向于选择取值较多的特征的问题(这个为什么这么说,没有太想明白)。可以使用信息增益比来对这一问题进行校正:

    ,分子很好理解是信息增益,那么分母呢?,n是A取值的个数,A是分类的特征,也就是特征值的个数|Di|也就是特征值Di的个数,|D|也就是样本的个数。

    1. 决策树的生成

    决策树的生成过程就是从根节点开始,根据特征选择的标准,依次选择每个节点的合适的分割特征,直到满足相应的条件为止;常用的有ID3算法和C4.5算法,两算法基本都差不多,只是过程中选择特征值的标准不一样。

    ID3:

        ID3算法用的是信息增益来选择每个节点的分割特征。其具体过程为:从根节点开始,计算数据集D所有特征的信息增益,然后选择信息增益最大的那个特征,作为根节点的划分特征,将待测数据划分为n个子集{D1,D2,…,Dn},然后这是个递归的过程,分别在各个子集上计算剩余特征的信息熵,在进行子集的划分,直到信息增益都特别小或者没有特征可以选择为止。

    决策树停止划分条件信息增益是否小于某个阈值ε,需要我们提前指定;如果是没有特征可选的停止,那极端情况就是每个叶子节点只有一个样本。

    C4.5算法:

        C4.5算法和ID3算法的过程是一样的,只不过是将特征选择的标准换成了信息增益比,阈值ε,变成了信息增益比的阈值,其他过程相同。

    1. 决策树的剪枝

        我们通过上述的两种算法构建出来的决策树,都是在训练数据上做的,换句话说就是对训练数据拟合度特别好,但是对测试数据集就不一定了,这就会出现对训练数据过拟合的情况;过拟合也是模型复杂的表现,所以就需要简化模型,使其具有更好的泛化能力;解决这个问题就是对已经生成的树进行剪枝,减掉某些子树或者叶子节点,从而简化模型。

    我们通过剪枝前后的损失函数来衡量是否进行剪枝,接下来搬上枯燥的公式:

    决策树的损失函数定义为:

    公式解释:T是决策树的叶子节点,|T|是叶子节点的个数,Nt是叶子节点样本的个数,其中:,Ntk表示在对应的子集中分类为k的子集的个数,所以合并两各式子,得到如下公式:

     

    其中对数系数的分母Nt抵消了,将上式简写为:

     

    C(T)表示对训练数据的预测误差,|T|表示模型复杂度,α>=0应该叫做调和系数(其实我觉得也可以看做是一个正则化系数),控制两者之间的影响。当α较大时,促使选择较简单的模型,较小的子树,当α交到时促使选择较复杂的模型,较大的树。α=0意味着只考虑模型与训练数据的拟合程度,不考虑模型复杂度。在α确定后,较大的子树,模型复杂度也高,与训练数据拟合程度好,较小的子树模型复杂度也低,与训练数据拟合程度不好。

    模型建立我们一般要有训练数据和测试数据,剪枝是我们用测试数据对生成的决策树进行剪枝。其中C(T)我们可以看到是对所有的进行求预测误差,所以在每次剪枝,我们都需要衡量剪枝前后的Cα(T)即决策树的损失函数,如果剪枝后损失更小,就剪枝,否则不剪。

    1. 总结

    分类决策树,由于特征值的个数是不确定的,所以每个节点的子节点的个数也是不确定的。而回归树就不一样了,回归树一般都是二叉树模型的。

     

    展开全文
  • 使用决策树实现分类

    万次阅读 多人点赞 2016-12-29 21:56:12
    决策树是一种树形结构,为人们提供决策依据,决策树可以用来回答yes和no问题,它通过树形结构将各种情况组合都表示出来,每个分支表示一次选择(选择yes还是no),直到所有选择都进行完毕,最终给出正确答案。

    这里写图片描述

    转载请注明出处:

    http://blog.csdn.net/gane_cheng/article/details/53897669

    http://www.ganecheng.tech/blog/53897669.html (浏览效果更好)

    决策树是一种树形结构,为人们提供决策依据,决策树可以用来回答yes和no问题,它通过树形结构将各种情况组合都表示出来,每个分支表示一次选择(选择yes还是no),直到所有选择都进行完毕,最终给出正确答案。

    本文介绍决策树如何来实现分类,并用来预测结果。

    先抛出问题。现在统计了14天的气象数据(指标包括outlook,temperature,humidity,windy),并已知这些天气是否打球(play)。如果给出新一天的气象指标数据:sunny,cool,high,TRUE,判断一下会不会去打球。

    outlooktemperaturehumiditywindyplay
    sunnyhothighFALSEno
    sunnyhothighTRUEno
    overcasthothighFALSEyes
    rainymildhighFALSEyes
    rainycoolnormalFALSEyes
    rainycoolnormalTRUEno
    overcastcoolnormalTRUEyes
    sunnymildhighFALSEno
    sunnycoolnormalFALSEyes
    rainymildnormalFALSEyes
    sunnymildnormalTRUEyes
    overcastmildhighTRUEyes
    overcasthotnormalFALSEyes
    rainymildhighTRUEno

    现在,我们想让所有输入情况可以更快的得到答案。也就是要求平均查找时间更短。当一堆数据区分度越高的话,比较的次数就会更少一些,也就可以更快的得到答案。

    下面介绍一些概念来描述这个问题。

    概念简介

    决策树

    决策树是一种树形结构,其中每个内部节点表示一个属性上的测试,每个分支代表一个测试输出,每个叶节点代表一种类别。

    决策树是一种十分常用的分类方法。他是一种监管学习,所谓监管学习就是给定一堆样本,每个样本都有一组属性和一个类别,这些类别是事先确定的,那么通过学习得到一个分类器,这个分类器能够对新出现的对象给出正确的分类。这样的机器学习就被称之为监督学习

    这里写图片描述

    香农熵

    这里写图片描述

    香农熵(entropy),简称熵,由美国数学家、信息论的创始人香农提出。用来定量表示信息的聚合程度,是信息的期望值。

    划分数据集的大原则是:将无序的数据变得更加有序。自然界各种物体已经在我们基础教育,高等教育中被学到。世界本来是充满各种杂乱信息的,但是被人类不停地认识到,认识的过程还是循序渐进的。原本杂乱的信息却被我们系统地组织起来了,这就要归功于分类了。

    学语文时,我们学习白话文,文言文,诗歌,唐诗,宋词,散文,杂文,小说,等等。
    学数学时,加减乘除,指数,对数,方程,几何,微积分,概率论,图论,线性,离散,等等。
    学英语时,名词,动词,形容词,副词,口语,语法,时态,等等。
    学历史时,中国史,世界史,原始社会,奴隶社会,封建社会,现代社会,等等。

    分类分的越好,我们理解,掌握起来就会更轻松。并且一个新事物出现,我们可以基于已经学习到的经验预测到它大概是什么。

    熵就是用来描述信息的这种确定与不确定状态的,信息越混乱,熵越大,信息分类越清晰,熵越小。

    我们来看一个例子,马上要举行世界杯赛了。大家都很关心谁会是冠军。假如我错过了看世界杯,赛后我问一个知道比赛结果的观众“哪支球队是冠军”? 他不愿意直接告诉我, 而要让我猜,并且我每猜一次,他要收一元钱才肯告诉我是否猜对了,那么我需要付给他多少钱才能知道谁是冠军呢? 我可以把球队编上号,从 1 到 32, 然后提问: “冠军的球队在 1-16 号中吗?” 假如他告诉我猜对了, 我会接着问: “冠军在 1-8 号中吗?” 假如他告诉我猜错了, 我自然知道冠军队在 9-16 中。 这样最多只需要五次, 我就能知道哪支球队是冠军。所以,谁是世界杯冠军这条消息的信息量只值五块钱。(球队第一种分类方式)

    我们实际上可能不需要猜五次就能猜出谁是冠军,因为象巴西、德国、意大利这样的球队得冠军的可能性比日本、美国、韩国等队大的多。因此,我们第一次猜测时不需要把 32 个球队等分成两个组,而可以把少数几个最可能的球队分成一组,把其它队分成另一组。然后我们猜冠军球队是否在那几只热门队中。我们重复这样的过程,根据夺冠概率对剩下的候选球队分组,直到找到冠军队。这样,我们也许三次或四次就猜出结果。因此,当每个球队夺冠的可能性(概率)不等时,“谁世界杯冠军”的信息量的信息量比五比特少。(球队第二种分类方式)

    熵定义为信息的期望值。求得熵,需要先知道信息的定义。如果待分类的事务可能划分在多个分类之中,则信息定义为

    l(xi)=log2p(xi)(1)

    其中, xi 表示第 i 个分类,p(xi) 表示选择第 i 个分类的概率。

    假如有变量X,其可能的分类有n种,熵,可以通过下面的公式得到:

    H(X)=i=1np(xi)log2p(xi)(2)

    其中, n 表示分类的数量。

    以上面球队为例,第一种分类的话,所得球队的熵为:

    H=i=1np(xi)log2p(xi)=(132log2132)×32=log2132=log2321=log232=5()

    如果是按第二种方式分类的话,假如,每个队得冠军的概率是这样的。

    球队分类获胜概率
    中国强队18%
    巴西强队18%
    德国强队18%
    意大利炮强队18%
    剩下的28只球队每队获胜概率都为1%弱队1%

    现在分成了两个队强队和弱队,需要分别计算两队的熵,然后再计算总的熵。

    强队的熵为:

    H=i=1np(xi)log2p(xi)=(14log214)×4=log214=log241=log24=2()

    弱队的熵为:

    H=i=1np(xi)log2p(xi)=(128log2128)×28=log2128=log2281=log2284.8()

    所得球队的总的熵为:

    H=0.72×2+0.28×4.82.784()

    可以看到,如果我们按照强弱队的方式来分类,然后再猜的话,平均只需要2.8次就可以猜出冠军球队。

    信息增益

    信息增益(information gain) 指的是划分数据集前后信息发生的变化。

    在信息增益中,衡量标准是看特征能够为分类系统带来多少信息,带来的信息越多,该特征越重要。对一个特征而言,系统有它和没它时信息量将发生变化,而前后信息量的差值就是这个特征给系统带来的信息量。所谓信息量,就是熵。

    特征T给聚类C或分类C带来的信息增益可以定义为

    IG(T)=H(C)H(C|T)(3)

    其中, IG(T) 表示特征 T 带来的信息增益, H(C) 表示未使用特征 T 时的熵, H(C|T) 表示使用特征 T 时的熵。并且 H(C) 一定会大于等于 H(C|T)

    例如,上面的球队按第一种分类得到的熵为 5,第二种分类得到的熵为 2.8,则强弱队这个特征为 32 只球队带来的信息增益则为:5-2.8=2.2 。

    信息增益最大的问题在于它只能考察特征对整个系统的贡献,而不能具体到某个类别上,这就使得它只适合用来做所谓“全局”的特征选择。

    一个特征带来的信息增益越大,越适合用来做分类的特征。

    构造决策树

    ID3 算法

    构造树的基本想法是随着树深度的增加,节点的熵迅速地降低。熵降低的速度越快越好(即信息增益越大越好),这样我们有望得到一棵高度最矮的决策树。

    好,现在用此算法来分析天气的例子。

    在没有使用任何特征情况下。根据历史数据,我们只知道新的一天打球的概率是9/14,不打的概率是5/14。此时的熵为:

    H=i=1np(xi)log2p(xi)=(514log2514+914log2914)(0.357×(1.486)+0.643×(0.637))0.940

    如果按照每个特征分类的话。属性有4个:outlook,temperature,humidity,windy。我们首先要决定哪个属性作树的根节点。

    对每项指标分别统计:在不同的取值下打球和不打球的次数。

    outlookyesno
    sunny23
    overcast40
    rainy32

    H(sunny)=i=1np(xi)log2p(xi)=(25log225+35log235)0.971

    H(overcast)=i=1np(xi)log2p(xi)=(log21)=0

    H(rainy)=i=1np(xi)log2p(xi)=(35log235+25log225)0.971

    因此如果用特征outlook来分类的话,总的熵为

    H(outlook)=514×0.971+0+514×0.9710.714×0.9710.694

    然后,求得特征outlook获得的信息增益。

    IG(outlook)=0.9400.694=0.246(outlook)

    用同样的方法,可以分别求出temperature,humidity,windy的信息增益。IG(temperature)=0.029,IG(humidity)=0.152,IG(windy)=0.048。

    因为 IG(outlook)>IG(humidity)>IG(windy)>IG(temperature)。所以根节点应该选择outlook特征来进行分类。

    这里写图片描述

    接下来要继续判断取temperature、humidity还是windy?在已知outlook=sunny的情况,根据历史数据,分别计算IG(temperature)、IG(humidity)和IG(windy),选最大者为特征。

    依此类推,构造决策树。当系统的信息熵降为0时,就没有必要再往下构造决策树了,此时叶子节点都是纯的–这是理想情况。最坏的情况下,决策树的高度为属性(决策变量)的个数,叶子节点不纯(这意味着我们要以一定的概率来作出决策,一般采用多数表决的方式确定此叶子节点)。

    构造决策树的一般过程

    1. 手机数据:可以使用任何方法。
    2. 准备数据:树构造算法只适用于标称型数据,因此数值型数据必须离散化。
    3. 分析数据:可以使用任何方法,构造树完成之后,我们应该检查图形是否符合预期。
    4. 训练算法:构造树的数据结构。
    5. 测试算法:使用经验树计算错误率。
    6. 使用算法:此步骤可以适用于任何监督学习算法,而使用决策树可以更好地理解数据的内在含义。

    Java实现

    定义数据结构

    这里写图片描述

    根据决策树的形状,我将决策树的数据结构定义如下。lastFeatureValue表示经过某个特征值的筛选到达的节点,featureName表示答案或者信息增益最大的特征。childrenNodeList表示经过这个特征的若干个值分类后得到的几个节点。

    public class Node
    {
        /**
         * 到达此节点的特征值
         */
        public String lastFeatureValue;
        /**
         * 此节点的特征名称或答案
         */
        public String featureName;
        /**
         * 此节点的分类子节点
         */
        public List<Node> childrenNodeList = new ArrayList<Node>();
    }

    定义输入数据格式

    文章最开始抛出的问题中的数据的输入格式是这样的。

    @feature
    outlook,temperature,humidity,windy,play
    
    @data
    sunny,hot,high,FALSE,no
    sunny,hot,high,TRUE,no
    overcast,hot,high,FALSE,yes
    rainy,mild,high,FALSE,yes
    rainy,cool,normal,FALSE,yes
    rainy,cool,normal,TRUE,no
    overcast,cool,normal,TRUE,yes
    sunny,mild,high,FALSE,no
    sunny,cool,normal,FALSE,yes
    rainy,mild,normal,FALSE,yes
    sunny,mild,normal,TRUE,yes
    overcast,mild,high,TRUE,yes
    overcast,hot,normal,FALSE,yes
    rainy,mild,high,TRUE,no

    存储输入数据

    在代码中,特征和特征值用List来存储,数据用Map来存储。

        //特征列表
        public static List<String> featureList = new ArrayList<String>();
        // 特征值列表
        public static List<List<String>> featureValueTableList = new ArrayList<List<String>>();
        //得到全局数据
        public static Map<Integer, List<String>> tableMap = new HashMap<Integer, List<String>>();

    初始化输入数据

    对输入数据进行初始化。

        /**
         * 初始化数据
         * 
         * @param file
         */
        public static void readOriginalData(File file)
        {
            int index = 0;
            try
            {
                FileReader fr = new FileReader(file);
                BufferedReader br = new BufferedReader(fr);
                String line;
                while ((line = br.readLine()) != null)
                {
                    // 得到特征名称
                    if (line.startsWith("@feature"))
                    {
                        line = br.readLine();
                        String[] row = line.split(",");
                        for (String s : row)
                        {
                            featureList.add(s.trim());
                        }
                    }
                    else if (line.startsWith("@data"))
                    {
                        while ((line = br.readLine()) != null)
                        {
                            if (line.equals(""))
                            {
                                continue;
                            }
                            String[] row = line.split(",");
                            if (row.length != featureList.size())
                            {
                                throw new Exception("列表数据和特征数目不一致");
                            }
                            List<String> tempList = new ArrayList<String>();
                            for (String s : row)
                            {
                                if (s.trim().equals(""))
                                {
                                    throw new Exception("列表数据不能为空");
                                }
                                tempList.add(s.trim());
                            }
                            tableMap.put(index++, tempList);
                        }
    
                        // 遍历tableMap得到属性值列表
                        Map<Integer, Set<String>> valueSetMap = new HashMap<Integer, Set<String>>();
                        for (int i = 0; i < featureList.size(); i++)
                        {
                            valueSetMap.put(i, new HashSet<String>());
                        }
                        for (Map.Entry<Integer, List<String>> entry : tableMap.entrySet())
                        {
                            List<String> dataList = entry.getValue();
                            for (int i = 0; i < dataList.size(); i++)
                            {
                                valueSetMap.get(i).add(dataList.get(i));
                            }
                        }
                        for (Map.Entry<Integer, Set<String>> entry : valueSetMap.entrySet())
                        {
                            List<String> valueList = new ArrayList<String>();
                            for (String s : entry.getValue())
                            {
                                valueList.add(s);
                            }
                            featureValueTableList.add(valueList);
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
                br.close();
            }
            catch (IOException e1)
            {
                e1.printStackTrace();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }

    计算给定数据集的香农熵

        /**
         * 计算熵
         * 
         * @param dataSetList
         * @return
         */
        public static double calculateEntropy(List<Integer> dataSetList)
        {
            if (dataSetList == null || dataSetList.size() <= 0)
            {
                return 0;
            }
            // 得到结果
            int resultIndex = tableMap.get(dataSetList.get(0)).size() - 1;
            Map<String, Integer> valueMap = new HashMap<String, Integer>();
            for (Integer id : dataSetList)
            {
                String value = tableMap.get(id).get(resultIndex);
                Integer num = valueMap.get(value);
                if (num == null || num == 0)
                {
                    num = 0;
                }
                valueMap.put(value, num + 1);
            }
            double entropy = 0;
            for (Map.Entry<String, Integer> entry : valueMap.entrySet())
            {
                double prob = entry.getValue() * 1.0 / dataSetList.size();
                entropy -= prob * Math.log10(prob) / Math.log10(2);
            }
            return entropy;
        }

    按照给定特征划分数据集

        /**
         * 对一个数据集进行划分
         * 
         * @param dataSetList
         *            待划分的数据集
         * @param featureIndex
         *            第几个特征(特征下标,从0开始)
         * @param value
         *            得到某个特征值的数据集
         * @return
         */
        public static List<Integer> splitDataSet(List<Integer> dataSetList, int featureIndex, String value)
        {
            List<Integer> resultList = new ArrayList<Integer>();
            for (Integer id : dataSetList)
            {
                if (tableMap.get(id).get(featureIndex).equals(value))
                {
                    resultList.add(id);
                }
            }
            return resultList;
        }

    选择最好的数据集划分方式

        /**
         * 在指定的几个特征中选择一个最佳特征(信息增益最大)用于划分数据集
         * 
         * @param dataSetList
         * @return 返回最佳特征的下标
         */
        public static int chooseBestFeatureToSplit(List<Integer> dataSetList, List<Integer> featureIndexList)
        {
            double baseEntropy = calculateEntropy(dataSetList);
            double bestInformationGain = 0;
            int bestFeature = -1;
    
            // 循环遍历所有特征
            for (int temp = 0; temp < featureIndexList.size() - 1; temp++)
            {
                int i = featureIndexList.get(temp);
    
                // 得到特征集合
                List<String> featureValueList = new ArrayList<String>();
                for (Integer id : dataSetList)
                {
                    String value = tableMap.get(id).get(i);
                    featureValueList.add(value);
                }
                Set<String> featureValueSet = new HashSet<String>();
                featureValueSet.addAll(featureValueList);
    
                // 得到此分类下的熵
                double newEntropy = 0;
                for (String featureValue : featureValueSet)
                {
                    List<Integer> subDataSetList = splitDataSet(dataSetList, i, featureValue);
                    double probability = subDataSetList.size() * 1.0 / dataSetList.size();
                    newEntropy += probability * calculateEntropy(subDataSetList);
                }
                // 得到信息增益
                double informationGain = baseEntropy - newEntropy;
                // 得到信息增益最大的特征下标
                if (informationGain > bestInformationGain)
                {
                    bestInformationGain = informationGain;
                    bestFeature = temp;
                }
            }
            return bestFeature;
        }
    

    多数表决不确定结果

    如果所有属性都划分完了,答案还没确定,需要通过多数表决的方式得到答案。

        /**
         * 多数表决得到出现次数最多的那个值
         * 
         * @param dataSetList
         * @return
         */
        public static String majorityVote(List<Integer> dataSetList)
        {
            // 得到结果
            int resultIndex = tableMap.get(dataSetList.get(0)).size() - 1;
            Map<String, Integer> valueMap = new HashMap<String, Integer>();
            for (Integer id : dataSetList)
            {
                String value = tableMap.get(id).get(resultIndex);
                Integer num = valueMap.get(value);
                if (num == null || num == 0)
                {
                    num = 0;
                }
                valueMap.put(value, num + 1);
            }
    
            int maxNum = 0;
            String value = "";
    
            for (Map.Entry<String, Integer> entry : valueMap.entrySet())
            {
                if (entry.getValue() > maxNum)
                {
                    maxNum = entry.getValue();
                    value = entry.getKey();
                }
            }
    
            return value;
        }
    

    创建决策树

        /**
         * 创建决策树
         * 
         * @param dataSetList
         *            数据集
         * @param featureIndexList
         *            可用的特征列表
         * @param lastFeatureValue
         *            到达此节点的上一个特征值
         * @return
         */
        public static Node createDecisionTree(List<Integer> dataSetList, List<Integer> featureIndexList, String lastFeatureValue)
        {
            // 如果只有一个值的话,则直接返回叶子节点
            int valueIndex = featureIndexList.get(featureIndexList.size() - 1);
            // 选择第一个值
            String firstValue = tableMap.get(dataSetList.get(0)).get(valueIndex);
            int firstValueNum = 0;
            for (Integer id : dataSetList)
            {
                if (firstValue.equals(tableMap.get(id).get(valueIndex)))
                {
                    firstValueNum++;
                }
            }
            if (firstValueNum == dataSetList.size())
            {
                Node node = new Node();
                node.lastFeatureValue = lastFeatureValue;
                node.featureName = firstValue;
                node.childrenNodeList = null;
                return node;
            }
    
            // 遍历完所有特征时特征值还没有完全相同,返回多数表决的结果
            if (featureIndexList.size() == 1)
            {
                Node node = new Node();
                node.lastFeatureValue = lastFeatureValue;
                node.featureName = majorityVote(dataSetList);
                node.childrenNodeList = null;
                return node;
            }
    
            // 获得信息增益最大的特征
            int bestFeatureIndex = chooseBestFeatureToSplit(dataSetList, featureIndexList);
            // 得到此特征在全局的下标
            int realFeatureIndex = featureIndexList.get(bestFeatureIndex);
            String bestFeatureName = featureList.get(realFeatureIndex);
    
            // 构造决策树
            Node node = new Node();
            node.lastFeatureValue = lastFeatureValue;
            node.featureName = bestFeatureName;
    
            // 得到所有特征值的集合
            List<String> featureValueList = featureValueTableList.get(realFeatureIndex);
    
            // 删除此特征
            featureIndexList.remove(bestFeatureIndex);
    
            // 遍历特征所有值,划分数据集,然后递归得到子节点
            for (String fv : featureValueList)
            {
                // 得到子数据集
                List<Integer> subDataSetList = splitDataSet(dataSetList, realFeatureIndex, fv);
                // 如果子数据集为空,则使用多数表决给一个答案。
                if (subDataSetList == null || subDataSetList.size() <= 0)
                {
                    Node childNode = new Node();
                    childNode.lastFeatureValue = fv;
                    childNode.featureName = majorityVote(dataSetList);
                    childNode.childrenNodeList = null;
                    node.childrenNodeList.add(childNode);
                    break;
                }
                // 添加子节点
                Node childNode = createDecisionTree(subDataSetList, featureIndexList, fv);
                node.childrenNodeList.add(childNode);
            }
    
            return node;
        }

    使用决策树对测试数据进行预测

        /**
         * 输入测试数据得到决策树的预测结果
         * @param decisionTree 决策树
         * @param featureList 特征列表
         * @param testDataList 测试数据
         * @return
         */
        public static String getDTAnswer(Node decisionTree, List<String> featureList, List<String> testDataList)
        {
            if (featureList.size() - 1 != testDataList.size())
            {
                System.out.println("输入数据不完整");
                return "ERROR";
            }
    
            while (decisionTree != null)
            {
                // 如果孩子节点为空,则返回此节点答案.
                if (decisionTree.childrenNodeList == null || decisionTree.childrenNodeList.size() <= 0)
                {
                    return decisionTree.featureName;
                }
                // 孩子节点不为空,则判断特征值找到子节点
                for (int i = 0; i < featureList.size() - 1; i++)
                {
                    // 找到当前特征下标
                    if (featureList.get(i).equals(decisionTree.featureName))
                    {
                        // 得到测试数据特征值
                        String featureValue = testDataList.get(i);
                        // 在子节点中找到含有此特征值的节点
                        Node childNode = null;
                        for (Node cn : decisionTree.childrenNodeList)
                        {
                            if (cn.lastFeatureValue.equals(featureValue))
                            {
                                childNode = cn;
                                break;
                            }
                        }
                        // 如果没有找到此节点,则说明训练集中没有到这个节点的特征值
                        if (childNode == null)
                        {
                            System.out.println("没有找到此特征值的数据");
                            return "ERROR";
                        }
    
                        decisionTree = childNode;
                        break;
                    }
                }
            }
            return "ERROR";
        }

    测试结果

    构建的决策树输出是这样的。

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <Node>
        <featureName>outlook</featureName>
        <childrenNodeList>
            <lastFeatureValue>rainy</lastFeatureValue>
            <featureName>windy</featureName>
            <childrenNodeList>
                <lastFeatureValue>FALSE</lastFeatureValue>
                <featureName>yes</featureName>
            </childrenNodeList>
            <childrenNodeList>
                <lastFeatureValue>TRUE</lastFeatureValue>
                <featureName>no</featureName>
            </childrenNodeList>
        </childrenNodeList>
        <childrenNodeList>
            <lastFeatureValue>sunny</lastFeatureValue>
            <featureName>humidity</featureName>
            <childrenNodeList>
                <lastFeatureValue>normal</lastFeatureValue>
                <featureName>yes</featureName>
            </childrenNodeList>
            <childrenNodeList>
                <lastFeatureValue>high</lastFeatureValue>
                <featureName>no</featureName>
            </childrenNodeList>
        </childrenNodeList>
        <childrenNodeList>
            <lastFeatureValue>overcast</lastFeatureValue>
            <featureName>yes</featureName>
        </childrenNodeList>
    </Node>
    

    转换成图是这样的。

    这里写图片描述

    此时输入数据进行测试。

    rainy,cool,high,TRUE

    得到结果为:

    判断结果:no

    与图中结果一致。

    源码下载

    本文实现代码可以从这里下载。

    http://download.csdn.net/detail/gane_cheng/9724922

    GitHub地址在这儿。

    https://github.com/ganecheng/DecisionTree

    决策树的优缺点

    优点

    计算复杂度不高,输出结果易于理解,对中间值的缺失不敏感,可以处理不相关特征数据。

    缺点

    可能会产生过度匹配问题。

    当特征和特征值过多时,这些匹配选项可能太多了,我们将这种问题称之为过度匹配(overfitting)。为了减少过度匹配问题,我们可以裁剪决策树,去掉一些不必要的叶子节点。如果叶子节点只能增加少许信息,则可以删除该结点,将它并入到其他叶子节点中去。

    另外,对于标称型数据 字符串还比较好说,对于数值型数据却无法直接处理,虽然可以将数值型数据划分区间转化为标称型数据,但是如果有很多特征都是数值型数据,还是会比较麻烦。

    参考文献

    《机器学习实战》(Machine Learning in Action),Peter Harrington著,人民邮电出版社。

    http://www.99cankao.com/numbers/log-antilog.php

    http://www.cnblogs.com/zhangchaoyang/articles/2196631.html

    http://baike.baidu.com/item/%E9%A6%99%E5%86%9C%E7%86%B5

    http://www.cnblogs.com/bourneli/archive/2013/03/15/2961568.html

    http://www.cnblogs.com/leoo2sk/archive/2010/09/19/decision-tree.html

    展开全文
  • 决策树分类(decision tree classification)和python实现

    万次阅读 多人点赞 2018-04-22 16:48:47
    决策树分类很符合人类分类时的思想,决策树分类时会提出很多不同的问题,判断样本的某个特征,然后综合所有的判断结果给出样本的类别。例如下图的流程即为一个典型的决策树分类的流程图,这个流程图用来简略的判断一...
  • 决策树分类算法

    2019-05-21 16:22:28
    机器学习非集成学习的算法ID3算法信息熵信息增益完整的例子(来自赵卫东的机器学习一书)算法思想(类似贪婪算法)集成学习的算法 ...一颗决策树由决策结点、分支和叶子结点组成,决策结点表示在样...
  • 决策树:创建此存储库是为了学习如何针对特定目的实施决策树以进行分类
  • 与SVM类似,决策树在机器学习算法中是一个功能非常全面的算法,它可以执行分类与回归任务,甚至是多输出任务。决策树的算法非常强大,即使是一些复杂的问题,也可以良好地拟合复杂数据集。决策树同时也是随机森林的...
  • 目录决策树 决策树
  • 分类算法-决策树分类

    2021-03-03 15:16:53
    决策树分类决策树分类1.基本思想2.决策树的特点3.二叉决策树算法与分类规则的生成4.决策树分类算法5.决策树属性的选取 决策树分类   数据分类的基本流程: 两步:  (1)对一个类别已经确定的数据集创建模型。...
  • 基于决策树的多分类Article Outline 文章大纲 What is a decision tree? 什么是决策树? Why use them? 为什么要使用它们? Data Background 资料背景 Descriptive Statistics 描述性统计 Decision Tree Training ...
  • 决策树分类算法解析

    2021-02-21 13:56:52
    标题决策树分类算法解析 1. 决策树算法简介 决策树算法简介 决策树是一种应用非常广泛的算法,比如语音识别、人脸识别、医疗诊断、模式识别等。 决策树算法既可以解决分类问题(对应的目标值是类别型的数据),也能...
  • 需要用到的库(pandas传送门)2,数据集3,计算香农熵4,信息增益5,数据集最佳切分函数找出最佳切分列按照给定列切分数据集6,递归构建决策树ID3 算法编写代码构建决策树决策树的存储使用决策树执行分类预测7,使用...
  • 机器学习笔记(三)决策树分类一.简介二.先看一个简单的例子三.决策树分类原理1.分类过程概述2.训练过程(1)递归分裂(2)最佳分裂及分裂条件(3)叶子节点的标签(4)终止分裂四.手写鸢尾花分类1. 数据集介绍2. ...
  • 分类算法之决策树

    2019-01-19 13:24:00
    决策树是非线性有监督的分类模型。 决策树是一种树形结构,树内部每个节点表示一个属性上的测试,每个分支代表一个测试输出,每个叶子节点代表一个分类类别。通过训练数据构建决策树,可以对未知数据进行分类。 1....
  • 分类决策树的理解

    2017-11-19 11:25:47
    决策树是一种用于分类预测的算法。其步骤可以分为:1)确定分类的根节点;2)确定根节点后进一步分裂的节点;3)确定最终的叶节点;它是一个递归树,意思是,后面的每一个新的决策树都可以在此基础上进行递归实现。...
  • 决策树分类方法

    2016-11-05 18:25:00
    在博弈论中常常使用决策树寻找最优决策,这些决策树往往是人工生成的。在数据挖掘过程中,决策树的生成通常是通过对数据的拟合、学习,从数据集中获取到一棵决策树决策树的形式,从根节点到叶子节点的路径就是...
  • 决策树和随机森林:决策树和随机森林都是非线性有监督的分类模型。 决策树是一种树形结构,树内部每个节点表示一个属性上的测试,每个分支代表一个测试输出,每个叶子节点代表一个分类类别。通过训练数据构建决策树...
  • 分类算法-决策树

    2018-05-16 08:12:36
    姓名:Jyx ...类似于我们平时对物体进行分类的决策过程,每次根据一个属性对样本进行分类,知道达到终止条件,最后再根据一定的规则对树的叶子指定所属类。 最普通的决策树是将空间分成一个个超矩形,...
  • Python Spark MLlib之决策树分类

    千次阅读 2018-09-13 13:58:48
    (2) numClasses:指定分类数目 (3) categoricalFeaturesInfo:设置分类特征字段信息,本例采用OneHot编码处理离散/分类特征字段,故这里设置为空字典dict() (4) impurity:决策树的impurity评估方法(划分的度量...
  • 文章目录决策分类树引入重要参数1,criterion2,splitter3,max_depth4,min_samples_leaf5,min_samples_split6,max_features7,class_weight重要属性重要方法决策回归 决策分类树 引入 from sklearn.tree ...
  • Spark Mllib之决策树-分类与回归

    千次阅读 2018-09-06 09:21:42
    微信公众号:数据挖掘与分析学习 决策树及其集成算法是分类和回归的机器学习任务的...spark.mllib支持使用连续和分类特征进行二分类和多类分类以及回归的决策树。该实现按行分区数据,允许数百万个实例的分布式训...
  • 决策树(Decision Tree)是一种基本的分类与回归方法,当决策树用于分类时称为分类树,用于回归时称为回归树。主要介绍分类树。 决策树由结点和有向边组成。结点有两种类型:内部结点和叶结点,其中内部结点表示一个...
  • 分类算法学习-决策树

    2021-09-03 16:18:22
    作为一种基本的分类算法,决策树的概念如同他的名字一样,是基于树这一定义而言的,通过特定的标准选择内部节点(就是树的分叉点)。决策树最为主要的三个步骤就是:特征选择,构建决策树,剪枝。 1、需要了解的是...
  • sklearn之分类决策树

    千次阅读 2017-07-14 08:33:27
    分类决策树 DecisionTreeClassifier 函数原型为 sklearn.tree.DecisionTreeClassifier(criterion=’gini’,spiltter=’best’, max_depth=None,min_samples_split=2,min_samples_leaf=1,min_weight_fraction_leaf...
  • 本篇是决策树系列的第二篇,介绍一下决策树... 决策树系列第一篇《分类决策树——树的生长》中提到过,树的生长是一种“完全”式的生长,终止条件也仅有“所有的样本属于同一类,或者所有的样本具有相同的属性值”...
  • 决策树

    2016-05-21 11:46:50
    决策树通过把实例从根节点排列到某个叶子结点来分类实例,叶子结点即为实例所属的分类。树上的每一个结点指定了对实例的某个属性的测试,并且该结点的每一个后继分支对应于该属性的一个可能值。分类实例的方法是从这...
  • 决策树实现鸢尾花分类

    千次阅读 2018-10-22 13:41:10
    在这篇博客中,我们使用以下几个库来实现决策树算法 scikit-learn机器学习库 scikit-learn最先是由David Cournapeau在2007年发起的一个Google Summer of Code项目,从那时起这个项目就已经拥有很多的贡献者了,该...
  • 参考:... ...  决策树分类算法是数据分析邻域的一个常见算法。目前,该算法的python实现也已经很多,但是纸上得来终觉浅,不自己实现一把,就无法理解其中的奥妙和原

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,730
精华内容 13,092
关键字:

决策树特定分类