第三章 決策樹 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算法可以用於劃標稱型數據集。