第三章 决策树 3.3+3.4 测试算法：使用决策树执行分类

本节我们将使用决策树构建分类器，我们可以将它用于实际数据的分类。

首先在第一节 trees.py 中添加：

# -*- coding:utf-8 -*-
from math import log
import operator
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
    for key in labelCounts:
        prob = float(labelCounts[key])/numEntries
        shannonEnt -= prob *log(prob, 2) # 以 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

def splitDataSet(dataSet, axis, value): # 待划分的数据集，划分数据集的特征，需要返回的特征的值
    retDataSet= [] # 创建新的 list 对象
    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) # set 是一个集合
        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):
    classCount = {} # 创建键值为 classList 中唯一值的数据字典
    for vote in classList:
        if vote not in classCount.keys():classCount[vote] = 0
        classCount[vote] += 1 # 储存了 classList 中每个类标签出现的频率
    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)
    for value in uniqueVals:
        subLabels = labels[:]
        myTree[bestFeatLabel][value] = createTree(splitDataSet\
                                (dataSet,bestFeat,value),subLabels)
    return myTree

def classify(inputTree, featLabels, testVec): # 递归函数
    firstStr = inputTree.keys()[0]
    secondDict = inputTree[firstStr]
    # 使用 index 方法查找当前列表中第一个匹配 firstStr 变量的元素 str
    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 

添加的 classify 也是一个递归函数，具体可以看注释。然后建立一个 run_trees.py 函数。

# -*- coding:utf-8 -*-
# run_trees.py
import trees
import treePlotter
print 'myDat, labels = trees.createDataSet()'
myDat, labels = trees.createDataSet()

print 'labels'
print labels

print 'myTree = treePlotter.retrieveTree(0)'
myTree = treePlotter.retrieveTree(0)

print 'myTree'
print myTree

print 'trees.classify(myTree, labels, [1,0])'
print trees.classify(myTree, labels, [1,0])

print 'trees.classify(myTree, labels, [1,1])'
print trees.classify(myTree, labels, [1,1])

运行结果是：

现在已经创建了决策树的分类器。

==========================================================================

这一节介绍如何在硬盘上存储决策树分类器。

构造决策树是很耗时的任务。为了节省计算时间，最好能在每次执行分类的时候调用已经构造好的决策树，这要使用 Python 模块 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)

在运行里面加入：

print "trees.storeTree(myTree, 'classifierStorage.txt')"
trees.storeTree(myTree, 'classifierStorage.txt')

print "trees.grabTree('classifierStorage.txt')"
print trees.grabTree('classifierStorage.txt')

结果为：

 通过以上代码，把分类器存在了硬盘上，就是那个 txt 文件，而不用每次对数据分类的时候重新学习一遍。

===================================================================================

这节我们将通过一个例子讲解决策树如何预测患者需要佩戴的隐形眼镜类型。

首先新建一个 run_trees.py 函数：

# -*- coding:utf-8 -*-
# ex3.4
# run_trees.py
import trees
import treePlotter

fr = open('lenses.txt')
lenses = [inst.strip().split('\t') for inst in fr.readlines()] # TAB 分割
# s.strip(rm)        删除s字符串中开头、结尾处，位于 rm删除序列的字符
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']
lensesTree = trees.createTree(lenses, lensesLabels)
print lensesTree
treePlotter.createPlot(lensesTree)

运行结果如下：

最后一行命令调用了绘图函数。问题在于字看不清。

从图上可以看出，医生最多需要4个问题就能决定患者用哪种隐形眼镜。

这个算法称为ID3。

ID3算法可以用于划标称型数据集。