第三章决策树

小咪咪 2022-05-14 19:15 152阅读 0赞

# 第3章 决策树 #

## 决策树的构造 ##

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

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

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

**决策树的一般流程**

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

使用ID3算法划分数据集，该算法处理如何划分数据集，何时停止划分数据集（进一步的信息可以参见[http://en.wikipedia.org/wiki/ID3\_algorithm][http_en.wikipedia.org_wiki_ID3_algorithm] 。每次划分数据集时我们只选取一个特征属性，如果训练集中存在20个特征，第一次我们选择哪个特征作为划分的参考属性呢？

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

表3-1 海洋生物数据

<table> 
 <thead> 
  <tr> 
   <th align="center">样本</th> 
   <th align="center">不浮出水面是否能生存</th> 
   <th align="center">是否有脚蹼</th> 
   <th align="center">属于鱼类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">1</td> 
   <td align="center">是</td> 
   <td align="center">是</td> 
   <td align="center">是</td> 
  </tr> 
  <tr> 
   <td align="center">2</td> 
   <td align="center">是</td> 
   <td align="center">是</td> 
   <td align="center">是</td> 
  </tr> 
  <tr> 
   <td align="center">3</td> 
   <td align="center">是</td> 
   <td align="center">否</td> 
   <td align="center">否</td> 
  </tr> 
  <tr> 
   <td align="center">4</td> 
   <td align="center">否</td> 
   <td align="center">是</td> 
   <td align="center">否</td> 
  </tr> 
  <tr> 
   <td align="center">5</td> 
   <td align="center">否</td> 
   <td align="center">是</td> 
   <td align="center">否</td> 
  </tr> 
 </tbody> 
</table>

### 3.1.1 信息增益 ###

划分数据集的大原则是：将无序的数据变得更加有序。

在划分数据集之前之后信息发生的变化称为信息增益，知道如何计算信息增益，我们就可以计算每个特征值划分数据集获得的信息增益，获得信息增益最高的特征就是最好的选择。

熵定义为信息的期望值。如果待分类的事务可能划分在多个分类之中，则符号xi的信息定义为  
 l ( x i ) = − log ⁡ 2 p ( x i ) , 其 中 p ( x i ) 是 选 择 该 分 类 的 概 率 l\\left(x\_\{i\}\\right)=-\\log\_\{2\}p(x\_\{i\}) ,其中p(xi)是选择该分类的概率 l(xi)=−log2p(xi),其中p(xi)是选择该分类的概率

为了计算熵，我们需要计算所有类别所有可能值包含的信息期望值，通过下面的公式得到：  
 H = − ∑ i = 1 n p ( x i ) log ⁡ 2 p ( x i ) H=-\\sum\_\{i=1\}^\{n\}p\\left(x\_\{i\}\\right)\\log\_\{2\}p(x\_\{i\}) H=−i=1∑np(xi)log2p(xi)  
其中n是分类的数目。

# 计算给定数据集的熵
    def calcShannonEnt(dataSet):
        numEntries = len(dataSet)
        labelCounts = {
        }
        for featVec in dataSet:
            curentLabel = featVec[-1]
            if curentLabel not in labelCounts.keys():
                labelCounts[curentLabel] = 0
                labelCounts[curentLabel] += 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

另一个度量集合无序程度的方法是基尼不纯度，简单地说就是从一个数据集中随机选取子项，度量其被错误分类到其他分组里的概率。

### 3.1.2 划分数据集 ###

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

def splitDataSet(dataSet, axis, value):
        """
        按照给定特征划分数据集
        :param dataSet: 待划分的数据集
        :param axis:划分数据集的特征
        :param value:特征的返回值
        :return:划分后的数据集
        """
        retDataSet = []
        for featVec in dataSet:
            if dataSet[axis] == value:
                reducedFeatVec = featVec[:axis]
                reducedFeatVec.extend(featVec[axis+1:])
                retDataSet.append(reducedFeatVec)
        return retDataSet

> Python语言在函数中传递的是列表的引用，在函数内部对列表对象的修改，将会影响该列表对象的整个生存周期。为了消除这个不良影响，我们需要在函数的开始声明一个新列表对象。因为该函数代码在同一数据集上被调用多次，为了不修改原始数据集，创建一个新的列表对象。

假定存在两个列表，a和b:

a = [1, 2, 3]
    b = [4, 5, 6]
    a.append(b)
    a

[1, 2, 3, [4, 5, 6]]

如果执行a.append(b)，则列表得到了第四个元素，而且第四个元素也是一个列表。然而如果使用extend方法：

a = [1, 2, 3]
    b = [4, 5, 6]
    a.extend(b)
    a

[1, 2, 3, 4, 5, 6]

则得到一个包含a和b所有元素的列表。

# 选择最好的数据集划分方式
    def chooseBestFeatureToSplit(dataSet):
        numFeatures = len(dataSet) - 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.  第一个要求是，数据必须是一种由列表元素组成的列表，而且所有的列表元素都要具有相同的数据长度；
2.  第二个要求是，数据的最后一列或者每个实例的最后一个元素是当前实例的类别标签

### 3.1.3 递归构建决策树 ###

目前我们已经学习了从数据集构造决策树算法所需要的子功能模块，其工作原理如下：得到原始数据集，然后基于最好的属性值划分数据集，由于特征值可能多于两个，因此可能存在大于两个分支的数据集划分。第一次划分之后，数据将被向下传递到树分支的下一个节点，在这个节点上，我们可以再次划分数据。因此我们可以采用递归的原则处理数据集。  
递归结束的条件是：程序遍历完所有划分数据集的属性，或者每个分支下的所有实例都具有相同的分类。如果所有实例具有相同的分类，则得到一个叶子节点或者终止块。任何到达叶子节点的数据必然属于叶子节点的分类。

def createTree(dataSet, labels):
        """
        创建树
        :param dataSet: 数据集
        :param labels: 标签列表
        :return:
        """
        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

# 返回出现次数最多的分类名称
    def majorityCnt(classList):
        classCount = {
        }
        for vote in classList:
            if vote not in classCount.keys() : classCount[vote] = 0
            classCount[vote] += 1
        sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
        return sortedClassCount[0][0]

## 3.2 在 Python 中使用 Matplotlib 注解绘制树形图 ##

### 3.2.1 Matplotlib 注解 ###

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(nodeText, centerPt, parentPt, nodeType):
        createPlot.ax1.annotate(nodeText, 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()
    
    
    if __name__ == '__main__':
        createPlot()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RyYWN5ZHJhZ29ubHh5_size_27_color_FFFFFF_t_70]

### 3.2.2 构造注解树 ###

我们虽然有x、y坐标，但是如何放置所有的树节点却是个问题。我们必须知道有多少个叶节点，以便可以正确确定x轴的长度；我们还需要知道树有多少层，以便可以正确确定y轴的高度。

import matplotlib.pyplot as plt
    
    # 定义文本框和箭头格式
    decisionNode = dict(boxstyle="sawtooth", fc="0.8")
    leafNode = dict(boxstyle="round4", fc="0.8")
    arrow_args = dict(arrowstyle="<-")
    
    
    # 获取叶节点的数目
    def getNumLeafs(myTree):
        numLeafs = 0
        firstStr = list(myTree.keys())[0]
        secondDict = myTree[firstStr]
        for key in list(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 list(secondDict.keys()):
            if type(secondDict[key]).__name__ == 'dict':
                thisDepth = 1 + getTreeDepth(secondDict[key])
            else:
                thisDepth = 1
            if thisDepth > maxDepth:
                maxDepth = thisDepth
        return maxDepth
    
    
    # 使用文本注解绘制树节点
    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()
    
    
    # 绘制带箭头的注解
    def plotNode(nodeText, centerPt, parentPt, nodeType):
        createPlot.ax1.annotate(nodeText, xy=parentPt,
                                xycoords='axes fraction', xytext=centerPt,
                                textcoords='axes fraction', va="center", ha="center",
                                bbox=nodeType, arrowprops=arrow_args)
    
    
    # 在父子节点间填充文本信息
    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)
        # 标记子节点属性值
        plotMidText(cntrPt, parentPt, nodeTxt)
        plotNode(firstStr, cntrPt, parentPt, decisionNode)
        secondDict = myTree[firstStr]
        # 减少y偏移
        plotTree.yOff = plotTree.yOff - 1.0 / plotTree.totalD
        for key in list(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 retrieyeTree(i):
        listOfTrees = [{
        'no surfacing': {
        0: 'no', 1: {
        'flippers': {
        0: 'no', 1: 'yes'}}}},
                       {
        'no surfacing': {
        0: 'no', 1: {
        'flippers': {
        0: {
        'head': {
        0: 'no', 1: 'yes'}}, 1: 'no'}}}}]
        return listOfTrees[i]
    
    
    if __name__ == '__main__':
        # createPlot()
        mytree = retrieyeTree(1)
        # print(mytree)
        createPlot(mytree)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RyYWN5ZHJhZ29ubHh5_size_27_color_FFFFFF_t_70 1]

## 3.3 测试和存储分类器 ##

### 3.3.1 测试算法：使用决策树执行分类 ###

在执行数据分类时，需要决策树以及用于构造树的标签向量。然后，程序比较测试数据与决策树上的数值，递归执行该过程直到进入叶子节点；最后将测试数据定义为叶子节点所属的类型。

# 使用决策树的分类函数
    def classify(inputTree, featLabels, testVect):
        firstStr = list(inputTree.keys())[0]
        secondDict = inputTree[firstStr]
        # 将标签字符串转换为索引
        featIndex = featLabels.index(firstStr)
        for key in list(secondDict.keys()):
            if testVect[featIndex] == key:
                if type(secondDict[key]).__name__ == 'dict':
                    classLabel = classify(secondDict[key], featLabels, testVect)
                else:
                    classLabel = secondDict[key]
        return classLabel

### 3.3.2 使用算法：决策树的存储 ###

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

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 示例：使用决策树预测隐形眼镜类型 ##

将通过一个例子讲解决策树如何预测患者需要佩戴的隐形眼镜类型。使用小数据集，我们就可以利用决策树学到很多知识：眼科医生是如何判断患者需要佩戴的镜片类型；一旦理解了决策树的工作原理，我们甚至也可以帮助人们判断需要佩戴的镜片类型。

def loadData(file_name):
        fr = open(file_name)
        lenses = [inst.strip().split('\t') for inst in fr.readlines()]
        lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']
        return lenses, lensesLabels
    
    
    # 使用决策树的分类函数
    def classify(inputTree, featLabels, testVect):
        firstStr = list(inputTree.keys())[0]
        secondDict = inputTree[firstStr]
        # 将标签字符串转换为索引
        featIndex = featLabels.index(firstStr)
        for key in list(secondDict.keys()):
            if testVect[featIndex] == key:
                if type(secondDict[key]).__name__ == 'dict':
                    classLabel = classify(secondDict[key], featLabels, testVect)
                else:
                    classLabel = secondDict[key]
                    print('result=', classLabel)
    
    
    if __name__ == '__main__':
        myData, labels = loadData('./data/lenses.txt')
        myLabels = [inst for inst in labels]
        lensensTree = createTree(myData, myLabels)
        # print(lensensTree)
        # 绘制决策树
        createPlot(lensensTree)
        # 分类
        classify(lensensTree, labels, ['young', 'myope', 'yes', 'normal'])

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RyYWN5ZHJhZ29ubHh5_size_27_color_FFFFFF_t_70 2]

