《机器学习实战》—— 决策树

---

一、决策树的构造

决策树（decision tree）是一类常见的机器学习算法，它是基于树结构来进行决策的。从根节点开始一步步走到叶子节点（决策）。所有的数据最终都会落到叶子节点，既可以做分类也可以做回归。

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

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

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

1. 信息增益

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

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

在可以评测哪种数据划分方式就是最好的数据划分之前，必须学习如何计算信息增益。集合信息的度量方式称为香农熵 或者简称为熵 。

熵定义为信息的期望值，在明晰这个概念之前，我们必须知道信息的定义。如果待分类的事物可能划分在多个分类之中，则符号$x_i$ 的信息定义为
$$l(x_i)=-{\log }_{2}p(x_i)$$
其中$p(x_i)$是选择改分类的概率

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

当$p(x_i)=0$ 或 $p(x_i)=1$时， $H=0$，随机变量完全没有不确定性。
当$p(x_i)=0.5$时，$H=1$，随机变量的不确定性最大

计算给定数据集的香农熵：

'''
Parameters:
    dataSet - 数据集
Returns:
    shannonEnt - 返回计算给定数据集的香农熵
'''
def calcShannonEnt(dataSet):
    # 返回数据集的行数
    numEntries = len(dataSet)
    # 保存每个标签(Label)出现次数的字典
    labelCounts = {}
    # 对每组特征向量进行统计
    for featVec in dataSet:
        # 提取标签(Label)信息
        currentLabel = featVec[-1]
        # 如果标签(Label)没有放入统计次数的字典，添加进去
        if currentLabel not in labelCounts.keys():
            labelCounts[currentLabel] = 0
        # Label计数
        labelCounts[currentLabel] += 1
    # 香农熵
    shannonEnt = 0.0
    # 计算香农熵
    for key in labelCounts:
        # 选择该标签(Label)的概率
        prob = float(labelCounts[key])/numEntries
        # 利用公式计算香农熵
        shannonEnt -= prob * log(prob, 2)
    # 返回香农熵
    return shannonEnt

首先，计算数据集中实例的总数。然后，创建一个数据字典，它的键值时最后一列的数值。如果当前键值不存在，则扩展字典并将当前键值加入字典。每个键值都记录了当前类别出现的次数。最后，使用所有类标签的发生频率计算类别出现的概率。我们将用这个概率计算香农熵，统计所有类标签发生的次数。

海洋生物数据：

	不浮出水面是否可以生存	是否有脚蹼	属于鱼类
1	是	是	是
2	是	是	是
3	是	否	否
4	否	是	否
5	否	是	否

根据上表格创建简单鱼鉴定数据集

"""
Parameters:
    无
Returns:
    dataSet - 数据集
    labels - 分类属性
"""
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

if __name__ == '__main__':
    dataSet, labels = createDataSet()
    print(dataSet)
    print(calcShannonEnt(dataSet))

