机器学习2决策树

决策树的思想比较简单，不复杂，决策树，就是通过一个属性将数据进行划分，而这个属性的选择也就是决策树的关键，用什么样的属性分开的值尽可能属于同一个类别。

属性选择的方法很多，书中主要介绍了：通过信息增益、增益比率、以及基尼指数.

具体伪代码书中给出：

本文采用了ID3算法划分数据集。该算法采用了一个叫信息增益的概念，关于信息论的部分，曾经写过一文http://www.cnblogs.com/fengbing/archive/2011/12/15/2288801.html中有部分阐述。

我的理解就是，信息是什么，怎么度量，也就是信息经过压缩之后还能代表本身的最小值，这个可以根据霍夫曼编码看出。

具体说明：

考虑用 0 和 1 组成的二进制数码为含有 n 个符号的某条信息编码，假设符号 Fn 在整条信息中重复出现的概率为 Pn，则该符号的熵也即表示该符号所需的位数位为：
En = - log2( Pn )
整条信息的熵也即表示整条信息所需的位数为：E = ∑En

举个例子，对下面这条只出现了 a b c 三个字符的字符串：
aabbaccbaa
字符串长度为 10，字符 a b c 分别出现了 5 3 2 次，则 a b c 在信息中出现的概率分别为 0.5 0.3 0.2，他们的熵分别为：
Ea = -log2(0.5) = 1
Eb = -log2(0.3) = 1.737
Ec = -log2(0.2) = 2.322
整条信息的熵也即表达整个字符串需要的位数为：
E = Ea * 5 + Eb * 3 + Ec * 2 = 14.855 位
回想一下如果用计算机中常用的 ASCII 编码，表示上面的字符串我们需要整整 80 位，这样我们就用较少的位数表示较频繁出现的符号。

而这个值不能再小了，再小就不能表示这个信息量了。而这个最小的信息量也就是这个信息的度量。

下面就来上代码

# -*- coding: utf-8 -*
from math import log

def calcShannonEnt(dataSet):
    numEntries = len(dataSet)#得到数据集总数
    labelCounts = {}
    for featVec in dataSet:
        currentLabel = featVec[-1]#-1表示最后一列
        #这边处理可能不好理解，初始不在字典中先设为0，再加1，以后再字典中就直接加1
        #我们可能处理是if no in dictionary，设为1，else +1
        if currentLabel not in labelCounts.keys():
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] +=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

 

运行

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

这边求得的熵并不高，也就是说信息量不大，下面根据作者一样，我们增加分类，我们会发现熵变大，即信息量变大。

>>> myDat[0][-1]='maybe'
>>> myDat
[[1, 1, 'maybe'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
>>> tree.calcShannonEnt(myDat)
1.3709505944546687

通过信息增益的概念来构造决策树的方法有ID3，C4.5，C5.0还有通过基尼指数的CART算法。

书中没有介绍通过基尼指数的实现，目前也不实现，等书看完了后续对没有实现的算法再进行实现。

我们知道了信息熵，下面我们就开始划分数据集。

#axis第几个特征，value特征的值，以这个特征分类
def splitDataSet(dataSet,axis,value):
    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            reduceFeatVec = featVec[:axis]#featVec[:axis],axis=0时返回[]
            reduceFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reduceFeatVec)
    return retDataSet

得到的结果

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

我们这边是以第一个特征值进行分类，下面我们要对所有的特征值进行分类，计算每个分类下的信息熵。

这样信息增益就是分裂前后的两个信息量的差

def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1   #最后一个是类别，特征数是每一行数目减去1
    baseEntropy = calcShannonEnt(dataSet)#计算数据集原始信息熵
    bestInfoGain = 0.0; bestFeature = -1
    for i in range(numFeatures):
        featList = [example[i] for example in dataSet]#example[i]代表第i列的特征值，在for循环获取这一列的所有值
        uniqueVals = set(featList) #set是一个无序不重复集跟其他语言一样，这样得到i这一列不同的特征值
        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

这个例子的第一步就是（3/5）*（-(2/3)*log(2/3)-(1/3)*log(1/3))+(2/5)*(-1*log1)

没有分类的时候直接计算-(2/5)*log(2/5)-(3/5)*log(3/5)

原始信息熵减去分裂之后的信息熵，就是信息增益，信息增益大的就选择这个特征进行分类。

我们打印出信息增益看出

num 0 infoGain 0.419973
num 1 infoGain 0.170951

