1. 決策樹基本概念

決策樹就是一棵樹，可解釋性強，可用if-then規則解釋，易讓人理解。決策樹的生成是一個遞歸的過程，一顆決策樹包含一個根節點、若干個內部結點和若干個葉結點；葉結點對應於決策結果，其他每個結點則對應於一個屬性測試；每個結點包含的樣本集合根據屬性測試的結果被劃分到子結點中；根結點包含樣本全集，從根結點到每個葉子結點的路徑對應了一個判定測試序列。下圖是以買電腦爲例構造的決策樹。

2. 決策樹類別

ID3決策樹：用信息增益來判斷當前節點應該用什麼特徵來構建決策樹。選擇信息增最高的進行劃分，容易偏向於取值較多的特徵
C4.5決策樹：用的是增益率，容易偏向於取值較少的特徵
CART決策樹：分類和迴歸都能做，基尼係數越小越好

3. 構建決策樹

3.1 選擇最優特徵

再講選擇最優特徵前先補充我們需要用到的信息熵和信息增益，這二個也是進行最優特徵選取的關鍵所在。

3.1.1 信息熵

決策樹學習的關鍵在於如何選擇最優特徵進行劃分，這時候就要用到信息增益，什麼是信息增益呢？在劃分數據集之前之後信息發生的變化成爲信息增益，知道如何計算信息增益，我們就可以計算每個特徵值劃分數據集獲得的信息增益，獲得信息增益最高的特徵就是最好的選擇。先來看看信息熵（information entropy）的定義：假如當前樣本集D中第k類樣本所佔的比例爲，爲類別的總數（對於二元分類來說，k=2）。則樣本集的信息熵爲：

信息熵的相關代碼如下：

# -*- coding: UTF-8 -*-
from math import log
def calcShannonEnt(dataSet):
    numEntires = len(dataSet)                        #返回數據集的行數
    labelCounts = {}                                #保存每個標籤(Label)出現次數的字典
    for featVec in dataSet:                            #對每組特徵向量進行統計
        currentLabel = featVec[-1]                    #提取標籤(Label)信息
        if currentLabel not in labelCounts.keys():    #如果標籤(Label)沒有放入統計次數的字典,添加進去
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1                #Label計數
    shannonEnt = 0.0                                  #信息熵
    for key in labelCounts:                            #計算信息熵
        prob = float(labelCounts[key]) / numEntires    #選擇該標籤(Label)的概率
        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       #返回數據集和分類屬性

if __name__ == '__main__':
    dataSet, features = createDataSet()
    print(dataSet)
    print(calcShannonEnt(dataSet))

代碼運行結果如下圖所示，代碼是先打印訓練數據集，然後打印計算的信息熵H(D)：

3.1.2 信息增益

最優特徵的選取需要看信息增益，信息增益是相對於特徵而言的，信息增益越大，特徵對最終的分類結果影響也就越大，我們就應該選擇對最終分類結果影響最大的那個特徵作爲我們的分類特徵，就是選擇信息增益最大的屬性。假定屬性a有 V個可能的取值 $\left \{ a^{1},a^{2},\cdots ,a^{V}\right \}$ ，如果使用特徵 a來對數據集D進行劃分，則會產生V個分支結點，其中第v（小v）個結點包含了數據集D中所有在特徵a上取值爲 $a^{v}$ 的樣本總數，記爲 $D^{v}$ 。因此可以根據上面信息熵的公式計算出信息熵，再考慮到不同的分支結點所包含的樣本數量不同，給分支節點賦予權重 $\frac{\left |D^{v} \right |}{\left |D \right |}$ ，即樣本數越多的分支節點的影響越大，因此，能夠計算出特徵a對樣本集D進行劃分所獲得的“信息增益”:

下面是計算信息增益，選擇最優特徵的代碼。在找到最優特徵之前我們需要用splitDataSet()函數對數據集進行劃分，循環計算信息熵和splitDataSet()函數，找到最好的特徵劃分方式。

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

"""
函數說明:計算給定數據集的信息熵

"""
def calcShannonEnt(dataSet):
    numEntires = len(dataSet)                        #返回數據集的行數
    labelCounts = {}                                #保存每個標籤(Label)出現次數的字典
    for featVec in dataSet:                            #對每組特徵向量進行統計
        currentLabel = featVec[-1]                    #提取標籤(Label)信息
        if currentLabel not in labelCounts.keys():    #如果標籤(Label)沒有放入統計次數的字典,添加進去
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1                #Label計數
    shannonEnt = 0.0                                  #信息熵
    for key in labelCounts:                            #計算信息熵
        prob = float(labelCounts[key]) / numEntires    #選擇該標籤(Label)的概率
        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       #返回數據集和分類屬性