>>>
[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
0.9709505944546686

熵越高，则混合的数据也越多，我们可以在数据集中添加更多的分类，观察熵是如何变化的。添加第三个名为maybe的分类，测试熵的变化：

if __name__ == '__main__':
    dataSet, labels = createDataSet()
    dataSet[0][-1] = 'maybe'
    print(dataSet)
    print(calcShannonEnt(dataSet))

>>>
[[1, 1, 'maybe'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
1.3709505944546687

分类增多，计算得到的熵增大。得到熵之后，我们就可以按照获取最大信息增益的方法划分数据集。

2. 划分数据集

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

按照给定特征划分数据集：

"""
Parameters:
    dataSet - 待划分的数据集
    axis - 划分数据集的特征
    value - 需要返回的特征的值
Returns:
    retDataSet - 划分后的数据集
"""
def splitDataSet(dataSet, axis, value):
    # 创建返回的数据集列表
    retDataSet = []
    # 遍历数据集
    for featVec in dataSet:
        if featVec[axis] == value:
            # 去掉axis特征
            reducedFeatVec = featVec[:axis]
            # 将符合条件的添加到返回的数据集
            reducedFeatVec.extend(featVec[axis + 1:])
            retDataSet.append(reducedFeatVec)
    # 返回划分后的数据集
    return retDataSet

在之前简单样本数据上测试函数splitDataSet()：

if __name__ == '__main__':
    dataSet, labels = createDataSet()
    print(dataSet)
    print(splitDataSet(dataSet, 0 ,1))
    print(splitDataSet(dataSet, 0 ,0))

>>>
[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
[[1, 'yes'], [1, 'yes'], [0, 'no']]
[[1, 'no'], [1, 'no']]

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

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

"""
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):
        #获取dataSet的第i个所有特征
        featList = [example[i] for example in dataSet]
        # 创建set集合{},元素不可重复
        uniqueVals = set(featList)
        # 经验条件熵
        newEntropy = 0.0
        # 计算信息增益
        for value in uniqueVals:
            # subDataSet划分后的子集
            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

if __name__ == '__main__':
    dataSet, labels = createDataSet()
    print(dataSet)
    print(chooseBestFeatureToSplit(dataSet))

>>>
[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
第0个特征的增益为0.420
第1个特征的增益为0.171
0

最佳索引是0，也就是第一个特征是最好的用于划分数据集的特征。

3. 递归构建决策树

工作原理：得到原始数据集，然后基于最好的属性值划分数据集，由于特征值可能多于两个，因此可能存在大于两个分支的数据集划分。第一次划分之后，数据将被向下传递到树分支的下一个节点，在这个节点上，我们可以再次划分数据。因此我们可以采用递归的原则处理数据集。

递归结束的条件：程序遍历完所有划分数据集的属性，或者每个分支下的所有实例都具有相同的分类。如果所有实例具有相同的分类，则得到一个叶子节点或者终止块。任何到达叶子节点的数据必然属于叶子节点的分类。如果数据集已经处理了所有属性，但是类标签依然不是唯一的，此时我们需要决定如何定义该叶子节点，在这种情况下，我们通常会采用多数表决的方法决定该叶子节点的分类。

多数表决：

"""
Parameters:
    classList - 类标签列表
Returns:
    sortedClassCount[0][0] - 出现此处最多的元素(类标签)
"""
def majorityCnt(classList):
    classCount = {}
    # 统计classList中每个元素出现的次数
    for vote in classList:
        if vote not in classCount.keys():classCount[vote] = 0
        classCount[vote] += 1
    # 根据字典的值降序排序
    sortedClassCount = sorted(classCount.items(), key = operator.itemgetter(1), reverse = True)
    # 返回classList中出现次数最多的元素
    return sortedClassCount[0][0]

创建决策树：

"""
Parameters:
    dataSet - 训练数据集
    labels - 分类属性标签
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
        subLabels = labels[:]
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)
    return myTree

测试之前的简单数据集

if __name__ == '__main__':
    dataSet, labels = createDataSet()
    print(dataSet)
    myTree = createTree(dataSet, labels)
    print(myTree)

>>>
[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}

变量 myTree 包含了很多代表树结构信息的嵌套字典，从左边开始，第一个关键字 no surfacing 是第一个划分数据集的特征名称，该关键字的值也是另一个数据字典。第二个关键字是 no surfacing 特征划分的数据集，这些关键字的值是 no surfacing 节点的子节点。这些值可能是类标签（例如’flippers’），也可能是另一个数据字典。如果值是类标签，则该子节点是叶子节点；如果值是另一个数据字典，则子节点是一个判断节点，这种格式结构不断重复就构成了整棵树。这棵树包含了3个叶子节点以及2个判断节点。

二、在 Python 中使用 Matplotlib 注解绘制树形图

1. Matplotlib

使用文本注解绘制树节点：

# 定义文本框和箭头格式
decisionNode = dict(boxstyle="sawtooth", fc="0.8")
leafNode = dict(boxstyle="round4", fc="0.8")
arrow_args = dict(arrowstyle="<-")
"""
Parameters:
    nodeTxt - 结点名
    centerPt - 文本位置
    parentPt - 标注的箭头位置
    nodeType - 结点格式
Returns:
    无
"""
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()

if __name__ == '__main__':
    createPlot()

测试效果：

2. 构造注解树

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

获取叶节点的数目和树的层数：

"""
Parameters:
    myTree - 决策树
Returns:
    numLeafs - 决策树的叶子结点的数目
"""
def getNumLeafs(myTree):
    # 初始化叶子
    numLeafs = 0
    #python3中myTree.keys()返回的是dict_keys,不在是list,
    #所以不能使用myTree.keys()[0]的方法获取结点属性，可以使用list(myTree.keys())[0]
    firstStr = next(iter(myTree))
    # 获取下一组字典
    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
    #python3中myTree.keys()返回的是dict_keys,不在是list,
    #所以不能使用myTree.keys()[0]的方法获取结点属性，可以使用list(myTree.keys())[0]
    firstStr = next(iter(myTree))
    # 获取下一个字典
    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

函数 retrieveTree 输出预先存储的树信息，避免了每次测试代码时都要从数据中创建树的麻烦。

def retrieveTree(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__':
    print(retrieveTree(1))
    myTree = retrieveTree(0)
    print(getNumLeafs(myTree))
    print(getTreeDepth(myTree))

>>>
{'no surfacing': {0: 'no', 1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}
3
2

getNumLeafs()函数和getTreeDepths() 函数都返回了正确的结果。接下来绘制一颗完整的树。

标注有向边属性值:

"""
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 = next(iter(myTree))
    # 中心位置
    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 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
    fig = plt.figure(1, facecolor='white')
    # 清空fig
    fig.clf()
    axprops = dict(xticks=[], yticks=[])
    # 去掉x、y轴
    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)
    # 获取决策树叶结点数目
    plotTree.totalW = float(getNumLeafs(inTree))
    # 获取决策树层数
    plotTree.totalD = float(getTreeDepth(inTree))
    # x偏移
    plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0;
    # 绘制决策树
    plotTree(inTree, (0.5,1.0), '')
    # 显示绘制结果
    plt.show()

if __name__ == '__main__':
    myTree = retrieveTree(0)
    createPlot(myTree)

三、测试和存储分类器

1. 测试算法：使用决策树执行分类

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

使用决策树的分类函数：

"""
Parameters:
    inputTree - 已经生成的决策树
    featLabels - 存储选择的最优特征标签
    testVec - 测试数据列表，顺序对应最优特征标签
Returns:
    classLabel - 分类结果
"""
def classify(inputTree, featLabels, testVec):
    # 获取决策树结点
    firstStr = next(iter(inputTree))
    # 下一个字典
    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

if __name__ == '__main__':
    dataSet, labels = createDataSet()
    print(labels)
    myTree = retrieveTree(0)
    print(myTree)
    print(classify(myTree, labels, [1, 0]))
    print(classify(myTree, labels, [1, 1]))

>>>
['no surfacing', 'flippers']
{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}
no
yes

2. 使用算法：决策树的存储

构造决策树是很耗时的任务，即使处理很小的数据集，如前面的样本数据，也要花费几秒的时间，如果数据集很大，将会耗费很多计算时间。然而用创建好的决策树解决分类问题，则可以很快完成。因此，为了节省计算时间，最好能够在每次执行分类时调用已经构造好的决策树。

存储决策树:

"""
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__':
    myTree = retrieveTree(0)
    storeTree(myTree, 'classifierStorage.txt')
    grabTree('classifierStorage.txt')

通过上面的代码，我们可以将分类器存储在硬盘上，而不用每次对数据分类时重新学习一遍，这也是决策树的优点之一。

四、应用：使用决策树预测车辆的状况

车辆的状况分为四类:

• unacc (Unacceptable 状况很差)
• acc (Acceptable 状况一般)
• good (Good 状况好)
• vgood (Very good 状况非常好)

通过一下分类属性来判断车辆的状况：

• buying (购买价: vhigh, high, med, low)
• maint (维护价: vhigh, high, med, low)
• doors (几个门: 2, 3, 4, 5more)
• persons (载人量: 2, 4, more)
• lug_boot (贮存空间: small, med, big)
• safety (安全性: low, med, high)

数据样本：从UCI数据库网站下载，并从中随机分别抽取200条左右的数据当作训练集和测试集

可视化决策树：

if __name__ == '__main__':
    fr = open('carTrain.txt')
    cars = [inst.strip().split('\t') for inst in fr.readlines()]
    carLabels = ['buying', 'maint', 'doors', 'persons', 'lub_boot', 'safety']
    carsTree = createTree(cars, carLabels)
    print(carsTree)
    createPlot(carsTree)

测试结果：

>>>
{'safety': {'low': 'unacc', 'med': {'persons': {'2': 'unacc', '4': {'buying': {'low': {'maint': {'low': 'acc', 'med': 'good', 'high': 'acc', 'vhigh': 'acc'}}, 'med': {'maint': {'low': 'acc', 'med': 'acc', 'high': 'unacc', 'vhigh': 'acc'}}, 'high': {'maint': {'low': 'unacc', 'med': 'acc', 'high': 'unacc', 'vhigh': 'unacc'}}, 'vhigh': {'maint': {'low': 'unacc', 'med': 'acc', 'high': 'unacc', 'vhigh': 'unacc'}}}}, 'more': {'buying': {'low': {'maint': {'med': {'doors': {'2': 'good', '3': 'good', '4': 'acc'}}, 'vhigh': {'doors': {'2': 'acc', '3': 'acc', '4': 'unacc'}}}}, 'med': {'doors': {'2': 'acc', '3': 'acc', '4': {'maint': {'med': 'acc', 'vhigh': 'unacc'}}}}, 'high': {'maint': {'med': {'doors': {'2': 'acc', '3': 'acc', '4': 'unacc'}}, 'vhigh': 'unacc'}}, 'vhigh': {'maint': {'med': {'doors': {'2': 'acc', '3': 'acc', '4': 'unacc'}}, 'vhigh': 'unacc'}}}}}}, 'high': {'persons': {'4': {'buying': {'low': {'maint': {'med': {'doors': {'2': 'vgood', '3': 'good', '4': 'good'}}, 'vhigh': 'acc'}}, 'med': {'doors': {'2': {'maint': {'med': 'vgood', 'vhigh': 'acc'}}, '3': 'acc', '4': 'acc'}}, 'high': {'maint': {'med': 'acc', 'vhigh': 'unacc'}}, 'vhigh': {'maint': {'med': 'acc', 'vhigh': 'unacc'}}}}, '2': 'unacc', 'more': {'buying': {'low': {'doors': {'4': 'vgood', '3': 'vgood', '5more': {'maint': {'low': 'good', 'high': 'acc'}}}}, 'med': {'maint': {'low': {'doors': {'4': 'vgood', '3': 'vgood', '5more': 'good'}}, 'high': 'acc'}}, 'high': 'acc', 'vhigh': {'maint': {'low': 'acc', 'high': 'unacc'}}}}}}}}

沿着决策树的不同分支，可以通过车辆自身的一些属性来判断该车辆状况的好坏与否。

测试数据：

"""
Parameters:
    inputTree - 已经生成的决策树
    featLabels - 存储选择的最优特征标签
    filename - 文件路径
Returns:
    无
"""
def toPredict(inputTree, featLabels, filename):
    fr = open(filename)
    testData = [inst.strip().split('\t') for inst in fr.readlines()]
    fr.close()
    dataNum = len(testData)
    print("总共数据：%d 条" %dataNum)
    currentNum = 0.0
    for i in range(dataNum):
        result = classify(inputTree, featLabels, testData[0][:-1])
        print("预测类型：%s \t 标准类型：%s" %(testData[i][-1], result))
        if(testData[i][-1] == result):
            currentNum += 1
    print("总共数据：%d 条" % dataNum)
    print("准确率：%f" %(currentNum/dataNum))

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

五、改进算法

注：以下用到的数据均与上面应用数据一致，代码只是部分修改

1. C4.5算法

C4.5算法是用于生成决策树的一种经典算法，是ID3算法的一种延伸和优化。C4.5算法对ID3算法进行了改进 ，改进点主要有：

• 用信息增益率来选择划分特征，克服了用信息增益选择的不足，但信息增益率对可取值数目较少的属性有所偏好；
• 能够处理离散型和连续型的属性类型，即将连续型的属性进行离散化处理；
• 能够处理具有缺失属性值的训练数据；
• 在构造树的过程中进行剪枝；

信息增益率
信息增益准则对可取值数目较多的属性有所偏好，为减少这种偏好可能带来的不利影响，C4.5算法采用信息增益率来选择最优划分属性。增益率公式：
$$Gain\_ratio(D,a)=\frac{Gain(D,a)}{IV(a)}$$
其中
$$IV(a)=-\sum _{v=1}^V\frac{|D^v|}{|D|}{\log }_2\frac{|D^v|}{|D|}$$
称为属性a的“固有值”，属性a的可能性取值数目越多（即V越大），则$IV(a)$的值通常就越大

主要代码：主要根据公式修改chooseBestFeatureToSplit函数来以信息增益率来找寻最大的(最优)特征的索引值

def chooseBestFeatureToSplit(dataSet):
    baseEntropy = calcShannonEnt(dataSet)
    baseGainRatio = 0.0
    bestFeature = -1
    numFeatures = len(dataSet[0]) - 1
    for i in range(numFeatures):
        # 获取第i个特征的特征值
        featVals = [example[i] for example in dataSet]
        uniqueVals = set(featVals)
        splitInfo = 0.0
        # 计算每种划分方式的条件信息熵newEntropy
        newEntropy = 0.0
        for value in uniqueVals:
            subDataSet = splitDataSet(dataSet, i, value)
            prob = len(subDataSet)/float(len(dataSet))
            splitInfo -= prob * log(prob, 2)  # 计算分裂信息
            newEntropy += prob * calcShannonEnt(subDataSet)  # 计算条件信息熵
        # 若该特征的特征值都相同，说明信息增益和分裂信息都为0，则跳过该特征
        if splitInfo == 0.0:
            continue
        # 计算信息增益率 = 信息增益 / 该划分方式的分裂信息
        gainRatio = float(baseEntropy - newEntropy) / splitInfo
        if gainRatio > baseGainRatio:
            bestFeature = i
            baseGainRatio = gainRatio
    return bestFeature

测试结果：

信息增益率准则对可取值数目较少的属性有所偏好。所以，C4.5算法不是直接选择信息增益率最大的候选划分属性，而是先从候选划分属性中找出信息增益高于平均水平的属性，再从中选择信息增益率最高的。

2. CART

CART算法构造决策树用于分类是：采用基尼指数的大小度量特征各个划分点的优劣。

优点：
CART算法对目标变量和预测变量在概率分布上没有要求，这样就避免了因目标变量与预测变量概率分布的不同而造成的误差
CART算法生成的决策树是结构简洁的二叉树
缺点：
CART算法是一种大容量样本集挖掘算法，当样本集比较小时不够稳定

基尼指数的定义是：分类问题中，假设D有K个类，样本点属于第k类的概率为$p_k$, 则概率
分布的基尼值定义为：
$$Gini(D)=\sum _{k=1}^K{p}_k(1-p_k)=1-\sum _{k=1}^K{p}_k^2$$
$Gini(D)$越小，数据集D的纯度越高；

给定数据集D，属性a的基尼指数定义为：
$$Gin{i}_{i}ndex(D,a)=\sum _{v=1}^V\frac{|D^v|}{|D|}Gini(D^v)$$
在候选属性集合A中，选择那个使得划分后基尼指数最小的属性作为最优划分属性。

主要代码：

def calcProbabilityEnt(dataSet):
    numEntries = len(dataSet)
    feaCounts = 0
    feal = dataSet[0][len(dataSet[0])-1]
    for feaVec in dataSet:
        if feaVec[-1] == feal:
            feaCounts += 1
    probabilityEnt = float(feaCounts)/numEntries
    return probabilityEnt

def chooseBestFeatureToSplit(dataset):
    # 计算划分属性的数量
    numFeatures = len(dataset[0])-1
    if numFeatures==1:
        return 0
    # 最佳基尼指数
    bestGini = 1
    bestFeature = -1
    # 从0开始赋值
    for i in range(numFeatures):
        # 获取数据集的第i(列)个特征
        featList = [example[i] for example in dataset]
        # 定义特征的值的基尼值
        feaGini = 0
        # 创建一个无序不重复元素集(删除重复元素)
        uniqueVals = set(featList)
        for value in uniqueVals:
            # 按照属性i和属性i位置上的值进行数据划分
            subDataSet = splitDataSet(dataset, i, value)
            prob = len(subDataSet)/float(len(dataset))
            probilityEnt = calcProbabilityEnt(subDataSet)
            feaGini += prob * (2 * probilityEnt * (1-probilityEnt))
        if feaGini < bestGini:
            bestGini = feaGini
            bestFeature = i
    return bestFeature

测试结果：


由结果可以看到，CART算法由于ID3算法，但不如C4.5算法，可能是由于我选择的数据集较少