什么样落实并使决策树算法?

正文对决策树算法进行简要的下结论和梳理,并对准知名的裁定树算法ID3(Iterative
Dichotomiser
迭代二分器)进行落实,实现利用Python语言,一句老梗,“人生苦短,我于是Python”,Python确实能够省多语言方面的转业,从而得以叫咱们注意让问题和解决问题之逻辑。

基于不同之数码,我实现了三单本子的ID3算法,复杂度逐步升级:

1.纯标称值无短缺失数据集

2.老是值与标称值混合且不论短缺失数据集

3.接连值与标称值混合,有少失数据集

首先单算法参考了《机器上实战》的多数代码,第二、三个算法基于前的实现进行模块的增多。

仲裁树简介

决定树算法不用说大家该还懂得,是机械上的一个红算法,由澳大利亚名牌计算机科学家Rose
Quinlan发表。

表决树是相同栽监督上之归类算法,目的是上学有同样粒决策树,该树中间节点是数据特征,叶子节点是种,实际分类时根据树的布局,一步一步冲当下多少特征取值选择上哪一样颗子树,直到走至叶子节点,叶子节点的种就是是此决定树对斯数量的学习结果。下图虽是千篇一律粒简单的仲裁树:

科学教案 1这个决定树用来判断一个装有纹理,触感,密度之西瓜是否是“好瓜”。

当起如此一个西瓜,纹理清晰,密度也0.333,触感硬滑,那么要你判定是否是一个“好瓜”,这时要经过表决树来判断,显然可以直接本着纹理->清晰->密度<=0.382->否,即是瓜不是“好瓜”,一糟裁决就如此好了。正因为决策树决策很有益,并且准确率为较高,所以常常让用来举行分类器,也是“机器上十异常算法”之一C4.5的主干考虑。

读有同样粒决策树要考虑一个问题,即 根据数量集构建当前培育应该选哪种属性作为树根,即分标准? 

设想最好的情形,一开始选有特征,就把数据集划分成,即于拖欠特征及取某个值的备是同样看似。

考虑最酷的状况,不断选择特征,划分后底数码集总是乱,就第二分类任务的话,总是有正类有负类,一直顶特征全部为此完了,划分的数据集合还是来正产生据,这时只能用投票法,正接近多就是选正类作为叶子,否则选负类。

因而得出了相似结论:
随着划分的进展,我们想选择一个特性,使得子节点包含的样本尽可能属于同一型,即“纯度”越强越好。

根据“纯度”的正规不同,有三种算法:

1.ID3算法(Iterative
Dichotomiser
迭代二分器),也是本文要实现的算法,基于信息增益即信息熵来度量纯度

2.C4.5算法(Classifier
4.5),ID3 的后算法,也是昆兰提出

3.CART算法(Classification
And Regression Tree),基于基尼指数度量纯度。

ID3算法简介

信息熵是信息论中之一个第一概念,也于“香农熵”,香农先生的事迹相比多人口都任罢,一个人口创造了同样家理论,牛之特别。香农理论遭遇一个怪重点的特性就是是”熵“,即”信息内容的不确定性“,香农在进行信息的定量测算的时节,明确地拿信息量定义也随机不定性程度的减。这即标志了外对信息之掌握:信息是用来减自由不定性的东西。或者发表为香农逆定义:信息是显眼的增加。这为说明了决策树因熵作为划分选择的气量标准的不错,即我们怀念再迅捷地起数遭到获得重新多信息,我们便应有迅速下降不确定性,即缩减”熵“。

信息熵定义为:

科学教案 2

D表示数据集,类别总数为|Y|,pk代表D中第k类样本所占有的比重。根据那定义,Ent的价更聊,信息纯度越强。Ent的范围是[0,log|Y|]

下要挑选某个属性进行划分,要依次考虑每个属性,假设当前设想属性a,a的取值有|V|种,那么我们要取a作为划分属性,划分到|V|个子节点后,所有子节点的音熵之与就分后的音信熵能够发生不行非常之缩减,减小的不过多的百般属性就是我们选的属性。

细分后的信熵定义为:

科学教案 3 

因此用属性a对样本集D进行分的音讯增益就是原本的消息熵减去划分后底信息熵:

科学教案 4

ID3算法就是这般每次选一个特性对样本集进行分,知道少种植状况要这进程停止:

(1)某个子节点样本全部属于同一像样

(2)属性都用了了,这时候要果实节点样本或不一样,那么只能少数服从多数了

科学教案 5(图片来源网络)

