机器学习实战笔记-决策树

Posted 2020-10-15 kevincong

图3-1所示的流程图就是一个决策树，正方形代表判断模块(decisionblock),椭圆形代表终止模块(terminating block)，表示已经得出结论，可以终止运行。从判断模块引出的左右箭头称作分支（branch)，它可以到达另一个判断模块或者终止模块。
图3-1构造了一个假想的邮件分类系统，它首先检测发送邮件域名地址。如果地址为myEmpIoyer.com,则将其放在分类“无聊时需要阅读的邮件”中。如果邮件不是来自这个域名，则检查邮件内容里是否包含单词曲棍球，如果包含则将邮件归类到“需要及时处理的朋友邮件” ，如果不包含则将邮件归类到“无需阅读的垃圾邮件”。

K-近邻算法可以完成很多分类任务，但是它最大的缺点就是无法给出数据的内在含义，决策树的主要优势就在于数据形式非常容易理解。

1 决策树的构造
决策树
优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关特征数据。
缺点：可能会产生过度匹配问题。
适用数据类型：数值型和标称型。

主要思路:
在构造决策树时，我们需要解决的第一个问题就是，当前数据集上哪个特征在划分数据分类时起决定性作用。为了找到决定性的特征，划分出最好的结果，我们必须评估每个特征。完成测试之后，原始数据集就被划分为几个数据子集。这些数据子集会分布在第一个决策点的所有分支上。如果某个分支下的数据属于同一类型，则当前无需阅读的垃圾邮件已经正确地划分数据分类，无需进一步对数据集进行分割。如果数据子集内的数据不属于同一类型，则需要重复划分数据子集的过程。如何划分数据子集的算法和划分原始数据集的方法相同，直到所有具有相同类型的数据均在一个数据子集内。

创建分支的伪代码函数createBranch()如下所示:：
检测数据集中的每个子项是否属于同一分类：
If so return 类标签；
Else
寻找划分数据集的最好特征
划分数据集 ‘
创建分支节点
for每个划分的子集
调用函数createBranch并增加返回结果到分支节点中
return分支节点

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

表3-1的数据包含5个海洋动物，特征包括：不浮出水面是否可以生存，以及是否有脚蹼。我们可以将这些动物分成两类：鱼类和非鱼类。现在我们想要决定依据第一个特征还是第二个特征划分数据。在回答这个问题之前，我们必须采用量化的方法判断如何划分数据。

1.1信息増益
划分数据集的大原则是：将无序的数据变得更加有序。我们可以使用多种方法划分数据集，但是每种方法都有各自的优缺点。组织杂乱无章数据的一种方法就是使用信息论度量信息，信息论是量化处理信息的分支科学。我们可以在划分数据之前使用信息论量化度量信息的内容。在划分数据集之前之后信息发生的变化称为信息增益，知道如何计算信息增益，我们就可以计算每个特征值划分数据集获得的信息增益，获得信息增益最高的特征就是最好的选择。在可以评测哪种数据划分方式是最好的数据划分之前，我们必须学习如何计算信息增益。集合信息的度量方式称为香农熵或者简称为熵，这个名字来源于信息论之父克劳德?香农。
熵定义为信息的期望值，在明晰这个概念之前，我们必须知道信息的定义。如果待分类的事务可能划分在多个分类之中’ 则符号xi的信息定义为

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

其中n是分类的数目。

计算给定数据集的香农熵
代码:

from math import log 

def calcShannonEnt(dataSet): 

    labelCounts = {} 

    for featVec in dataSet: 

        currentLabel = featVec[-1] 

        labelCounts[currentLabel] = labelCounts.get(currentLabel,0) + 1 

    shannonEnt = 0.0 

    for key in labelCounts: 

        prob = float(labelCounts[key])/numEntries 

        shannonEnt -= prob * log(prob,2) 

    return shannonEnt

创建数据集
代码:

def createDataSet(): 

    dataSet = [[1,1,‘yes‘],[1,1,‘yes‘],[1,0,‘no‘],[0,1,‘no‘],[0,1,‘no‘]] 

    labels  = [‘no surfacing‘,‘flippers‘] 

    return dataSet,labels

测试截图:

如果我们将数据集中的第一行数据的分类改为’maybe’,测试截图如下:

我们发现，数据集的分类越分散，那么熵越大。得到熵之后，我们就可以按照获取最大信息增益的方法划分数据集

1.2划分数据集
分类算法除了需要测量信息熵，还需要划分数据集，度量花费数据集的熵，以便判断当前是否正确地划分了数据集。我们将对每个特征划分数据集的结果计算一次信息熵，然后判断按照哪个特征划分数据集是最好的划分方式

按照给定特征划分数据集，代码如下

def splitDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:
        if(featVec[axis] == value):
            reducedFeatVec = featVec[:axis]
            reducedFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet

测试截图如下:

接下来我们将遍历整个数据集，循环计算香农熵和splitDataSet()函数，找到最好的特征划分方式。熵计算将会告诉我们如何划分数据集是最好的数据组织方式。
代码:

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:
            subDataSet = splitDataSet(dataSet,i,value)
            prob = len(subDataSet)/float(len(dataSet))
            newEntropy += prob * calcShannonEnt(subDataSet)
        infoGain = baseEntropy - newEntropy
        if(infoGain > bestInfoGain):
            bestInfoGain = infoGain
            bestFeature = i
    return bestFeature

测试截图:

