前言
- 決策樹在我們的生活中應用非常廣泛，甚至可以說無處不在。
- 小實例：下午要上課，但是女友來找，我是上課呢，還是陪女友，想想那個重要，就選哪個！
- 決策樹絕大多數用來分類，也可以用于回歸(取節點平均值即可)。
- 決策樹劃分數據集常用算法有 ID3算法， C4.5算法，本章節使用 ID3 算法劃分數據集。
ID3 算法
- 從信息論知識中我們知道，期望信息越小，信息增益越大，從而純度越高。所以 ID3 算法的核心思想就是以信息增益度量屬性選擇，選擇分裂后信息增益最大的屬性進行分裂。下面先定義幾個要用到的概念。
- 設 D 為用類別對訓練元組進行的劃分，則 D 的熵表示為:
其中 pi 表示第 i 個類別在整個訓練元組中出現的概率，可以用此類別元素的數量除以訓練元組元素總數量作為估計。熵的實際意義表示是 D 中元組的類標號所需要的平均信息量。 -
現在我們假設將訓練元組 D 按屬性 A 進行劃分，則 A 對 D 劃分的數學期望信息為：
-
信息增益即為兩者的差值:
- ID3 算法就是在每次需要分裂時，計算每個屬性的增益率，然后選擇增益率最大的屬性進行分裂。
1，準備數據如下
- 圖表中的數據用編程實現如下
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
-
計算給定數據集的香農熵，代碼實現
from math import log
def calcShannonEnt(dataSet):
# 數據集樣本數
numEntries = len(dataSet)
# 定義字典，用于計數
labelCounts = {}
# 從數據集中，每次取出一行
for featVec in dataSet:
# 取出每一行的最后一列，即 'yes' or 'no'
currentLabel = featVec[-1]
# 判斷 'yes' or 'no' 是否在字典中，不在加入計數為0，在則計數加1
if currentLabel not in labelCounts.keys():
labelCounts[currentLabel] = 0
labelCounts[currentLabel] += 1
# 定義容器，存放 熵
shannonEnt = 0.0
# 依據信息熵公式，計算該 dataSet 的信息熵
for key in labelCounts:
prob = float(labelCounts[key]) / numEntries
shannonEnt -= prob * log(prob, 2)
# 返回 dataSet 的信息熵
return shannonEnt
- 測試一下
myDat, labels = createDataSet()
print(myDat)
print(labels)
print(calcShannonEnt(myDat))
# [[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
# ['no surfacing', 'flippers']
# 0.9709505944546686
# 數據越混亂，熵越高，增加更多分類，觀察熵值變化
myDat[0][-1] = 'maybe' # 熵越高，則混合的數據也越多
print(calcShannonEnt(myDat))
# 1.3709505944546687
- 按照給定特征劃分數據集
# dataSet 數據集
# axis 列號
# value 將列號為axis，值為value的 其他數據分個出來，看實例
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
- 測試一下
myDat, labels = createDataSet()
print(myDat)
print(splitDataSet(myDat, 0, 1))
print(splitDataSet(myDat, 0, 0))
print(splitDataSet(myDat, 1, 1))
print(splitDataSet(myDat, 1, 0))
# [[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
# [[1, 'yes'], [1, 'yes'], [0, 'no']]
# [[1, 'no'], [1, 'no']]
# [[1, 'yes'], [1, 'yes'], [0, 'no'], [0, 'no']]
# [[1, 'no']]
-
選擇最好的數據集劃分方式
現在我們假設將訓練元組 D 按屬性 A 進行劃分，則 A 對 D 劃分的數學期望信息為：
信息增益即為兩者的差值:
def chooseBestFeatureToSplit(dataSet):
# 每一行最后一列為 label,計算 feature 列數
numFeatures = len(dataSet[0]) - 1
# 計算整個數據集的信息熵
baseEntropy = calcShannonEnt(dataSet)
# bestInfoGain 信息增益預先設為為 0.0
# bestFeature 最好劃分的列標簽，預先設為 -1
bestInfoGain = 0.0; bestFeature = -1
# 依據 feature 數進行循環
for i in np.arange(numFeatures):
# 將每一行數據取出，存為list，次數為feature數，即沒有最后一列label
featList = [example[i] for example in dataSet]
# set 去冗余
uniqueVals = set(featList)
# 定義熵容器
newEntropy = 0.0
# 從 uniqueVals 集合中迭代
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
- 測試一下
myDat, labels = createDataSet()
print(chooseBestFeatureToSplit(myDat)) # 0
測試結果為 0，即選擇第0列進行劃分。
- 多數表決的方法決定該葉子節點的分類
如果數據集已經處理了所有屬性，但是類標簽依然不是唯一的，此時我們需要決定如何定義該葉子節點，在這種情況下，我們通常會采用 多數表決的方法決定該葉子節點的分類
def majorityCnt(classList):
# 定義一個用于計數的字典
# 注，此時classList 只有一列，為類標簽，因為類標簽不唯一，才用此方法找最多的label
classCount = {}
# 從 classList 迭代取值
for vote in classList:
# 如果從classList中取出的值不在classCount字典中，則將該值放入字典，
# 計數為1，否則在字典中的該值計數加1
if vote not in classCount.keys():
classCount[vote] = 0
classCount[vote] += 1
# 找到字典中 value 最大的 key 并返回
newvalue = -1
for key in classCount:
if newvalue < classCount[key]:
newkey = key
newvalue = classCount[key]
return newkey
- 創建樹的函數代碼
# 兩個輸入參數-- 數據集， 標簽列表
def createTree(dataSet, labels):
# 將 dataSet 最后一列放入 classList
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
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
- 測試一下
myDat, labels = createDataSet()
myTree = createTree(myDat, labels)
print(myTree)
# {'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}
- 使用決策樹執行分類
# inputTree 創建好的決策樹
# featLabels 存放feature名的list
# testVec 預測的feature
def classify(inputTree, featLabels, testVec):
# 取出決策樹的key，存為list，并取第一個key
firstStr = list(inputTree.keys())[0]
# 取出第一個key所對應的value
secondDict = inputTree[firstStr]
# 取出 firstStr 所在的列號
featIndex = featLabels.index(firstStr)
# 這段代碼為遞歸找到類別，依次遞歸向下找
for key in secondDict.keys():
if testVec[featIndex] == key:
if isinstance(secondDict[key], dict):
classLabel = classify(secondDict[key], featLabels, testVec)
else:
classLabel = secondDict[key]
return classLabel
- 測試分類效果
myDat, labels = createDataSet()
print(labels)
# ['no surfacing', 'flippers']
myTree = createTree(myDat, labels)
print(myTree)
# {'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}
# 經過 createTree 已經把labels給破壞了，所以現在要從新獲取labels
myDat, labels = createDataSet()
print(classify(myTree, labels, [1, 0])) # no
print(classify(myTree, labels, [1, 1])) # yes