图3-8所示的决策树非常好地匹配了实验数据，然而这些匹配选项可能太多了。我们将这种问题称之为过度匹配（overfitting）。为了减少过度匹配问题，我们可以裁剪决策树，去掉一些不必要的叶子节点。如果叶子节点只能增加少许信息，则可以删除该节点，将它并入到其他叶子节点中。本章使用的算法称为ID3，它是一个好的算法但并不完美。ID3算法无法直接处理数值型数据，尽管我们可以通过量化的方法将数值型数据转化为标称型数值，但是如果存在太多的特征划分，ID3算法仍然会面临其他问题。

## 3.5 本章小结 ##

决策树分类器就像带有终止块的流程图，终止块表示分类结果。开始处理数据集时，我们首先需要测量集合中数据的不一致性，也就是熵，然后寻找最优方案划分数据集，直到数据集中的所有数据属于同一分类。ID3算法可以用于划分标称型数据集。构建决策树时，我们通常采用递归的方法将数据集转化为决策树。隐形眼镜的例子表明决策树可能会产生过多的数据集划分，从而产生过度匹配数据集的问题。我们可以通过裁剪决策树，合并相邻的无法产生大量信息增益的叶节点，消除过度匹配问题。

[http_en.wikipedia.org_wiki_ID3_algorithm]: http://en.wikipedia.org/wiki/ID3_algorithm
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RyYWN5ZHJhZ29ubHh5_size_27_color_FFFFFF_t_70]: /images/20220503/357763d5d79e48389196d13c386b84dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RyYWN5ZHJhZ29ubHh5_size_27_color_FFFFFF_t_70 1]: /images/20220503/b0fd3d22de134e14888fa33ba5c8cfde.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RyYWN5ZHJhZ29ubHh5_size_27_color_FFFFFF_t_70 2]: /images/20220503/a89b1c9d7b0a4e0994fbc01eeb928f76.png