機器學習-決策樹建立（一）

優點：計算複雜度不高，輸出結果易於理解，對中間再缺失不敏感，可以處理不相關特性。

缺點：可能產生過渡匹配問題

使用類型：數字型和標稱型

一，基本概念

1，信息熵

度量樣本集合純度的最常用指標之一。值越小，則純度越高。

公式爲：

其中，Pk爲第k類佔總數的比例。

例如，有10個樣本，4個爲好，6個爲壞，則信息熵爲：Ent(D)=-(4/10*log2(4/10)+6/10*log2(6/10))

2,信息增益

用於衡量分支影響力大小。信息增益越大，則影響力越大。ID3決策樹就是採用信息增益劃分屬性。

公式爲：

其中，D爲分支下的總數，Dv爲佔總數比例。

例如：數據如下：

 

1,青綠,蜷縮,濁響,清晰,凹陷,硬滑,是
2,烏黑,蜷縮,沉悶,清晰,凹陷,硬滑,是
3,烏黑,蜷縮,濁響,清晰,凹陷,硬滑,是
4,青綠,蜷縮,沉悶,清晰,凹陷,硬滑,是
5,淺白,蜷縮,濁響,清晰,凹陷,硬滑,是
6,青綠,稍蜷,濁響,清晰,稍凹,軟粘,是
7,烏黑,稍蜷,濁響,稍糊,稍凹,軟粘,是
8,烏黑,稍蜷,濁響,清晰,稍凹,硬滑,是
9,烏黑,稍蜷,沉悶,稍糊,稍凹,硬滑,否
10,青綠,硬挺,清脆,清晰,平坦,軟粘,否
11,淺白,硬挺,清脆,模糊,平坦,硬滑,否
12,淺白,蜷縮,濁響,模糊,平坦,軟粘,否
13,青綠,稍蜷,濁響,稍糊,凹陷,硬滑,否
14,淺白,稍蜷,沉悶,稍糊,凹陷,硬滑,否
15,烏黑,稍蜷,濁響,清晰,稍凹,軟粘,否
16,淺白,蜷縮,濁響,模糊,平坦,硬滑,否
17,青綠,蜷縮,沉悶,稍糊,稍凹,硬滑,否

 

信息熵有最後一列計算。ENT（D）=-（（8/17）*log2（8/17）+（9/17）*log2（9/17））=0.998

第二列分類可知，青綠爲編號{1,4,6,10,13,16},則信息熵Ent（D1）=-（（3/6）*log2（3/6）+（3/6）*log2（3/6））=1

烏黑和淺白計算類似信息熵爲0.918和0.722

則最終信息增益爲：Gain（D，色澤）=0.998-（6/17*1+6/17*0.918+5/17*0.722）=0.109

3，信息增益率

信息增益對屬性多有偏好，信息增益對屬性少的有偏好。是ID4.5決策樹算法。

公式如下：

4，基尼指數

基尼指數䦹一種衡量數據集純度指標。基尼指數越小，純度越高。

公式如下：

python代碼：

新建兩個Python文件：tree.py，用於決策樹分類；treePlotter.py用於繪製圖形

tree.py代碼：

 

from math import log
import operator
import treePlotter as tp

def createDataSet():
    dataSet=[]
    fr = open('watermelon1.txt')
    for line in fr.readlines():
        lineArr = line.strip().split(',')
        dataSet.append(lineArr[:])  # 添加數據
    labels = ['編號','色澤','根蒂','敲聲','紋理','頭部','觸感','好瓜']
    return dataSet, labels

#計算信息熵 Ent（D）=-Σp*log2(p)
def calcShannonEnt(dataSet):
    numEntries = len(dataSet)                    #數據總數
    labelCounts = {}
    for featVec in dataSet:
        currentLabel = featVec[-1]               #獲取類別
        if currentLabel not in labelCounts.keys(): labelCounts[currentLabel] = 0   #新key加入字典賦值爲0
        labelCounts[currentLabel] += 1           #已經存在的key，value+=1
    shannonEnt = 0.0
    for key in labelCounts:
        prob = float(labelCounts[key])/numEntries
        shannonEnt -= prob * log(prob,2)             #計算信息熵
    return shannonEnt

#獲取特徵值數據集
# dataSet --整個數據集
# axis --數據列
# value --類別
def splitSubDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            retDataSet.append([featVec[axis],featVec[-1]])
    return retDataSet

#除去劃分完成的決策樹數據量
def splitDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            reducedFeatVec = featVec[:axis]
            reducedFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet

# 計算連續變量的分類點
# def calcconplot(subDataSet)

# 計算信息增益並返回信息增益最高的列
def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1      #獲取所有特徵值數量(減1是除去最後一列分類)
    baseEntropy = calcShannonEnt(dataSet)   #計算基礎信息熵Ent(D)
    bestInfoGain = 0.0; bestFeature = []
    for i in range(1,numFeatures):        #遍歷所有特徵值
        featList = [example[i] for example in dataSet]#將特徵值保存在列表中
        uniqueVals = set(featList)       #獲取特徵值分類
        newEntropy = 0.0                                               #特徵值不連續
        for value in uniqueVals:
            subDataSet = splitSubDataSet(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={}
    for vote in classList:
        if vote not in classCount.keys(): classCount[vote] = 0
        classCount[vote] += 1
    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:{}}
    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)                             # 獲取特徵值分類
    del(labels[bestFeat])                                    # 刪除已經建立節點的特徵值
    for value in uniqueVals:
        subLabels = labels[:]                                 # 複製出建立節點外的所有特徵值
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)  #建立子節點
    return myTree