ID3算法实现(纯标称值)

设样本全部凡标称值即距离散值的口舌,会比较简单。

代码:

科学教案 6科学教案 7

from math import log
from operator import itemgetter
def createDataSet():            #创建数据集
    dataSet = [[1,1,'yes'],
               [1,1,'yes'],
               [1,0,'no'],
               [0,1,'no'],
               [0,1,'no']]
    featname = ['no surfacing', 'flippers']
    return dataSet,featname
def filetoDataSet(filename):
    fr = open(filename,'r')
    all_lines = fr.readlines()
    featname = all_lines[0].strip().split(',')[1:-1]
    print(featname)
    dataSet = []
    for line in all_lines[1:]:
        line = line.strip()
        lis = line.split(',')[1:]
        dataSet.append(lis)
    fr.close()
    return dataSet,featname
def calcEnt(dataSet):           #计算香农熵
    numEntries = len(dataSet)
    labelCounts = {}
    for featVec in dataSet:
        label = featVec[-1]
        if label not in labelCounts.keys():
            labelCounts[label] = 0
        labelCounts[label] += 1
    Ent = 0.0
    for key in labelCounts.keys():
        p_i = float(labelCounts[key]/numEntries)
        Ent -= p_i * log(p_i,2)
    return Ent
def splitDataSet(dataSet, axis, value):   #划分数据集,找出第axis个属性为value的数据
    returnSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            retVec = featVec[:axis]
            retVec.extend(featVec[axis+1:])
            returnSet.append(retVec)
    return returnSet
def chooseBestFeat(dataSet):
    numFeat = len(dataSet[0])-1
    Entropy = calcEnt(dataSet)
    DataSetlen = float(len(dataSet))
    bestGain = 0.0
    bestFeat = -1
    for i in range(numFeat):
        allvalue = [featVec[i] for featVec in dataSet]
        specvalue = set(allvalue)
        nowEntropy = 0.0
        for v in specvalue:
            Dv = splitDataSet(dataSet,i,v)
            p = len(Dv)/DataSetlen
            nowEntropy += p * calcEnt(Dv)
        if Entropy - nowEntropy > bestGain:
            bestGain = Entropy - nowEntropy
            bestFeat = i
    return bestFeat
def Vote(classList):
    classdic = {}
    for vote in classList:
        if vote not in classdic.keys():
            classdic[vote] = 0
        classdic[vote] += 1
    sortedclassDic = sorted(classdic.items(),key=itemgetter(1),reverse=True)
    return sortedclassDic[0][0]
def createDecisionTree(dataSet,featnames):
    featname = featnames[:]              ################
    classlist = [featvec[-1] for featvec in dataSet]  #此节点的分类情况
    if classlist.count(classlist[0]) == len(classlist):  #全部属于一类
        return classlist[0]
    if len(dataSet[0]) == 1:         #分完了,没有属性了
        return Vote(classlist)       #少数服从多数
    # 选择一个最优特征进行划分
    bestFeat = chooseBestFeat(dataSet)
    bestFeatname = featname[bestFeat]
    del(featname[bestFeat])     #防止下标不准
    DecisionTree = {bestFeatname:{}}
    # 创建分支,先找出所有属性值,即分支数
    allvalue = [vec[bestFeat] for vec in dataSet]
    specvalue = sorted(list(set(allvalue)))  #使有一定顺序
    for v in specvalue:
        copyfeatname = featname[:]
        DecisionTree[bestFeatname][v] = createDecisionTree(splitDataSet(dataSet,bestFeat,v),copyfeatname)
    return DecisionTree
if __name__ == '__main__':
    filename = "D:\\MLinAction\\Data\\西瓜2.0.txt"
    DataSet,featname = filetoDataSet(filename)
    #print(DataSet)
    #print(featname)
    Tree = createDecisionTree(DataSet,featname)
    print(Tree)

View Code

解释一下几单函数:

filetoDataSet(filename)
 将文件中之数目整理成数据集

calcEnt(dataSet)    
计算香农熵

splitDataSet(dataSet, axis, value)    
划分数据集,选择发生第axis独特性的取值为value的持有数据集,即D^v,并去丢第axis单特性,因为未需要了

chooseBestFeat(dataSet)    
 根据信息增益,选择一个太好之性

Vote(classList)      
 如果属性用了,类别仍未平等,投票决定

createDecisionTree(dataSet,featnames)    
递归创建决策树


之所以西瓜数据集2.0对准算法进行测试,西瓜数据集见 西瓜数据集2.0,输出如下:

