python3.5《机器学习实战》学习笔记（四）：决策树算法

转载请注明作者和出处：http://blog.csdn.net/u013829973
系统版本：window 7 （64bit）
文章中的完整代码在我的GitHub：https://github.com/weepon
python版本：python 3.5

1、 决策树

  决策树(decision tree)是一种基本的分类与回归方法。在分类问题中，表示基于特征对实例进行分类的过程，它可以认为是if-then规则的集合，也可以认为是定义在特征空间与类空间上的条件概率分布。决策树学习的经典算法：ID3，C4.5，CART

决策树的概念很简单，下图所示的流程图是一个简单的决策树

图1.1 流程图
其中，长方形代表判断模块(decision block)，椭圆形成代表终止模块(terminating block)，表示已经得出结论，可以终止运行。从判断模块引出的左右箭头称作为分支(branch)，它可以达到另一个判断模块或者终止模块。用专业的术语讲，分类决策树模型是一种描述对实例进行分类的树形结构。决策树由结点(node)和有向边(directed edge)组成。结点有两种类型：内部结点(internal node)和叶结点(leaf node)。内部结点表示一个特征或属性，叶结点表示一个类。图中的决策树，长方形和椭圆形都是结点。长方形的结点属于内部结点，椭圆形的结点属于叶结点，从结点引出的左右箭头就是有向边。而最上面的结点就是决策树的根结点(root node)。

  用决策树分类时，从根节点开始，对实例的某一特征进行测试，根据测试结果，将实例分配到其子节点；这时每一个子节点对应着该特征的一个取值。如此递归地对实例进行测试并分配，直至达到叶节点。最后将实例分到叶节点的类中。

使用决策树的一般流程：

• 收集数据：可以使用任何方法。
• 准备数据：对收集完的数据进行整理，注意：树构造算法只适用于标称型数据，因此数值型数据必须离散化。
• 分析数据：可以使用任何方法，决策树构造完成之后，我们可以检查决策树图形是否符合预期。
• 训练算法：这个过程也就是构造决策树，同样也可以说是决策树学习，就是构造一个决策树的数据结构。
• 测试算法：使用经验树计算错误率。
• 使用算法：此步骤可以使用适用于任何监督学习算法，而使用决策树可以更好地理解数据的内在含义。

2、 决策树的学习

通常，决策树的学习包括3个步骤：

• 特征选择
• 决策树的生成（只考虑局部最优）
• 决策树的剪枝（考虑全局最优）

2-1 特征选择

特征选择在于选取对训练数据具有分类能力的特征。这样可以提高决策树学习的效率，如果利用一个特征进行分类的结果与随机分类的结果没有很大差别，则称这个特征是没有分类能力的。经验上扔掉这样的特征对决策树学习的精度影响不大。通常特征选择的标准是信息增益或信息增益比。

2-1-1 信息增益

信息增益：在划分数据集之前之后信息发生的变化。知道如何计算信息增益，我们就可以计算每个特征值划分数据集获得的信息增益，获得信息增益最高的特征就是最好的选择。
首先看一下“熵”：
熵定义为信息的期望值。在信息论与概率统计中，熵是表示随机变量不确定性的度量。如果待分类的事务可能划分在多个分类之中，则符号 xi 的信息定义为

l(xi)=−log2p(xi)

其中 p(xi) 是选择该分类的概率。
为了计算熵，我们需要计算所有类别所有可能值包含的信息期望值(数学期望)，通过下面的公式得到：

H=−∑i=0np(xi)log2p(xi)

期中 n 是分类的数目。熵越大，随机变量的不确定性就越大。
下面计算给定数据集的香农熵（熵），代码如下：

from math import log
import operator

'''
函数说明:创建数据集
Parameters:
    无
Returns:
    dataSet - 数据集
    labels - 分类属性(特征)
'''
def createDataSet():    # 数据来自《统计学习方法》 表5.1贷款申请样本数据表
    dataSet = [[0, 0, 0, 0, 'no'],                        #数据集
            [0, 0, 0, 1, 'no'],
            [0, 1, 0, 1, 'yes'],
            [0, 1, 1, 0, 'yes'],
            [0, 0, 0, 0, 'no'],
            [1, 0, 0, 0, 'no'],
            [1, 0, 0, 1, 'no'],
            [1, 1, 1, 1, 'yes'],
            [1, 0, 1, 2, 'yes'],
            [1, 0, 1, 2, 'yes'],
            [2, 0, 1, 2, 'yes'],
            [2, 0, 1, 1, 'yes'],
            [2, 1, 0, 1, 'yes'],
            [2, 1, 0, 2, 'yes'],
            [2, 0, 0, 0, 'no']]
    labels = ['age', 'job', 'house', 'credit'] #分类属性
    #转化成离散值
    return dataSet, labels