1.3递归构建决策树
工作原理：
得到原始数据集，然后基于最好的属性值划分数据集，由于特征值可能多于两个，因此可能存在大于两个分支的数据集划分。第一次划分之后，数据将被向下传递到树分支的下一个节点，在这个节点上，我们可以再次划分数据。因此我们可以采用递归的原则处理数据集。
递归结束的条件是：程序遍历完所有划分数据集的属性，或者每个分支下的所有实例都具有相同的分类。如果所有实例具有相同的分类，则得到一个叶子节点或者终止块。任何到达叶子节点的数据必然属于叶子节点的分类。
如果数据集已经处理了所有属性，但是类标签依然不是唯一的，此时我们需要决定如何定义该叶子节点，在这种情况下，我们通常会采用多数表决的方法决定该叶子节点的分类。

多数表决代码：

def majorityCnt(classList): 

    classCount = {} 

    for vote in classList: 

        classCount[vote] = classCount.get(vote,0) +1 

    sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True) 

    return sortedClassCount[0][0]

测试截图:

创建数的函数代码:

def c r e a teTree(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[:]#保证在递归的不同调用层级中的labels互不影响 

        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value) ,subLabels) 

    return myTree

测试截图:

需要注意的是，subLabels = labels[:],这行代码复制了类标签，并将其存储在新列表变量sublabels中。之所以这样做，是因为在python中函数参数是列表类型时，参数是按照引用方式传递的。为了保证每次调用函数createTree()不改变原始列表的内容，使用新变量subLabels代替原始列表。

2.在Python中使用Matplotlib注解绘制树形图
2.1Matplotlib注解
Matplotlib提供了一个注解工具annotations，非常有用，它可以在数据图形上添加文本注
释。注解通常用于解释数据的内容。由于数据上面直接存在文本描述非常丑陋，因此工具内嵌支
持带箭头的划线工具，使得我们可以在其他恰当的地方指向数据位置，并在此处添加描述信息，
解释数据内容。

使用文本注解绘制树节点
代码:

import matplotlib.pyplot as plt 

decisionNode = dict(boxstyle=”sawtooth”, fc=”0.8”) 

leafNode = dict(boxstyle=”round4”, fc=”0.8”) 

arrow_args = dict(arrowstyle=”<-“) 

def plotNode(nodeTxt, centerPt, parentPt, nodeType): 

    createPlot.ax1.annotate(nodeTxt, xy=parentPt,xycoords=’axes fraction’, xytext=centerPt, textcoords=’axes fraction’, va=”center”, ha=”center”, bbox=nodeType, arrowprops=arrow_args) 

def createPlot(): 

    fig = plt.figure(1,facecolor=”white”) 

    fig.clf() 

    createPlot.ax1=plt.subplot(111, frameon=False) 

    plotNode(‘a decision node’, (0.5, 0.1), (0.1, 0.5), decisionNode) 

    plotNode(‘a leaf node’, (0.8, 0.1), (0.3, 0.8), leafNode) 

    plt.show() 

    测试截图: 

    

2.2构造注解树
绘制一棵完整的树需要一些技巧。我们虽然有x、y坐标，但是如何放置所有的树节点却是个问题。我们必须知道有多少个叶节点，以便可以正确确x轴的长度；我们还需要知道树有多少层，以便可以正确确定y轴的高度。这里我们定义两个新函数getNurnLeafs()和getTreeDepth( )，来获取叶节点的数目和树的层数
获取叶节点的数目和树的层数:
代码:

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 

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

测试截图:

绘制树的函数代码:

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) 

    #绘制树的主要方法 

def plotTree(myTree, parentPt, nodeTxt): 

    numLeafs = getNumLeafs(myTree) 

    depth = getTreeDepth(myTree) 

    firstStr = list(myTree.keys())[0] 

    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW,plotTree.yOff) 

    plotNode(firstStr, cntrPt, parentPt, decisionNode) 

    secondDict = myTree[firstStr] 

    plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD 

    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 

def createPlot(inTree): 

    fig = plt.figure(1,facecolor=”white”) 

    fig.clf() 

    axprops = dict(xticks=[],yticks=[]) 

    createPlot.ax1 = plt.subplot(111,frameon=False, **axprops) 

    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() 

    效果截图: 

    

3.测试和存储分类器
3.1测试算法：使用决策树执行分类
使用决策树的分类函数代码:

 

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

测试截图:

3.2使用算法：决策树的存储
构造决策树是很耗时的任务，即使处理很小的数据集，如前面的样本数据，也要花费几秒的
时间，如果数据集很大，将会耗费很多计算时间。然而用创建好的决策树解决分类问题，贝何以
很快完成。因此，为了节省计算时间，最好能够在每次执行分类时调用巳经构造好的决策树。为
了解决这个问题，需要使用python模块pickle序列化对象，。序列化对象可以在磁
盘上保存对象，并在需要的时候读取出来。任何对象都可以执行序列化操作，字典对象也不例外

3.3使用pickle模块存储决策树
代码:

def storeTree(inputTree,filename):
    import pickle
    fw = open(filename,‘wb+‘)
    pickle.dump(inputTree,fw)
    fw.close()
def grabTree(filename):
    import pickle
    fr = open(filename,‘rb+‘)
    return pickle.load(fr)

测试截图:

3.4示例：使用决策树预测隐形眼镜类型
(1 )收集数据：提供的文本文件。
(2 )准备数据：解析tab键分隔的数据行。
(3 )分析数据：快速检查数据，确保正确地解析数据内容，使用createPlot()函数绘制最终的树形图。
(4)训练算法：使用3.1节的createTree()函数。
(5)测试算法：编写测试函数验证决策树可以正确分类给定的数据实例。
(6)使用算法：存储树的数据结构，以便下次使用时无需重新构造树。
代码及测试截图:

版权声明：本文为博主原创文章，未经博主允许不得转载。