['色泽', '根蒂', '敲声', '纹理', '脐部', '触感']
{'纹理': {'清晰': {'根蒂': {'蜷缩': '是', '硬挺': '否', '稍蜷': {'色泽': {'青绿': '是', '乌黑': {'触感': {'硬滑': '是', '软粘': '否'}}}}}}, '稍糊': {'触感': {'硬滑': '否', '软粘': '是'}}, '模糊': '否'}}

以能反映决策树的优越性即决定方便,这里根据matplotlib模块编写可视化函数treePlot,对转移的表决树进行可视化,可视化结果如下:

科学教案 8

 

由于数量最少,没有安装测试数据因证实其准确度,但是自己后面会基于乳腺癌的例证进行准确度的测试的,下面进入下一些:

出连续值的气象

发连续值的景象如果 西瓜数据集3.0 

一个性有老多种取值,我们必将不能够每个取值都举行一个分,这时候要对连续属性进行离散化,有几乎栽艺术供选择,其中有数种植是:

1.对准各个一样近乎别的数据集的连续值取平均值,再取各类的平均值的平均值作为划分点,将连属性化为寡类成为离散属性

2.C4.5动的第二细分效仿,排序离散属性,取诸半只之中部作为划分点的候选点,计算为每个划分点划分数据集的信息增益,取最好老的生划分点将接连属性化为简单好像成为离散属性,用该属性进行私分的音信增益就是刚计算的极端充分信增益。公式如下:

科学教案 9

此间运用第二种,并当上前对连日属性进行离散化。增加拍卖的代码如下:

def splitDataSet_for_dec(dataSet, axis, value, small):
    returnSet = []
    for featVec in dataSet:
        if (small and featVec[axis] <= value) or ((not small) and featVec[axis] > value):
            retVec = featVec[:axis]
            retVec.extend(featVec[axis+1:])
            returnSet.append(retVec)
    return returnSet
def DataSetPredo(filename,decreteindex):
    dataSet,featname = filetoDataSet(filename)
    Entropy = calcEnt(dataSet)
    DataSetlen = len(dataSet)
    for index in decreteindex:     #对每一个是连续值的属性下标
        for i in range(DataSetlen):
            dataSet[i][index] = float(dataSet[i][index])
        allvalue = [vec[index] for vec in dataSet]
        sortedallvalue = sorted(allvalue)
        T = []
        for i in range(len(allvalue)-1):        #划分点集合
            T.append(float(sortedallvalue[i]+sortedallvalue[i+1])/2.0)
        bestGain = 0.0
        bestpt = -1.0
        for pt in T:          #对每个划分点
            nowent = 0.0
            for small in range(2):   #化为正类负类
                Dt = splitDataSet_for_dec(dataSet, index, pt, small)
                p = len(Dt) / float(DataSetlen)
                nowent += p * calcEnt(Dt)
            if Entropy - nowent > bestGain:
                bestGain = Entropy-nowent
                bestpt = pt
        featname[index] = str(featname[index]+"<="+"%.3f"%bestpt)
        for i in range(DataSetlen):
            dataSet[i][index] = "是" if dataSet[i][index] <= bestpt else "否"
    return dataSet,featname

着重是先期处理函数DataSetPredo,对数据集提前离散化,然后再度拓展学习,学习代码类似。输出的核定树如下:

科学教案 10

有缺失失值的景象

数码发生欠失值是广大的情形,我们不好直接丢掉这些多少,因为这么见面损失大量数码,不经济,但是缺失失值我们吧束手无策判断她的取值。怎么处置吧,办法还是有。

设想少独问题: 

1.发缺乏失值时怎么进展划分选择

2.业已选分属性,有差失值的样本划不分,如何划分?

问题1:发出缺失失值时怎样进行划分选择**

主导思维是拓展极端优属性选择时,先就考虑无短缺失值样本,然后还趁以相应比例,得到在全样本集上的横情况。连带考虑到第二个问题来说,考虑被各个一个样本一个权重,此时每个样本不再总是让当作一个独立样本,这样便于第二个问题之解决:即只要样本在属于性a上的值缺失,那么将那看做是所有值都取,只不过取每个值的权重不均等,每个值的权重参考该值在无缺失值样本被的百分比,简单地说,比如在无缺失值样本集中,属性a取去两个值1和2,并且赢得1底权重和占有全权重和1/3,而得到2之权重和占2/3,那么根据该属性对样本集进行剪切时,遇到该属性上有缺乏失值的样本,那么我们以为该样本取值2的可能性还特别,于是将拖欠样本的权重乘以2/3由到取值为2之范本集中继续拓展剪切构造决策树,而随着1/3划及取值为1底样本集中继续组织。不明了自家说清楚没有。