'''
函数说明:计算数据集香农熵
Parameters:
    dataSet - 数据集
Returns:
    shannonEnt 香农熵
'''
def calcShannonEnt(dataSet):
    numEntries = len(dataSet)                     # 计算数据集的实例总数
    labelCounts = {}
    for featVec in dataSet:                       # 计算每个类别出现的次数的字典
        currentLabel = featVec[-1]                # 取每个样本的类别，并计算出现的次数
        if currentLabel not in labelCounts.keys(): labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1
    shannonEnt = 0.0
    for key in labelCounts:                            #计算香农熵
        prob = float(labelCounts[key])/numEntries      # 计算该类别的概率
        shannonEnt -= prob * log(prob,2)               # 利用公式，计算熵
    return shannonEnt
'''
函数说明:按照给定特征划分数据集

Parameters:
    dataSet - 待划分的数据集
    axis - 划分数据集的特征索引
    value - 需要返回的特征的值
Returns:
    retDataSet 划分后的数据集
'''    
def splitDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:                    ##遍历数据集
        if featVec[axis] == value:
            reducedFeatVec = featVec[:axis]     #删掉axis的特征，保留剩下的特征并存到retDataSet
            reducedFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet

'''
函数说明:选择最优特征

Parameters:
    dataSet - 数据集
Returns:
    bestFeature - 信息增益最大的(最优)特征的索引值
'''

def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1      #特征数
    baseEntropy = calcShannonEnt(dataSet)  #计算香农熵
    bestInfoGain = 0.0;                 #初始化最大信息增益变量
    bestFeature = -1
    for i in range(numFeatures):        #遍历所有特征
        featList = [example[i] for example in dataSet]#取所有样本的第一个特征
        uniqueVals = set(featList)       #去重复值
        newEntropy = 0.0
        for value in uniqueVals:        #按照第i个特征划分数据下的香农熵，信息增益
            subDataSet = splitDataSet(dataSet, i, value)
            prob = len(subDataSet)/float(len(dataSet))
            newEntropy += prob * calcShannonEnt(subDataSet)     
        infoGain = baseEntropy - newEntropy     # 信息增益
        print("第%d个特征的增益为%.3f" % (i, infoGain))
        if (infoGain > bestInfoGain):       #选择最大增益的特征索引
            bestInfoGain = infoGain         
            bestFeature = i
    return bestFeature    

2-1-2 信息增益比

C4.5算法与ID3类似，前者对后者进行了改进，C4.5在生成的过程中，使用信息增益比来选择特征。相关知识参考《统计学习方法》第五章。

2-2 决策树的生成

ID3算法的核心是在决策树的各个节点上应用信息增益准则选择特征，递归的构建决策树。
代码如下：

'''
函数说明:创建决策树（递归函数）

Parameters:
    dataSet - 训练数据集
    labels - 分类属性标签
    featLabels - 存储选择的最优特征标签
Returns:
    myTree - 决策树
'''
def createTree(dataSet,labels):
    classList = [example[-1] for example in dataSet]  #取数据集的类别标签
    if classList.count(classList[0]) == len(classList): 
        return classList[0]   #递归停止条件一：如果类别完全相同则停止继续划分
    if len(dataSet[0]) == 1:   #递归停止条件二：遍历完所有特征时返回出现次数最多的类标签
        return majorityCnt(classList)
    bestFeat = chooseBestFeatureToSplit(dataSet) #选择最优特征
    bestFeatLabel = labels[bestFeat]             # #最优特征的标签
    myTree = {bestFeatLabel:{}}             #根据最优特征的标签生成树
    del(labels[bestFeat])
    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)
    for value in uniqueVals:
        subLabels = labels[:]       #复制标签，递归创建决策树
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)
    return myTree 

上面程序的运行结果：

2-3 决策树的剪枝