所有以0也就是第一列的特征进行划分。

目前我们给出了第一次特征的划分，下面还要进行第二次的划分，甚至更多，决策树是一种树的形式，我们考虑采用的方式是递归处理。

递归处理要有一个结束条件。

1、遍历了所有的属性，或者每个分支下所有的实例都具有相同的分类。

2、可能会遇到最后没有属性可以划分这个样本子集的时候，我们采用投票原则，多的就为这个样本子集的类别标识，强制为叶子节点

具体代码：

def majorityCnt(classList):
    classCount={}
    for vote in classList:
        if vote not in classCount.keys():
            classCount[vote] = 0
        classCount[vote] += 1
    #这个sorted跟sort的区别前面提到，这个是重新建了一个数组，sort是在原有的基础上
    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]#得到分类这边是yes no
    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

结果：

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

这边是采用字典的形式表示这个树形结构的，这个json字符串也有点像，不过决策树的优势在于它的图形表示，下面就通过之前用过的Matplotlib画图。

最终得到如下图：

具体画图这边就不叙述了，没有细看。主要通过得到叶子数，得到数的深度。

下面还是一样，给出一个真实的例子，然后对模型进行正确性评估。

也就是知道这个决策树，我们给出一个特征属性，来判断这个的类别是什么

def classify(inputTree,featLabels,testVec):
    firstStr = inputTree.keys()[0]
    secondDict = inputTree[firstStr]
    featIndex = featLabels.index(firstStr)
    key = testVec[featIndex]
    valueOfFeat = secondDict[key]
    if isinstance(valueOfFeat, dict): #判断valueOfFeat是不是字典类型，也就是判断是不是还有子集，有在进行递归判断
        classLabel = classify(valueOfFeat, featLabels, testVec)
    else: classLabel = valueOfFeat
    return classLabel

测试：

>>> import tree
>>> import treePlotter
>>> myTree = treePlotter.retrieveTree(0)
>>> myData,labels = tree.createDataSet()
>>> tree.classify(myTree,labels,[1,0])
'no'

测试模型

另外我们创建好决策树之后就将其保存，这样要使用直接调用就好。

数据持久保存使用pickle模块，进行基本的数据序列和反序列化

#pickle模块实现了基本的数据序列和反序列化
def storeTree(inputTree,filename):
    import pickle
    fw = open(filename,'w')
    pickle.dump(inputTree,fw)
    fw.close()

def grabTree(filename):
    import pickle
    fr = open(filename)
    return pickle.load(fr)

使用

>>> myTree = {'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}
>>> myTree
{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}
>>> tree.storeTree(myTree,'classifierStorage.txt')
>>> tree.grabTree('classifierStorage.txt')
{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}
>>>

最后作者给出了隐形眼镜的测试，我这边也把其代码列出

>>> fr = open('lenses.txt')
>>> lenses = [inst.strip().split('\t') for inst in fr.readlines()]
>>> lensesLabels = ['age','prescript','astigmatic','tearRate']
>>> lensesTree = tree.createTree(lenses,lensesLabels)
>>> lensesTree
{'tearRate': {'reduced': 'no lenses', 'normal': {'astigmatic': {'yes': {'prescript': {'hyper': {'age': {'pre': 'no lenses', 'presbyopic': 'no lenses', 'young': 'hard'}}, 'myope': 'hard'}}, 'no': {'age': {'pre': 'soft', 'presbyopic': {'prescript': {'hyper': 'soft', 'myope': 'no lenses'}}, 'young': 'soft'}}}}}}
>>> import treePlotter
>>> treePlotter.createPlot(lensesTree)

最后给出图如下：

这样基本的ID3算法就结束了，不过决策树远不止这么多。

决策树是一个很好的思想，因为其直观，效果也好，普通用户使用甚至可以得出几十年专家的水准。但是它也有很多问题，就关这个特征属性的选择问题，就有很多研究。

我们现在使用了信息增益，之后有C4.5算法采用信息增益比，在这本书的第九章有CART算法采用基尼指数，另外还有距离度量、基于统计的等等。

另外由于在真实世界中没有没有完善的数据，这数据有噪声，而我们刚刚的算法没有考虑这些问题。

还有属性之间是有关联的，这样划分出来的结果也会有问题，最终导致划分过细，而且最后的结果不易于理解。

于是有一些方案来解决这些问题。这个在这本书的第九章会给出一定的解决方案，这个ID3算法就到这边。