公式如下:

科学教案 11

其中,D~表示数据集D在属性a上凭短缺失值的样书,根据它们来判定a属性的优劣,rho(即‘lou’)表示属性a的无缺失值样本占所有样本的百分比,p~_k表示无短缺失值样本中第k像样所占用的比例,r~_v表示不管缺失失值样本在属性a上取值为v的范本所占的百分比。

于划分样本时,如果来欠失值,则拿样本划分到所有子节点,在属性a取值v的子节点上之权重为r~_v
* 原来的权重。

复详实的解读参考《机器上》P86-87。

依据权重法修改后的ID3算法实现如下:

科学教案 12科学教案 13

from math import log
from operator import itemgetter

def filetoDataSet(filename):
    fr = open(filename,'r')
    all_lines = fr.readlines()
    featname = all_lines[0].strip().split(',')[1:-1]
    dataSet = []
    for line in all_lines[1:]:
        line = line.strip()
        lis = line.split(',')[1:]
        if lis[-1] == '2':
            lis[-1] = '良'
        else:
            lis[-1] = '恶'
        dataSet.append(lis)
    fr.close()
    return dataSet,featname

def calcEnt(dataSet, weight):           #计算权重香农熵
    labelCounts = {}
    i = 0
    for featVec in dataSet:
        label = featVec[-1]
        if label not in labelCounts.keys():
            labelCounts[label] = 0
        labelCounts[label] += weight[i]
        i += 1
    Ent = 0.0
    for key in labelCounts.keys():
        p_i = float(labelCounts[key]/sum(weight))
        Ent -= p_i * log(p_i,2)
    return Ent

def splitDataSet(dataSet, weight, axis, value, countmissvalue):   #划分数据集,找出第axis个属性为value的数据
    returnSet = []
    returnweight = []
    i = 0
    for featVec in dataSet:
        if featVec[axis] == '?' and (not countmissvalue):
            continue
        if countmissvalue and featVec[axis] == '?':
            retVec = featVec[:axis]
            retVec.extend(featVec[axis+1:])
            returnSet.append(retVec)
        if featVec[axis] == value:
            retVec = featVec[:axis]
            retVec.extend(featVec[axis+1:])
            returnSet.append(retVec)
            returnweight.append(weight[i])
        i += 1
    return returnSet,returnweight

def splitDataSet_for_dec(dataSet, axis, value, small, countmissvalue):
    returnSet = []
    for featVec in dataSet:
        if featVec[axis] == '?' and (not countmissvalue):
            continue
        if countmissvalue and featVec[axis] == '?':
            retVec = featVec[:axis]
            retVec.extend(featVec[axis+1:])
            returnSet.append(retVec)
        if (small and featVec[axis] <= value) or ((not small) and featVec[axis] > value):
            retVec = featVec[:axis]
            retVec.extend(featVec[axis+1:])
            returnSet.append(retVec)
    return returnSet

def DataSetPredo(filename,decreteindex):     #首先运行,权重不变为1
    dataSet,featname = filetoDataSet(filename)
    DataSetlen = len(dataSet)
    Entropy = calcEnt(dataSet,[1 for i in range(DataSetlen)])
    for index in decreteindex:     #对每一个是连续值的属性下标
        UnmissDatalen = 0
        for i in range(DataSetlen):      #字符串转浮点数
            if dataSet[i][index] != '?':
                UnmissDatalen += 1
                dataSet[i][index] = int(dataSet[i][index])
        allvalue = [vec[index] for vec in dataSet if vec[index] != '?']
        sortedallvalue = sorted(allvalue)
        T = []
        for i in range(len(allvalue)-1):        #划分点集合
            T.append(int(sortedallvalue[i]+sortedallvalue[i+1])/2.0)
        bestGain = 0.0
        bestpt = -1.0
        for pt in T:          #对每个划分点
            nowent = 0.0
            for small in range(2):   #化为正类(1)负类(0)
                Dt = splitDataSet_for_dec(dataSet, index, pt, small, False)
                p = len(Dt) / float(UnmissDatalen)
                nowent += p * calcEnt(Dt,[1.0 for i in range(len(Dt))])
            if Entropy - nowent > bestGain:
                bestGain = Entropy-nowent
                bestpt = pt
        featname[index] = str(featname[index]+"<="+"%d"%bestpt)
        for i in range(DataSetlen):
            if dataSet[i][index] != '?':
                dataSet[i][index] = "是" if dataSet[i][index] <= bestpt else "否"
    return dataSet,featname