"""
函數說明:按照給定特徵劃分數據集

Parameters:
    dataSet - 待劃分的數據集
    axis - 劃分數據集的特徵
    value - 需要返回的特徵的值
Returns:
    無
"""
def splitDataSet(dataSet, axis, value):       
    retDataSet = []                                        #創建返回的數據集列表
    for featVec in dataSet:                             #遍歷數據集
        if featVec[axis] == value:
            reducedFeatVec = featVec[:axis]                #去掉axis特徵
            reducedFeatVec.extend(featVec[axis+1:])     #將符合條件的添加到返回的數據集
            retDataSet.append(reducedFeatVec)
    return retDataSet                                      #返回劃分後的數據集

"""
函數說明:選擇最優特徵

Parameters:
    dataSet - 數據集
Returns:
    bestFeature - 信息增益最大的(最優)特徵的索引值
"""
def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1                    #特徵數量
    baseEntropy = calcShannonEnt(dataSet)                 #計算數據集的信息熵
    bestInfoGain = 0.0                                  #信息增益
    bestFeature = -1                                    #最優特徵的索引值
    for i in range(numFeatures):                         #遍歷所有特徵
        #獲取dataSet的第i個所有特徵
        featList = [example[i] for example in dataSet]
        uniqueVals = set(featList)                         #創建set集合{},元素不可重複
        newEntropy = 0.0                                  #經驗條件熵
        for value in uniqueVals:                         #計算信息增益
            subDataSet = splitDataSet(dataSet, i, value)         #subDataSet劃分後的子集
            prob = len(subDataSet) / float(len(dataSet))           #計算子集的概率
            newEntropy += prob * calcShannonEnt(subDataSet)     #根據公式計算經驗條件熵
        infoGain = baseEntropy - newEntropy                     #信息增益
        print("第%d個特徵的增益爲%.3f" % (i, infoGain))            #打印每個特徵的信息增益
        if (infoGain > bestInfoGain):                             #計算信息增益
            bestInfoGain = infoGain                    #更新信息增益，找到最大的信息增益
            bestFeature = i                               #記錄信息增益最大的特徵的索引值
    return bestFeature                                     #返回信息增益最大的特徵的索引值

if __name__ == '__main__':
    dataSet, features = createDataSet()
    print("最優特徵索引值:" + str(chooseBestFeatureToSplit(dataSet)))

3.2 決策樹的生成

決策樹是不斷地遞歸生成的，那何時我們才能結束遞歸呢？遞歸有兩個終止條件：第一個停止條件是所有的類標籤完全相同，則直接返回該類標籤；第二個停止條件是使用完了所有特徵，仍然不能將數據劃分僅包含唯一類別的分組，即特徵不夠用，無法簡單地返回唯一的類標籤，這裏挑選出現數量最多的類別作爲返回值。代碼如下：

# -*- coding: UTF-8 -*-
from math import log
import operator


"""
函數說明:計算給定數據集的信息熵

"""
def calcShannonEnt(dataSet):
    numEntires = len(dataSet)                        #返回數據集的行數
    labelCounts = {}                                #保存每個標籤(Label)出現次數的字典
    for featVec in dataSet:                            #對每組特徵向量進行統計
        currentLabel = featVec[-1]                    #提取標籤(Label)信息
        if currentLabel not in labelCounts.keys():    #如果標籤(Label)沒有放入統計次數的字典,添加進去
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1                #Label計數
    shannonEnt = 0.0                                  #信息熵
    for key in labelCounts:                            #計算信息熵
        prob = float(labelCounts[key]) / numEntires    #選擇該標籤(Label)的概率
        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       #返回數據集和分類屬性
"""
函數說明:按照給定特徵劃分數據集

Parameters:
    dataSet - 待劃分的數據集
    axis - 劃分數據集的特徵
    value - 需要返回的特徵的值
Returns:
    無
"""
def splitDataSet(dataSet, axis, value):       
    retDataSet = []                                        #創建返回的數據集列表
    for featVec in dataSet:                             #遍歷數據集
        if featVec[axis] == value:
            reducedFeatVec = featVec[:axis]                #去掉axis特徵
            reducedFeatVec.extend(featVec[axis+1:])     #將符合條件的添加到返回的數據集
            retDataSet.append(reducedFeatVec)
    return retDataSet                                      #返回劃分後的數據集

