本篇内容为《机器学习实战》第 3 章决策树部分程序清单。所用代码为 python3。

决策树

优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关特征数据。

缺点：可能会产生过度匹配问题。

适用数据类型：数值型和标称型

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

创建分支的伪代码函数createBranch()如下所示：

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

下面我们采用量化的方法来判定如何划分数据，我们以下图所示的数据集为例：

程序清单 3-1 计算给定数据集的香农熵

'''
Created on Sep 16, 2018

@author: yufei
'''

# coding=utf-8

"""
计算给定数据的香农熵
"""
from math import log
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

    # 以 2 为底求对数
    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

在 python 提示符下，执行代码并得到结果：

>>> import trees
>>> myDat, labels = trees.createDataSet()
>>> myDat
[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
>>> trees.calcShannonEnt(myDat)
0.9709505944546686

程序清单 3-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()，在 python 提示符下，执行代码并得到结果：

>>> myDat, labels = trees.createDataSet()
>>> myDat
[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
>>> trees.splitDataSet(myDat, 0, 0)
[[1, 'no'], [1, 'no']]

程序清单 3-3 选择最好的数据集划分方式

"""
函数功能：选择特征，划分数据集，计算得出最好的划分数据集的特征

数据集需满足：
1、数据是一种由列表元素组成的列表，且所有的列表元素都要具有相同的数据长度
2、数据的最后一列或每个实例的最后一个元素是当前实例的类别标签
"""
def chooseBestFeatureToSplit(dataSet):
    # 判定当前数据集包含多少特征属性
    numFeatures = len(dataSet[0]) - 1
    # 计算整个数据集的原始香农熵，即最初的无序度量值
    baseEntropy = calcShannonEnt(dataSet)

    bestInfoGain = 0.0
    bestFeatures = -1

    # 遍历数据集中的所有特征
    for i in range(numFeatures):
        # 创建唯一的分类标签列表，将数据集中所有第 i 个特征值写入这个 list 中
        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
            bestFeatures = i
    return bestFeatures

在 python 提示符下，执行代码并得到结果：

>>> myDat, labels = trees.createDataSet()
>>> trees.chooseBestFeatureToSplit(myDat)
0
>>> myDat
[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]

代码运行结果告诉我们，第 0 个特征是最好的用于划分数据集的特征。也就是说第一个特征是 1 的放在一个组，第一个特征是 0 的放在另一个组。因为这个数据集比较简单，我们直接观察可以看到第一种划分更好地处理了相关数据。

下面我们会介绍如何将上述实现的函数功能放在一起，构建决策树。

程序清单 3-4 创建树的函数代码

"""
使用分类名称的列表，创建数据字典
返回出现次数最多的分类名称
"""
import operator
def majorityCnt(classList):
    classCount = {}
    for vote in classList:
        if vote in classList:
            classCount[vote] = 0
        classCount[vote] += 1
    sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]

# 参数：数据集，标签列表
def createTree(dataSet, labels):
    # 创建名为 classList 的列表变量，包含了数据集的所有类标签
    classList = [example[-1] for example in dataSet]
    # 递归函数的第一个停止条件：所有类标签完全相同，则直接返回该类标签
    if classList.count(classList[0]) == len(classList):
        return classList[0]
    # 递归函数的第二个停止条件：使用完所有特征，仍然不能将数据集划分成仅包含唯一类别的分组
    # 由于无法简单地返回唯一的类标签，这里遍历完所有特征时使用 majorityCnt 函数返回出现次数最多的类别
    if len(dataSet[0]) == 1:
        return majorityCnt(classList)

    # 当前数据集选取的最好特征存储在变量 bestFeat 中，得到列表包含的所有属性值
    bestFeat = chooseBestFeatureToSplit(dataSet)
    bestFeatLabel = labels[bestFeat]
    # 字典变量 myTree 存储了树的所有信息
    myTree = {bestFeatLabel:{}}
    del(labels[bestFeat])

    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)
    # 遍历当前选择特征包含的所有属性值
    for value in uniqueVals:
        # 复制类标签，将其存储在新列表变量 subLabels 中
        # 在python语言中，函数参数是列表类型时，参数是按照引用方式传递的
        # 为了保证每次调用函数 createTree 时不改变原始列表的内容
        subLabels = labels[:]
        # 在每个数据集划分上递归的调用函数 createTree（）
        # 得到的返回值被插入字典变量 myTree 中
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)
    return myTree

在 python 提示符下，执行代码并得到结果：

>>> myDat, labels = trees.createDataSet()
>>> myTree = trees.createTree(myDat, labels)
>>> myTree
{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}

最后得到的变量myTree包含了很多代表树结构信息的嵌套字典。这棵树包含了 3 个叶子节点以及 2 个判断节点，形状如下图所示：

不足之处，欢迎指正。