def getUnmissDataSet(dataSet, weight, axis):
    returnSet = []
    returnweight = []
    tag = []
    i = 0
    for featVec in dataSet:
        if featVec[axis] == '?':
            tag.append(i)
        else:
            retVec = featVec[:axis]
            retVec.extend(featVec[axis+1:])
            returnSet.append(retVec)
        i += 1
    for i in range(len(weight)):
        if i not in tag:
            returnweight.append(weight[i])
    return returnSet,returnweight

def printlis(lis):
    for li in lis:
        print(li)

def chooseBestFeat(dataSet,weight,featname):
    numFeat = len(dataSet[0])-1
    DataSetWeight = sum(weight)
    bestGain = 0.0
    bestFeat = -1
    for i in range(numFeat):
        UnmissDataSet,Unmissweight = getUnmissDataSet(dataSet, weight, i)   #无缺失值数据集及其权重
        Entropy = calcEnt(UnmissDataSet,Unmissweight)      #Ent(D~)
        allvalue = [featVec[i] for featVec in dataSet if featVec[i] != '?']
        UnmissSumWeight = sum(Unmissweight)
        lou = UnmissSumWeight / DataSetWeight        #lou
        specvalue = set(allvalue)
        nowEntropy = 0.0
        for v in specvalue:      #该属性的几种取值
            Dv,weightVec_v = splitDataSet(dataSet,Unmissweight,i,v,False)   #返回 此属性为v的所有样本 以及 每个样本的权重
            p = sum(weightVec_v) / UnmissSumWeight          #r~_v = D~_v / D~
            nowEntropy += p * calcEnt(Dv,weightVec_v)
        if lou*(Entropy - nowEntropy) > bestGain:
            bestGain = Entropy - nowEntropy
            bestFeat = i
    return bestFeat

def Vote(classList,weight):
    classdic = {}
    i = 0
    for vote in classList:
        if vote not in classdic.keys():
            classdic[vote] = 0
        classdic[vote] += weight[i]
        i += 1
    sortedclassDic = sorted(classdic.items(),key=itemgetter(1),reverse=True)
    return sortedclassDic[0][0]

def splitDataSet_adjustWeight(dataSet,weight,axis,value,r_v):
    returnSet = []
    returnweight = []
    i = 0
    for featVec in dataSet:
        if featVec[axis] == '?':
            retVec = featVec[:axis]
            retVec.extend(featVec[axis+1:])
            returnSet.append(retVec)
            returnweight.append(weight[i] * r_v)
        elif featVec[axis] == value:
            retVec = featVec[:axis]
            retVec.extend(featVec[axis+1:])
            returnSet.append(retVec)
            returnweight.append(weight[i])
        i += 1
    return returnSet,returnweight

def createDecisionTree(dataSet,weight,featnames):
    featname = featnames[:]              ################
    classlist = [featvec[-1] for featvec in dataSet]  #此节点的分类情况
    if classlist.count(classlist[0]) == len(classlist):  #全部属于一类
        return classlist[0]
    if len(dataSet[0]) == 1:         #分完了,没有属性了
        return Vote(classlist,weight)       #少数服从多数
    # 选择一个最优特征进行划分
    bestFeat = chooseBestFeat(dataSet,weight,featname)
    bestFeatname = featname[bestFeat]
    del(featname[bestFeat])     #防止下标不准
    DecisionTree = {bestFeatname:{}}
    # 创建分支,先找出所有属性值,即分支数
    allvalue = [vec[bestFeat] for vec in dataSet if vec[bestFeat] != '?']
    specvalue = sorted(list(set(allvalue)))  #使有一定顺序
    UnmissDataSet,Unmissweight = getUnmissDataSet(dataSet, weight, bestFeat)   #无缺失值数据集及其权重
    UnmissSumWeight = sum(Unmissweight)      # D~
    for v in specvalue:
        copyfeatname = featname[:]
        Dv,weightVec_v = splitDataSet(dataSet,Unmissweight,bestFeat,v,False)   #返回 此属性为v的所有样本 以及 每个样本的权重
        r_v = sum(weightVec_v) / UnmissSumWeight          #r~_v = D~_v / D~
        sondataSet,sonweight = splitDataSet_adjustWeight(dataSet,weight,bestFeat,v,r_v)
        DecisionTree[bestFeatname][v] = createDecisionTree(sondataSet,sonweight,copyfeatname)
    return DecisionTree