构建决策树的算法有很多，比如C4.5、ID3和CART，这些算法在运行时并不总是在每次划分数据分组时都会消耗特征。由于特征数目并不是每次划分数据分组时都减少，因此这些算法在实际使用时可能引起一定的问题。目前我们并不需要考虑这个问题，只需要在算法开始运行前计算列的数目，查看算法是否使用了所有属性即可。

决策树生成算法递归地产生决策树，直到不能继续下去未为止。这样产生的树往往对训练数据的分类很准确，但对未知的测试数据的分类却没有那么准确，即出现过拟合现象。过拟合的原因在于学习时过多地考虑如何提高对训练数据的正确分类，从而构建出过于复杂的决策树。解决这个问题的办法是考虑决策树的复杂度，对已生成的决策树进行简化。

4、 绘制决策树（可视化）

决策树的主要优点是易于理解，如果不能直观地显示出来，就无法发挥其优势，接下来，我们学习绘制决策树。
代码如下：

'''
函数说明:获取决策树叶子结点的数目

Parameters:
    myTree - 决策树
Returns:
    numLeafs - 决策树的叶子结点的数目
'''
def getNumLeafs(myTree):
    numLeafs = 0
    firstStr = list(myTree.keys())[0]
    secondDict = myTree[firstStr]
    for key in secondDict.keys():
        if type(secondDict[key]).__name__=='dict':#测试该结点是否为字典，如果不是字典，代表此结点为叶子结点
            numLeafs += getNumLeafs(secondDict[key])
        else:   numLeafs +=1
    return numLeafs

'''
函数说明:获取决策树的层数

Parameters:
    myTree - 决策树
Returns:
    maxDepth - 决策树的层数
'''
def getTreeDepth(myTree):
    maxDepth = 0
    firstStr = list(myTree.keys())[0]
    secondDict = myTree[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

'''
函数说明:绘制结点

Parameters:
    nodeTxt - 结点名
    centerPt - 文本位置
    parentPt - 标注的箭头位置
    nodeType - 结点格式
Returns:
    无
'''
def plotNode(nodeTxt, centerPt, parentPt, nodeType):
    arrow_args = dict(arrowstyle="<-")                                            #定义箭头格式
    createPlot.ax1.annotate(nodeTxt, xy=parentPt,  xycoords='axes fraction',
             xytext=centerPt, textcoords='axes fraction',
             va="center", ha="center", bbox=nodeType, arrowprops=arrow_args)

'''
函数说明:标注有向边属性值

Parameters:
    cntrPt、parentPt - 用于计算标注位置
    txtString - 标注的内容
Returns:
    无
'''    
def plotMidText(cntrPt, parentPt, txtString):
    xMid = (parentPt[0]-cntrPt[0])/2.0 + cntrPt[0]
    yMid = (parentPt[1]-cntrPt[1])/2.0 + cntrPt[1]
    createPlot.ax1.text(xMid, yMid, txtString, va="center", ha="center", rotation=30)

    '''
函数说明:绘制决策树

Parameters:
    myTree - 决策树(字典)
    parentPt - 标注的内容
    nodeTxt - 结点名
Returns:
    无
'''
def plotTree(myTree, parentPt, nodeTxt):
    decisionNode = dict(boxstyle="sawtooth", fc="0.8")                                        #设置结点格式
    leafNode = dict(boxstyle="round4", fc="0.8")                                            #设置叶结点格式    
    numLeafs = getNumLeafs(myTree) 
    depth = getTreeDepth(myTree)
    firstStr = list(myTree.keys())[0]  
    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW, plotTree.yOff)  #中心位置
    plotMidText(cntrPt, parentPt, nodeTxt)
    plotNode(firstStr, cntrPt, parentPt, decisionNode)
    secondDict = myTree[firstStr]
    plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD             #y偏移
    for key in secondDict.keys():
        if type(secondDict[key]).__name__=='dict':#测试该结点是否为字典，如果不是字典，代表此结点为叶子结点  
            plotTree(secondDict[key],cntrPt,str(key))       
        else:  
            plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW  
            #不是叶结点，递归调用继续绘制
            plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
            plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))#如果是叶结点，绘制叶结点，并标注有向边属性值
    plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD
'''
函数说明:创建绘制面板

Parameters:
    inTree - 决策树(字典)
Returns:
    无
'''
def createPlot(inTree):
    fig = plt.figure(1, facecolor='white')
    fig.clf()                                                #清空fig
    axprops = dict(xticks=[], yticks=[])
    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops) #去掉x、y轴
    #createPlot.ax1 = plt.subplot(111, frameon=False) #ticks for demo puropses 
    plotTree.totalW = float(getNumLeafs(inTree))
    plotTree.totalD = float(getTreeDepth(inTree))
    plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0;
    plotTree(inTree, (0.5,1.0), '')
    plt.show()    

5、 测试决策树

'''
函数说明:使用决策树分类

Parameters:
    inputTree - 已经生成的决策树
    featLabels - 存储选择的最优特征标签
    testVec - 测试数据列表，顺序对应最优特征标签
Returns:
    classLabel - 分类结果
'''    
def classify(inputTree, featLabels, testVec):
    firstStr = list(inputTree.keys())[0]                                                      #获取决策树结点
    secondDict = inputTree[firstStr]                                                        #下一个字典
    featIndex = featLabels.index(firstStr)                                               
    for key in secondDict.keys():
        if testVec[featIndex] == key:
            if type(secondDict[key]).__name__ == 'dict':
                classLabel = classify(secondDict[key], featLabels, testVec)
            else: classLabel = secondDict[key]
    return classLabel

6、 保存、加载决策树模型

'''
函数说明:存储决策树

Parameters:
    inputTree - 已经生成的决策树
    filename - 决策树的存储文件名
Returns:
    无
'''
def storeTree(inputTree, filename):

    with open(filename, 'wb') as fw:
        pickle.dump(inputTree, fw)
'''
函数说明:读取决策树

Parameters:
    filename - 决策树的存储文件名
Returns:
    pickle.load(fr) - 决策树字典
'''
def grabTree(filename):
    fr = open(filename, 'rb')
    return pickle.load(fr)  

下面运行主函数：

if __name__ == '__main__':
    dataSet, labels = createDataSet()
    print(dataSet)
    print('香农熵为：',calcShannonEnt(dataSet))
    print('开始计算最优特征：')
    print("最优特征索引值:" + str(chooseBestFeatureToSplit(dataSet)))
    myTree = createTree(dataSet, labels)
    print('创建好的决策树：',myTree)
    createPlot(myTree)
    testVec = [0,1]       
    featLabels =['house','job']  
    result = classify(myTree, featLabels, testVec)
    print(result)
    storeTree(myTree, 'classifierStorage.txt')
    myTree1 = grabTree('classifierStorage.txt')
    print(myTree1)

运行结果如下：

总结

1、 决策树的优点：

• 数据形式易于理解。
• 计算复杂度不高，对中间值的确实不敏感，可以处理不相关特征数据。
• 需要准备的数据量不大，而其他的技术往往需要很大的数据集，需要创建虚拟变量，去除不完整的数据，但是该算法对于丢失的数据不能进行准确的预测。
• 决策树算法的时间复杂度(即预测数据)是用于训练决策树的数据点的对数
• 可以同时处理数值变量和分类变量。其他方法大都适用于分析一种变量的集合。
• 可以处理多值输出变量问题。
• 使用白盒模型。如果一个情况被观察到，使用逻辑判断容易表示这种规则。相反，如果是黑盒模型（例如人工神经网络），结果会非常难解释。
• 即使对真实模型来说，假设无效的情况下，也可以较好的适用。

2、 决策树的缺点：

• 决策树算法学习者可以创建复杂的树，但是没有推广依据，这就是所谓的过拟合，为了避免这种问题，出现了剪枝的概念，即设置一个叶子结点所需要的最小数目或者设置树的最大深度
• 决策树的结果可能是不稳定的，因为在数据中一个很小的变化可能导致生成一个完全不同的树，这个问题可以通过使用集成决策树来解决
• 众所周知，学习一个最优决策树是NP-完全问题。因此，实际决策树学习算法是基于启发式算法，如贪婪算法，寻求在每个节点上的局部最优决策。这样的算法不能保证返回全局最优决策树。对样本和特征的随机抽样可以防止整体效果偏差。
• 概念难以学习，因为决策树没有很好的解释他们，例如，XOR。
• 分类任务时，不能解决类别不平衡问题。

下一节开始决策树实战。。。