if __name__ == '__main__':
    myData,label = createDataSet()
    mytree = createTree(myData,label)
    tp.createPlot(mytree)

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 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':  #如果是節點則深度加1
            thisDepth = 1 + getTreeDepth(secondDict[key])
        else:   thisDepth = 1
        if thisDepth > maxDepth: maxDepth = thisDepth
    return maxDepth

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 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()

# 繪製節點文字
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)

#計算節點位置
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

結果如下圖：

接下來，我們給出測試數據如下：

1,青綠,蜷縮,濁響,清晰,凹陷,軟粘
2,烏黑,稍蜷,沉悶,清晰,凹陷,硬滑
3,青綠,蜷縮,濁響,稍糊,平坦,硬滑
4,青綠,稍蜷,沉悶,清晰,凹陷,硬滑
5,淺白,蜷縮,濁響,稍糊,凹陷,硬滑
6,青綠,稍蜷,濁響,清晰,平坦,軟粘
7,烏黑,稍蜷,濁響,稍糊,稍凹,軟粘
8,青綠,稍蜷,濁響,清晰,稍凹,硬滑
9,烏黑,稍蜷,沉悶,稍糊,稍凹,硬滑
10,青綠,硬挺,濁響,清晰,平坦,軟粘
11,淺白,硬挺,清脆,模糊,平坦,硬滑
12,淺白,蜷縮,濁響,模糊,平坦,軟粘
13,青綠,稍蜷,濁響,稍糊,凹陷,硬滑
14,淺白,稍蜷,沉悶,稍糊,凹陷,硬滑
15,烏黑,稍蜷,濁響,清晰,稍凹,軟粘
16,淺白,蜷縮,濁響,模糊,平坦,硬滑

17,青綠,蜷縮,濁響,稍糊,稍凹,軟粘

然後在tree.py新增：

 

# 決策樹進行分類
def classify(inputTree,featLabels,testVec):
    firstStr = list(inputTree.keys())[0]
    secondDict = inputTree[firstStr]
    featIndex = featLabels.index(firstStr)
    key = testVec[featIndex]
    valueOfFeat = secondDict[key]
    if isinstance(valueOfFeat, dict):
        classLabel = classify(valueOfFeat, featLabels, testVec)
    else: classLabel = valueOfFeat
    return classLabel

# 讀取測試數據
def createtestDataSet():
    dataSet=[]
    fr = open('testData.txt')
    for line in fr.readlines():
        lineArr = line.strip().split(',')
        dataSet.append(lineArr[:])  # 添加數據
    labels = ['編號','色澤','根蒂','敲聲','紋理','頭部','觸感']
    return dataSet, labels

if __name__ == '__main__':
    myData,label = createDataSet()
    mytree = createTree(myData,label)
    tp.createPlot(mytree)
    testData,testlabel = createtestDataSet()
    for data in testData:
        cla = classify(mytree,testlabel,data)
        print(data)
        print(cla)

決策樹分類得到如下結果：

['1', '青綠', '蜷縮', '濁響', '清晰', '凹陷', '軟粘']
是
['2', '烏黑', '稍蜷', '沉悶', '清晰', '凹陷', '硬滑']
是
['3', '青綠', '蜷縮', '濁響', '稍糊', '平坦', '硬滑']
否
['4', '青綠', '稍蜷', '沉悶', '清晰', '凹陷', '硬滑']
是
['5', '淺白', '蜷縮', '濁響', '稍糊', '凹陷', '硬滑']
否
['6', '青綠', '稍蜷', '濁響', '清晰', '平坦', '軟粘']
是
['7', '烏黑', '稍蜷', '濁響', '稍糊', '稍凹', '軟粘']
是
['8', '青綠', '稍蜷', '濁響', '清晰', '稍凹', '硬滑']
是
['9', '烏黑', '稍蜷', '沉悶', '稍糊', '稍凹', '硬滑']
否
['10', '青綠', '硬挺', '濁響', '清晰', '平坦', '軟粘']
否
['11', '淺白', '硬挺', '清脆', '模糊', '平坦', '硬滑']
否
['12', '淺白', '蜷縮', '濁響', '模糊', '平坦', '軟粘']
否
['13', '青綠', '稍蜷', '濁響', '稍糊', '凹陷', '硬滑']
否
['14', '淺白', '稍蜷', '沉悶', '稍糊', '凹陷', '硬滑']
否
['15', '烏黑', '稍蜷', '濁響', '清晰', '稍凹', '軟粘']
否
['16', '淺白', '蜷縮', '濁響', '模糊', '平坦', '硬滑']
否
['17', '青綠', '蜷縮', '濁響', '稍糊', '稍凹', '軟粘']
是