if __name__ == '__main__':
    filename = "D:\\MLinAction\\Data\\breastcancer.txt"
    DataSet,featname = DataSetPredo(filename,[0,1,2,3,4,5,6,7,8])
    Tree = createDecisionTree(DataSet,[1.0 for i in range(len(DataSet))],featname)
    print(Tree)

View Code

发缺乏失值的情要 西瓜数据集2.0alpha

尝试结果:

科学教案 14

以乳腺癌数据集上的测试和表现

有了算法,我们自然想做肯定之测试看一样扣算法的见。这里我选了威斯康辛女性乳腺癌的多寡。

数据总共有9列,每一样排分别表示,以逗号分割

1 Sample
code number (病人ID)
2 Clump
Thickness 肿块厚度
3
Uniformity of Cell Size 细胞大小的均匀性
4
Uniformity of Cell Shape 细胞形状的均匀性
5
Marginal Adhesion 边缘粘
6 Single
Epithelial Cell Size 单上皮细胞的高低
7 Bare
Nuclei 裸核
8 Bland
Chromatin 乏味染色体
9 Normal
Nucleoli 正常核
10
Mitoses 有丝分裂
11 Class:
2 for benign, 4 formalignant(恶性或良性分类)

[from
Toby]

总共700漫长左右底数,选取最后80漫漫作为测试集,前面作为训练集,进行学习。

动分类器的代码如下:

import treesID3 as id3
import treePlot as tpl
import pickle

def classify(Tree, featnames, X):
    classLabel = "未知"
    root = list(Tree.keys())[0]
    firstGen = Tree[root]
    featindex = featnames.index(root)  #根节点的属性下标
    for key in firstGen.keys():   #根属性的取值,取哪个就走往哪颗子树
        if X[featindex] == key:
            if type(firstGen[key]) == type({}):
                classLabel = classify(firstGen[key],featnames,X)
            else:
                classLabel = firstGen[key]
    return classLabel

def StoreTree(Tree,filename):
    fw = open(filename,'wb')
    pickle.dump(Tree,fw)
    fw.close()

def ReadTree(filename):
    fr = open(filename,'rb')
    return pickle.load(fr)

if __name__ == '__main__':
    filename = "D:\\MLinAction\\Data\\breastcancer.txt"
    dataSet,featnames = id3.DataSetPredo(filename,[0,1,2,3,4,5,6,7,8])
    Tree = id3.createDecisionTree(dataSet[:620],[1.0 for i in range(len(dataSet))],featnames)
    tpl.createPlot(Tree)
    storetree = "D:\\MLinAction\\Data\\decTree.dect"
    StoreTree(Tree,storetree)
    #Tree = ReadTree(storetree)
    i = 1
    cnt = 0
    for lis in dataSet[620:]:
        judge = classify(Tree,featnames,lis[:-1])
        shouldbe = lis[-1]
        if judge == shouldbe:
            cnt += 1
        print("Test %d was classified %s, it's class is %s %s" %(i,judge,shouldbe,"=====" if judge==shouldbe else ""))
        i += 1
    print("The Tree's Accuracy is %.3f" % (cnt / float(i)))

训练有底决策树如下:

科学教案 15

终极的正确率可以看:

科学教案 16

正确率约为96%左右,算是不殊的分类器了。

自家之科学教案乳腺癌数据表现:http://7xt9qk.com2.z0.glb.clouddn.com/breastcancer.txt

至此,决策树算法ID3的落实了,下面考虑因基尼指数和信增益率进行分割选择,以及考虑实现剪枝过程,因为我们得观看地方训练出底决策树还设有正在群冗余分支,是因实现过程中,由于数据量太怪,每个分支都无了纯净,所以会创于生的分,但是分支投票的结果还要是一律的,而且数据量再特别,特征数还多吧,决策树会非常特别非常复杂,所以剪枝一般是必定做的同等步。剪枝分为先剪枝和后剪枝,如果细说的语句可形容死多矣。

此文亦可见:这里
参考资料:《机器上》《机器上实战》通过本次实战也发觉了马上点儿本书中的组成部分错的处在。

lz初学机器上不久,如发错漏的处在请求多包涵指出还是各位有什么想法或见欢迎评论去报告自己:)

Leave a Comment.