python实现决策树算法

python实现决策树算法

摘要：本文首先对决策树算法进行简单介绍，然后利用python一步步构造决策树，并通过matplotlib工具包直观的绘制树形图，最后在数据集对算法进行测试。

关键词：机器学习，决策树，python，matplotlib

简介
决策树算法是一种逼近离散函数值的方法。它是一种典型的分类方法，首先对数据进行处理，利用归纳算法生成可读的规则和决策树，然后使用决策对新数据进行分析。本质上决策树是通过一系列规则对数据进行分类的过程。[决策树算法百度百科]
决策树的形式如下图所示：

决策树很多任务都是为了获取数据中所蕴含的知识信息，因此决策树可以使用不熟悉的数据集合，并从中提取出一系列规则，从而对外部未知信息进行预测归类。

决策树的构造
在构造决策树时，需要考虑的第一个问题就是，当前数据集上的特征该如何划分。划分数据集的原则也是将无序的数据变得更加有序。首先了解几个概念：
1、符号xi的信息：

其中p(xi)是选择该分类的概率。
2、熵（entropy）:信息的期望值

3、信息增益（information gain）

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

编程实现决策树算法：
香农熵计算：
input — dataSet 为一个列表

def calcShannonEnt(dataSet):
    """计算香农熵"""
    numEntries = len(dataSet)
    labelCounts={}
    for featVec in dataSet:
        currentLabel = featVec[-1]
        if currentLabel not in labelCounts:
            labelCounts[currentLabel] = 0 #先令对应键值为0
        labelCounts[currentLabel] +=1
    ShannonEnt = 0.0
    for key in labelCounts: # 遍历所有键值
        prob = float(labelCounts[key]) / numEntries
        ShannonEnt -= prob * math.log(prob,2)
    return ShannonEnt

创建数据集：

def createData():
    """创建数据集"""
    dataSet = [[1,1,'yes'],
               [1,1,'yes'],
               [1,0,'no'],
               [0,1,'no'],
               [0,1,'no']]
    # dataSet = [[1,1,2,'yes'],
    #            [1,0,1,'yes'],
    #            [0,0,3,'no'],
    #            [1,1,3,'bad'],
    #            [2,2,3,'no']]
    labels = ['no surfacing','flippers']
    return dataSet,labels

得到熵之后，我们就可以按照获取最大增益的办法划分数据集。

`划分数据集
信息增益表示的是信息的变化，而信息可以用熵来度量，所以我们可以用熵的变化来表示信息增益。而获得最高信息增益的特征就是最好的选择，故此，我们可以对所有特征遍历，得到最高信息增益的特征加以选择。

def splitDataSet(dataSet,axis,value):
    """
    :param dataSet:待划分的数据集
    :param axis:划分数据集的特征，也就是每一列
    :param value:特征返回值（是一列，2,3？，也就特征的索引）
    :return:retDataSet=[]
    """
    retDataSet=[]
    for featVec in dataSet:
        if featVec[axis] == value:
            reducedFeatVec = featVec[0:axis]
            reducedFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet

接下来遍历整个数据集，循环计算香农熵和splitDataSet()函数，找到最好的划分方式：

def chooseBestFeatureToSplit(dataSet):
    """计算信息增益，选择最好的类别进行划分"""
    numFeature=len(dataSet[0]) - 1# 特征个数
    baseEntropy = calcShannonEnt(dataSet) # 基础信息熵
    bestInfoGain = 0
    bestFeature = -1 #选取最好的特征进行划分，也就是按照最大信息增益方法划分数据集
    for i in range(numFeature):#遍历每个特征
        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 createTree(dataSet,labels):
    classList = [example[-1] for example in dataSet] #['yes', 'yes', 'no', 'no', 'no']
    if classList.count(classList[0]) == len(classList):
        return classList[0]
    if len(dataSet[0]) ==1:
        return majorityCnt(classList)
    bestFeat = chooseBestFeatureToSplit(dataSet)#选择最好的第i个特征进行划分
    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

测试结果：

至此，就可以由已知的数据集构造一支决策树了。

下面将介绍如何使用matplotlib工具包可视化生成的决策树。

Matplotlib注释绘制树形图matplotlib学习网站

#首先定义文本框和箭头的格式：
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 plotMidText(cntrPt,parentPr,txtString):
    xMid = (parentPr[0] - cntrPt[0]/2) + cntrPt[0]
    yMid = (parentPr[1] - cntrPt[1]/2) + cntrPt[1]
    createPlot.ax1.text(xMid,yMid,txtString,va='center',ha='center',rotation=30)

#绘制树结构
def plotTree(myTree,parentPt,nodeTxt):
    numLeafs = getNumLeafs(myTree)
    depth = getTreeDepth(myTree)
    #firstStr = myTree.keys()[0]
    firstSides = list(myTree.keys())
    firstStr = firstSides[0]
    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW,plotTree.yOff)
    plotMidText(cntrPt,parentPt,decisionNode)
    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':  # test to see if the nodes are dictonaires, if not they are leaf nodes
            plotTree(secondDict[key], cntrPt, str(key))  # recursion
        else:  # it's a leaf node print the leaf node
            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 getNumLeafs(myTree):
    numLeafs = 0
    #firstStr = myTree.keys()[0]
    firstSides = list(myTree.keys())
    firstStr = firstSides[0]
    secondDict = myTree[firstStr]
    for key in secondDict.keys():
        if type(secondDict[key]).__name__=='dict':#test to see if the nodes are dictonaires, if not they are leaf nodes
            numLeafs += getNumLeafs(secondDict[key])
        else:   numLeafs +=1
    return numLeafs

#获取树的深度
def getTreeDepth(myTree):
    maxDepth = 0
    #firstStr = myTree.keys()[0]
    firstSides = list(myTree.keys())
    firstStr = firstSides[0]
    #print(firstStr)
    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 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()

可视化结果：

小结

1. 了解信息、熵、信息增益等概念，编程实现决策树算法
2. 学习树的递归生成方法，以及如何编程实现获取树的深度、叶子节点的个数
3. matplotlib工具包的应用，数据的可视化。

以上是我在学习过程中的一些理解与总结，难免有错，望大家不吝指教~

参考文献
[1].PeterHarrington, 哈林顿, 李锐. 机器学习实战[M]. 人民邮电出版社, 2013.