"""
函數說明:選擇最優特徵

Parameters:
    dataSet - 數據集
Returns:
    bestFeature - 信息增益最大的(最優)特徵的索引值
"""
def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1                    #特徵數量
    baseEntropy = calcShannonEnt(dataSet)                 #計算數據集的信息熵
    bestInfoGain = 0.0                                  #信息增益
    bestFeature = -1                                    #最優特徵的索引值
    for i in range(numFeatures):                         #遍歷所有特徵
        #獲取dataSet的第i個所有特徵
        featList = [example[i] for example in dataSet]
        uniqueVals = set(featList)                         #創建set集合{},元素不可重複
        newEntropy = 0.0                                  #經驗條件熵
        for value in uniqueVals:                         #計算信息增益
            subDataSet = splitDataSet(dataSet, i, value)         #subDataSet劃分後的子集
            prob = len(subDataSet) / float(len(dataSet))           #計算子集的概率
            newEntropy += prob * calcShannonEnt(subDataSet)     #根據公式計算經驗條件熵
        infoGain = baseEntropy - newEntropy                     #信息增益
        print("第%d個特徵的增益爲%.3f" % (i, infoGain))            #打印每個特徵的信息增益
        if (infoGain > bestInfoGain):                             #計算信息增益
            bestInfoGain = infoGain                    #更新信息增益，找到最大的信息增益
            bestFeature = i                               #記錄信息增益最大的特徵的索引值
    return bestFeature                                     #返回信息增益最大的特徵的索引值

"""
函數說明:統計classList中出現此處最多的元素(類標籤)

Parameters:
    classList - 類標籤列表
Returns:
    sortedClassCount[0][0] - 出現此處最多的元素(類標籤)
"""
def majorityCnt(classList):
    classCount = {}
    for vote in classList:                                        #統計classList中每個元素出現的次數
        if vote not in classCount.keys():classCount[vote] = 0   
        classCount[vote] += 1
    sortedClassCount = sorted(classCount.items(), key = operator.itemgetter(1), reverse = True)        #根據字典的值降序排序
    return sortedClassCount[0][0]                                #返回classList中出現次數最多的元素

"""
函數說明:創建決策樹

Parameters:
    dataSet - 訓練數據集
    labels - 分類屬性標籤
    featLabels - 存儲選擇的最優特徵標籤
Returns:
    myTree - 決策樹
"""
def createTree(dataSet, labels, featLabels):
    classList = [example[-1] for example in dataSet]            #取分類標籤(是否放貸:yes or 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]                            #最優特徵的標籤
    featLabels.append(bestFeatLabel)
    myTree = {bestFeatLabel:{}}                                    #根據最優特徵的標籤生成樹
    del(labels[bestFeat])                                        #刪除已經使用特徵標籤
    featValues = [example[bestFeat] for example in dataSet]        #得到訓練集中所有最優特徵的屬性值
    uniqueVals = set(featValues)                                #去掉重複的屬性值
    for value in uniqueVals:                                    #遍歷特徵，創建決策樹。                       
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), labels, featLabels)
    return myTree

if __name__ == '__main__':
    dataSet, labels = createDataSet()
    featLabels = []
    myTree = createTree(dataSet, labels, featLabels)
    print(myTree)

運行結果：

{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}

如果看這個結果顯示不太舒服的話，可以使用Matplotlib繪製決策樹或者使用Graphviz顯示決策樹。下面是使用Matplotlib繪製決策樹的代碼，只需要在上面代碼開頭加上 import相關的包並在結尾加入以下代碼即可顯示。

# -*- coding: UTF-8 -*-
from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
from math import log
import operator



#結尾處加上下面的代碼
"""
函數說明:獲取決策樹葉子結點的數目

Parameters:
    myTree - 決策樹
Returns:
    numLeafs - 決策樹的葉子結點的數目
"""
def getNumLeafs(myTree):
    numLeafs = 0                                                #初始化葉子
    firstStr = next(iter(myTree))                                #python3中myTree.keys()返回的是dict_keys,不在是list,所以不能使用myTree.keys()[0]的方法獲取結點屬性，可以使用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

