Python編程實驗一 決策樹實現結果預測

題目：給定如下訓練集和測試集，參考《機器學習》（Tom Mitchell）第三章和《機器學習》（周志華）第四章，先閱讀ID3、C4.5和CART算法並且仔細閱讀附件給出的ID3、C4.5算法python程序，再實現基於基尼指數（Gini index）選擇最優划分屬性（特征）構造的CART決策樹的 python程序。最終提交一份實驗報告, 提交的實驗報告給出python實現的完整程序和實驗結果。

 

訓練集:

    outlook     temperature    humidity     windy

    ---------------------------------------------------------

    sunny       hot            high         false         N

    sunny       hot            high         true          N

    overcast    hot            high         false         Y

    rain        mild           high         false         Y

    rain        cool           normal       false         Y

    rain        cool           normal       true          N

    overcast    cool           normal       true          Y

 

測試集

    outlook    temperature     humidity     windy

    ---------------------------------------------------------

    sunny       mild           high         false          

    sunny       cool           normal       false         

    rain        mild           normal       false        

    sunny       mild           normal       true          

    overcast    mild           high         true          

    overcast    hot            normal       false         

    true        rain           mild         high        

 

Python程序

1、CART.py

# -*- coding: utf-8 -*-

## 參考《機器學習》（Tom M. Mitchell） 第三章 決策樹學習

## 《機器學習》（周志華）， 第四章 決策樹

from math import log
import operator
import treePlotter

def calcGiniIndex(dataSet):
    """
    輸入：數據集
    輸出：數據集的基尼指數
    描述：計算給定數據集的基尼指數
    """
    numEntries = len(dataSet)                     # 返回數據集的行數
    labelCounts = {}                              # 保存每個標簽（Label）出現次數的字典
    for featVec in dataSet:                       # 對每組特征向量進行統計
        currentLabel = featVec[-1]                  # 提取標簽信息
        if currentLabel not in labelCounts.keys():    # 如果標簽沒有放入統計次數的字典，添加進去
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1            # Label計數
    giniIndexEnt = 0.0                            # 基尼指數
    for key in labelCounts:                          # 計算基尼指數
        prob = float(labelCounts[key])/numEntries       # 選擇該標簽（Label）的概率
        giniIndexEnt += prob * (1.0 - prob)       # 利用公式計算
    return giniIndexEnt                              # 返回基尼指數

def splitDataSet(dataSet, axis, value):       # 待划分數據集合，特征下標，特征值
    """
    輸入：數據集，選擇維度，選擇值
    輸出：划分數據集
    描述：按照給定特征划分數據集；去除選擇維度中等於選擇值的項
    """
    retDataSet = []                          # 保存划分的數據子集
    for featVec in dataSet:                  # 遍歷數據集中的每個樣本
        if featVec[axis] == value:           #如果特征值符合要求，則添加到子集中
            reduceFeatVec = featVec[:axis]   # 保存第0到第axis-1個特征
            reduceFeatVec.extend(featVec[axis+1:])     # 保存第axis+1到最后一個特征
            retDataSet.append(reduceFeatVec)           # 添加符合要求的樣本到划分子集中
    return retDataSet                                  # 返回划分好的（特征axis的值=value）的子集

def chooseBestFeatureToSplit(dataSet):
    """
    輸入：數據集
    輸出：最好的划分維度
    描述：選擇最好的數據集划分維度
    """
    numFeatures = len(dataSet[0]) - 1                 # 特征數量
    bestInfoGini = calcGiniIndex(dataSet)             # 計算數據集的基尼指數
    bestFeature = -1                                   # 最優特征索引值
    for i in range(numFeatures):                        # 遍歷所有特征
        featList = [example[i] for example in dataSet]      # 獲取dataSet的第i個所有特征-第i列全部特征
        uniqueVals = set(featList)                    # 創建set集合{}元素不可重復
        newGini = 0.0
        for value in uniqueVals:                            # 計算新的基尼指數
            subDataSet = splitDataSet(dataSet, i, value)    # subDataSet划分后的子集
            prob = len(subDataSet)/float(len(dataSet))      # 計算子集概率
            newGini += prob * calcGiniIndex(subDataSet)     # 新的基尼指數
        if (newGini < bestInfoGini):
            bestInfoGini = newGini
            bestFeature = i
    return bestFeature                                         # 返回基尼指數最小的特征索引值

def majorityCnt(classList):
    """
    輸入：分類類別列表
    輸出：子節點的分類
    描述：數據集已經處理了所有屬性，但是類標簽依然不是唯一的，
          采用多數判決的方法決定該子節點的分類
    """
    classCount = {}
    for vote in classList:                # 統計classList中每個元素出現的次數
        if vote not in classCount.keys():
            classCount[vote] = 0
        classCount[vote] += 1
    sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reversed=True)  # 根據字典的值降序排序
    return sortedClassCount[0][0]            # 返回classList中出現次數最多的元素

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 = list(inputTree.keys())[0]
    secondDict = inputTree[firstStr]
    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

