【机器学习】决策树

决策树是一种分类算法，其中的每个内部节点代表对某一特征的一次判断，树中的每一条边代表对该特征的一种测试结果，每一个非叶子节点是一个判断条件，每一个叶子节点是结论。
决策树的决策过程：
从根节点开始，选取最优特征作为根节点，用该节点的每一种判断结果做为一个分支，然后再在余下的特征找到最优的，作为子节点，依次，直到所有特征都分布在这颗树上。
那么就涉及到一个问题，如何在每一个用特征做节点的时候找到的特征是最合适的？
为了把无序的数据变得有序，这儿采用信息增益的方式来帮助我们找到当前最优特征，我们把信息发生的变化称为信息增益，信息增益的度量是由熵来度量，根据不同特征划分来计算熵，将划分钱和划分后的熵的差值就称为信息增益。
所以需要知道熵是什么？公式如何表达？如何计算数据的熵？
熵是信息的期望值
信息的定义的公式是

[l(x_i)=- log pleft(x_{i} ight) ]

为了计算熵，需要计算所有类别所有可能值包含的信息期望值，信息熵公式如下

[H(X)=-sum_{i=1}^{n} pleft(x_{i} ight) log pleft(x_{i} ight) ]

那么根据公式计算当前数据的熵的思路：

具体的例子
对于西瓜书表4.1中，需要计算{色泽、根蒂、敲声、纹理、脐部、触感}每一个特征的信息增益，举例色泽来说，有三种分支，分别是{青绿、乌黑、浅白}，对该特征对D进行划分，可以得到3个子集，分别为：(D^1)（色泽=青绿）、(D^2)（色泽=乌黑）、(D^3)（色泽=浅白）,子集(D^1)共包含6个样本{1，4，6，10，13，17}，其中正例占(p_1) = 3/6，负例占(p_2) = 3/6；子集(D^2)共包含6个样本{1，4，6，10，13，17}，其中正例占(p_1) = 4/6，负例占(p_2) = 2/6；子集(D^3)共包含5样本{5，11，12，14，16}，其中正例占(p_1) = 1/5，负例占(p_2) = 4/5，
因此，可以计算出用“色泽”划分之后所获得的3个分支结点的信息熵为：

[egin{aligned} operatorname{Ent}left(D^{1} ight) &=-left(frac{3}{6} log _{2} frac{3}{6}+frac{3}{6} log _{2} frac{3}{6} ight)=1.000 \ operatorname{Ent}left(D^{2} ight) &=-left(frac{4}{6} log _{2} frac{4}{6}+frac{2}{6} log _{2} frac{2}{6} ight)=0.918 \ operatorname{Ent}left(D^{3} ight) &=-left(frac{1}{5} log _{2} frac{1}{5}+frac{4}{5} log _{2} frac{4}{5} ight)=0.722 end{aligned} ]

根据信息增益的公式初始熵减去当前特征的熵的差值就是信息增益，求出来每一种特征的信息增益，对于信息增益最大的特征就是当前最合适的特征。

计算数据初始熵代码如下：

def calcShannonEnt(dataSet):
    """
    :param dataSet: 特征列表，dataSet
    :return:
    """
    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: # 遍历存储所有的特征列表，也就是yes:3 no :2
        prob = float(labelCounts[key]) / numEntries # 计算每个特征出现的概率
        shannonEnt -= prob * log(prob, 2)  # 计算总的信息熵
    return shannonEnt

该函数用于计算信息增益，并且选择当前最好的数据划分方式，也就是找到当前信息增益最大的特征作为当前节点。

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

def splitDataSet(dataSet, axis, value):
    """
    :param dataSet: 数据集列表 dataSet
    :param axis: 划分的特征 0-->不浮出水面可以生存和1-->是否有脚蹼
    :param value: 需要返回特征的值
    :return:
    这个函数很有意思的，尤其是if里面三行，特征抽取的代码。
    随着axis的增大，特征featVec也在移动，reducedFeatVec也随着移动。这两个分别占领的一行数据的两部分
    """
    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            reducedFeatVec = featVec[:axis]
            reducedFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet

现在可以知道每一次选取哪一个特征作为当前节点，就需要构建整个决策树。
递归的停止条件：
第一个：程序遍历完所有划分数据集的特征
第二个：每一个分支下所有的实例都有相同的分类，
第一种：所有特征的有了节点位置，肯定是遍历结束了，第二种，把样本进行某个特征进行划分后，已经把数据都划分正确了，那么其他的特征就没用用处了。比如划分是否是鱼类，只要不浮出水面不能可以生存，那一定不是鱼类，就不需要再看该种生物是否有脚踝了。
构建树的代码如下：

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)

    # 每个数据集上递归调用，将返回的值插入myTree
    for value in uniqueVals:
        subLabels = labels[:]     # 复制类别标签
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)
    return myTree

那么用id3构造决策树的整体代码如下：

# _*_ encoding=utf8 _*_

from math import log
import operator

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

def calcShannonEnt(dataSet):
    """
    :param dataSet: 特征列表，dataSet
    :return:
    """
    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: # 遍历存储所有的特征列表，也就是yes:3 no :2
        prob = float(labelCounts[key]) / numEntries # 计算每个特征出现的概率
        shannonEnt -= prob * log(prob, 2)  # 计算总的信息熵
    return shannonEnt

def splitDataSet(dataSet, axis, value):
    """
    :param dataSet: 数据集列表 dataSet
    :param axis: 划分的特征 0-->不浮出水面可以生存和1-->是否有脚蹼
    :param value: 需要返回特征的值
    :return:
    这个函数很有意思的，尤其是if里面三行，特征抽取的代码。
    随着axis的增大，特征featVec也在移动，reducedFeatVec也随着移动。这两个分别占领的一行数据的两部分
    """
    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            reducedFeatVec = featVec[:axis]
            reducedFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet

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

def majorityCnt(classList):
    """
    :param classList: 分类名称的列表
    :return: 返回出现次数最多的分类名称
    """
    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]


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)

    # 每个数据集上递归调用，将返回的值插入myTree
    for value in uniqueVals:
        subLabels = labels[:]     # 复制类别标签
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)
    return myTree

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