"""
函數說明:獲取決策樹的層數

Parameters:
    myTree - 決策樹
Returns:
    maxDepth - 決策樹的層數
"""
def getTreeDepth(myTree):
    maxDepth = 0                                                #初始化決策樹深度
    firstStr = next(iter(myTree))                                #python3中myTree.keys()返回的是dict_keys,不在是list,所以不能使用myTree.keys()[0]的方法獲取結點屬性，可以使用list(myTree.keys())[0]
    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

"""
函數說明:繪製結點

Parameters:
    nodeTxt - 結點名
    centerPt - 文本位置
    parentPt - 標註的箭頭位置
    nodeType - 結點格式
Returns:
    無
"""
def plotNode(nodeTxt, centerPt, parentPt, nodeType):
    arrow_args = dict(arrowstyle="<-")                                            #定義箭頭格式
    font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)        #設置中文字體
    createPlot.ax1.annotate(nodeTxt, xy=parentPt,  xycoords='axes fraction',    #繪製結點
        xytext=centerPt, textcoords='axes fraction',
        va="center", ha="center", bbox=nodeType, arrowprops=arrow_args, FontProperties=font)

"""
函數說明:標註有向邊屬性值

Parameters:
    cntrPt、parentPt - 用於計算標註位置
    txtString - 標註的內容
Returns:
    無
"""
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, va="center", ha="center", rotation=30)

"""
函數說明:繪製決策樹

Parameters:
    myTree - 決策樹(字典)
    parentPt - 標註的內容
    nodeTxt - 結點名
Returns:
    無
"""
def plotTree(myTree, parentPt, nodeTxt):
    decisionNode = dict(boxstyle="sawtooth", fc="0.8")                                        #設置結點格式
    leafNode = dict(boxstyle="round4", fc="0.8")                                            #設置葉結點格式
    numLeafs = getNumLeafs(myTree)                                                          #獲取決策樹葉結點數目，決定了樹的寬度
    depth = getTreeDepth(myTree)                                                            #獲取決策樹層數
    firstStr = next(iter(myTree))                                                            #下個字典                                                 
    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                                        #y偏移
    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

"""
函數說明:創建繪製面板

Parameters:
    inTree - 決策樹(字典)
Returns:
    無
"""
def createPlot(inTree):
    fig = plt.figure(1, facecolor='white')                                                    #創建fig
    fig.clf()                                                                                #清空fig
    axprops = dict(xticks=[], yticks=[])
    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)                                #去掉x、y軸
    plotTree.totalW = float(getNumLeafs(inTree))                                            #獲取決策樹葉結點數目
    plotTree.totalD = float(getTreeDepth(inTree))                                            #獲取決策樹層數
    plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0;                                #x偏移
    plotTree(inTree, (0.5,1.0), '')                                                            #繪製決策樹
    plt.show()                                                                                 #顯示繪製結果     

if __name__ == '__main__':
    dataSet, labels = createDataSet()
    featLabels = []
    myTree = createTree(dataSet, labels, featLabels)
    print(myTree)  
    createPlot(myTree)

最後我們可以看到可視化的決策樹：

3.3 剪枝

剪枝是爲了防止決策樹過擬合現象，分別有預剪枝和後剪枝。

預剪枝：在決策樹生成過程中，在劃分節點時，若該節點沒提高其在驗證集上的準確率，則不進行劃分

後剪枝：先生成一棵完整的決策樹，再從底往上對非葉節點考察進行剪枝

4 sklearn實現決策樹

以乳腺癌數據集爲例：

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeClassifier

dt = load_breast_cancer()
clf = DecisionTreeClassifier(criterion='entropy')
score = cross_val_score(clf,dt.data,dt.target,cv=5)
print(np.mean(score))

機器學習實戰——決策樹構建過程，信息熵及相關代碼

1. 決策樹基本概念

2. 決策樹類別

3. 構建決策樹

3.1 選擇最優特徵

3.1.1 信息熵

3.1.2 信息增益

3.2 決策樹的生成

3.3 剪枝

4 sklearn實現決策樹

python gdal 安裝使用（Windows， python 3.6.8）

無法安裝64位office，因爲已有32位版本的程序【親測可用】

英文會議參考文獻的出版地 and 英文參考文獻的查找

機器學習實戰——決策樹構建過程，信息熵及相關代碼

Learning Visual Knowledge Memory Networks for Visual Question Answering論文解讀

matplotlib中的plt.subplot()使用介紹

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結