def classifyAll(inputTree, featLabels, testDataSet):
    """
    輸入：決策樹，分類標簽，測試數據集
    輸出：決策結果
    描述：跑決策樹
    """
    classLabelAll = []
    for testVec in testDataSet:
        classLabelAll.append(classify(inputTree, featLabels, testVec))
    return classLabelAll

def storeTree(inputTree, filename):
    """
    輸入：決策樹，保存文件路徑
    輸出：
    描述：保存決策樹到文件
    """
    import pickle
    fw = open(filename, 'wb')
    pickle.dump(inputTree, fw)
    fw.close()

def grabTree(filename):
    """
    輸入：文件路徑名
    輸出：決策樹
    描述：從文件讀取決策樹
    """
    import pickle
    fr = open(filename, 'rb')
    return pickle.load(fr)

def createDataSet():
    """
    outlook->  0: sunny | 1: overcast | 2: rain
    temperature-> 0: hot | 1: mild | 2: cool
    humidity-> 0: high | 1: normal
    windy-> 0: false | 1: true
    """
    dataSet = [[0, 0, 0, 0, 'N'],
               [0, 0, 0, 1, 'N'],
               [1, 0, 0, 0, 'Y'],
               [2, 1, 0, 0, 'Y'],
               [2, 2, 1, 0, 'Y'],
               [2, 2, 1, 1, 'N'],
               [1, 2, 1, 1, 'Y']]
    labels = ['outlook', 'temperature', 'humidity', 'windy']
    return dataSet, labels

def createTestSet():
    """
    outlook->  0: sunny | 1: overcast | 2: rain
    temperature-> 0: hot | 1: mild | 2: cool
    humidity-> 0: high | 1: normal
    windy-> 0: false | 1: true
    """
    testSet = [[0, 1, 0, 0],
               [0, 2, 1, 0],
               [2, 1, 1, 0],
               [0, 1, 1, 1],
               [1, 1, 0, 1],
               [1, 0, 1, 0],
               [2, 1, 0, 1]]
    return testSet

def main():
    dataSet, labels = createDataSet()
    labels_tmp = labels[:] # 拷貝，createTree會改變labels
    desicionTree = createTree(dataSet, labels_tmp)
    #storeTree(desicionTree, 'classifierStorage.txt')
    #desicionTree = grabTree('classifierStorage.txt')
    print('desicionTree:\n', desicionTree)
    treePlotter.createPlot(desicionTree)
    testSet = createTestSet()
    print('classifyResult:\n', classifyAll(desicionTree, labels, testSet))

if __name__ == '__main__':
    main()

2、treePlotter.py
import matplotlib.pyplot as plt

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 getNumLeafs(myTree):
    """
    輸入：決策樹
    輸出：決策樹的葉子數量
    描述：
    """
    numLeafs = 0
    firstStr = list(myTree.keys())[0]
    secondDict = myTree[firstStr]
    for key in secondDict.keys():
        if type(secondDict[key]).__name__ == 'dict':
            numLeafs += getNumLeafs(secondDict[key])
        else:
            numLeafs += 1
    return numLeafs

def getTreeDepth(myTree):
    """
    輸入：決策樹
    輸出：樹的深度
    描述：
    """
    maxDepth = 0
    firstStr = list(myTree.keys())[0]
    secondDict = myTree[firstStr]
    for key in secondDict.keys():
        if type(secondDict[key]).__name__ == 'dict':
            thisDepth = getTreeDepth(secondDict[key]) + 1
        else:
            thisDepth = 1
        if thisDepth > maxDepth:
            maxDepth = thisDepth
    return maxDepth

def plotMidText(cntrPt, parentPt, txtString):
    """
    輸入：
    輸出：
    描述：
    """
    xMid = (parentPt[0] - cntrPt[0]) / 2.0 + cntrPt[0]
    yMid = (parentPt[1] - cntrPt[1]) / 2.0 + cntrPt[1]
    createPlot.ax1.text(xMid, yMid, txtString)

def plotTree(myTree, parentPt, nodeTxt):
    """
    輸入：
    輸出：
    描述：
    """
    numLeafs = getNumLeafs(myTree)
    depth = getTreeDepth(myTree)
    firstStr = list(myTree.keys())[0]
    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs)) / 2.0 / plotTree.totalw, plotTree.yOff)
    plotMidText(cntrPt, parentPt, nodeTxt)
    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':
            plotTree(secondDict[key], cntrPt, str(key))
        else:
            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 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()

 

運行結果：

desicionTree:

 {'outlook': {0: 'N', 1: 'Y', 2: {'windy': {0: 'Y', 1: 'N'}}}}

classifyResult:

 ['N', 'N', 'Y', 'N', 'Y', 'Y', 'N']

 

Process finished with exit code 0

 

畫出的決策樹圖形：