id3演算法例題

❶ 用python實現紅酒數據集的ID3,C4.5和CART演算法

ID3演算法介紹
ID3演算法全稱為迭代二叉樹3代演算法（Iterative Dichotomiser 3）
該演算法要先進行特徵選擇，再生成決策樹，其中特徵選擇是基於「信息增益」最大的原則進行的。
但由於決策樹完全基於訓練集生成的，有可能對訓練集過於「依賴」，即產生過擬合現象。因此在生成決策樹後，需要對決策樹進行剪枝。剪枝有兩種形式，分別為前剪枝（Pre-Pruning）和後剪枝（Post-Pruning），一般採用後剪枝。
信息熵、條件熵和信息增益
信息熵：來自於香農定理，表示信息集合所含信息的平均不確定性。信息熵越大，表示不確定性越大，所含的信息量也就越大。
設x 1 , x 2 , x 3 , . . . x n {x_1, x_2, x_3, ...x_n}x
1

,x
2

,x
3

,...x
n

為信息集合X的n個取值，則x i x_ix
i

的概率：
P ( X = i ) = p i , i = 1 , 2 , 3 , . . . , n P(X=i) = p_i, i=1,2,3,...,n
P(X=i)=p
i

,i=1,2,3,...,n

信息集合X的信息熵為：
H ( X ) = − ∑ i = 1 n p i log ⁡ p i H(X) =- \sum_{i=1}^{n}{p_i}\log{p_i}
H(X)=−
i=1
∑
n

p
i

logp
i

條件熵：指已知某個隨機變數的情況下，信息集合的信息熵。
設信息集合X中有y 1 , y 2 , y 3 , . . . y m {y_1, y_2, y_3, ...y_m}y
1

,y
2

,y
3

,...y
m

組成的隨機變數集合Y，則隨機變數（X，Y）的聯合概率分布為
P ( x = i , y = j ) = p i j P(x=i,y=j) = p_{ij}
P(x=i,y=j)=p
ij

條件熵：
H ( X ∣ Y ) = ∑ j = 1 m p ( y j ) H ( X ∣ y j ) H(X|Y) = \sum_{j=1}^m{p(y_j)H(X|y_j)}
H(X∣Y)=
j=1
∑
m

p(y
j

)H(X∣y
j

)
由
H ( X ∣ y j ) = − ∑ j = 1 m p ( y j ) ∑ i = 1 n p ( x i ∣ y j ) log ⁡ p ( x i ∣ y j ) H(X|y_j) = - \sum_{j=1}^m{p(y_j)}\sum_{i=1}^n{p(x_i|y_j)}\log{p(x_i|y_j)}
H(X∣y
j

)=−
j=1
∑
m

p(y
j

)
i=1
∑
n

p(x
i

∣y
j

)logp(x
i

∣y
j

)
和貝葉斯公式：
p ( x i y j ) = p ( x i ∣ y j ) p ( y j ) p(x_iy_j) = p(x_i|y_j)p(y_j)
p(x
i

y
j

)=p(x
i

∣y
j

)p(y
j

)
可以化簡條件熵的計算公式為:
H ( X ∣ Y ) = ∑ j = 1 m ∑ i = 1 n p ( x i , y j ) log ⁡ p ( x i ) p ( x i , y j ) H(X|Y) = \sum_{j=1}^m \sum_{i=1}^n{p(x_i, y_j)\log\frac{p(x_i)}{p(x_i, y_j)}}
H(X∣Y)=
j=1
∑
m

i=1
∑
n

p(x
i

,y
j

)log
p(x
i

,y
j

)
p(x
i

)

信息增益：信息熵-條件熵，用於衡量在知道已知隨機變數後，信息不確定性減小越大。
d ( X , Y ) = H ( X ) − H ( X ∣ Y ) d(X,Y) = H(X) - H(X|Y)
d(X,Y)=H(X)−H(X∣Y)

python代碼實現
import numpy as np
import math

def calShannonEnt(dataSet):
""" 計算信息熵 """
labelCountDict = {}
for d in dataSet:
label = d[-1]
if label not in labelCountDict.keys():
labelCountDict[label] = 1
else:
labelCountDict[label] += 1
entropy = 0.0
for l, c in labelCountDict.items():
p = 1.0 * c / len(dataSet)
entropy -= p * math.log(p, 2)
return entropy

def filterSubDataSet(dataSet, colIndex, value):
"""返回colIndex特徵列label等於value，並且過濾掉改特徵列的數據集"""
subDataSetList = []
for r in dataSet:
if r[colIndex] == value:
newR = r[:colIndex]
newR = np.append(newR, (r[colIndex + 1:]))
subDataSetList.append(newR)
return np.array(subDataSetList)

def chooseFeature(dataSet):
""" 通過計算信息增益選擇最合適的特徵"""
featureNum = dataSet.shape[1] - 1
entropy = calShannonEnt(dataSet)
bestInfoGain = 0.0
bestFeatureIndex = -1
for i in range(featureNum):
uniqueValues = np.unique(dataSet[:, i])
condition_entropy = 0.0

for v in uniqueValues: #計算條件熵
subDataSet = filterSubDataSet(dataSet, i, v)
p = 1.0 * len(subDataSet) / len(dataSet)
condition_entropy += p * calShannonEnt(subDataSet)
infoGain = entropy - condition_entropy #計算信息增益

if infoGain >= bestInfoGain: #選擇最大信息增益
bestInfoGain = infoGain
bestFeatureIndex = i
return bestFeatureIndex

def creatDecisionTree(dataSet, featNames):
""" 通過訓練集生成決策樹 """
featureName = featNames[:] # 拷貝featNames，此處不能直接用賦值操作，否則新變數會指向舊變數的地址
classList = list(dataSet[:, -1])
if len(set(classList)) == 1: # 只有一個類別
return classList[0]
if dataSet.shape[1] == 1: #當所有特徵屬性都利用完仍然無法判斷樣本屬於哪一類，此時歸為該數據集中數量最多的那一類
return max(set(classList), key=classList.count)

bestFeatureIndex = chooseFeature(dataSet) #選擇特徵
bestFeatureName = featNames[bestFeatureIndex]
del featureName[bestFeatureIndex] #移除已選特徵列
decisionTree = {bestFeatureName: {}}

featureValueUnique = sorted(set(dataSet[:, bestFeatureIndex])) #已選特徵列所包含的類別， 通過遞歸生成決策樹
for v in featureValueUnique:
FeatureName = featureName[:]
subDataSet = filterSubDataSet(dataSet, bestFeatureIndex, v)
decisionTree[bestFeatureName][v] = creatDecisionTree(subDataSet, FeatureName)
return decisionTree

def classify(decisionTree, featnames, featList):
""" 使用訓練所得的決策樹進行分類 """
classLabel = None
root = decisionTree.keys()[0]
firstGenDict = decisionTree[root]
featIndex = featnames.index(root)
for k in firstGenDict.keys():
if featList[featIndex] == k:
if isinstance(firstGenDict[k], dict): #若子節點仍是樹，則遞歸查找
classLabel = classify(firstGenDict[k], featnames, featList)
else:
classLabel = firstGenDict[k]
return classLabel
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
下面用鳶尾花數據集對該演算法進行測試。由於ID3演算法只能用於標稱型數據，因此用在對連續型的數值數據上時，還需要對數據進行離散化，離散化的方法稍後說明，此處為了簡化，先使用每一種特徵所有連續性數值的中值作為分界點，小於中值的標記為1，大於中值的標記為0。訓練1000次，統計准確率均值。

from sklearn import datasets
from sklearn.model_selection import train_test_split

iris = datasets.load_iris()
data = np.c_[iris.data, iris.target]

scoreL = []
for i in range(1000): #對該過程進行10000次
trainData, testData = train_test_split(data) #區分測試集和訓練集

featNames = iris.feature_names[:]
for i in range(trainData.shape[1] - 1): #對訓練集每個特徵，以中值為分界點進行離散化
splitPoint = np.mean(trainData[:, i])
featNames[i] = featNames[i]+'<='+'{:.3f}'.format(splitPoint)
trainData[:, i] = [1 if x <= splitPoint else 0 for x in trainData[:, i]]
testData[:, i] = [1 if x <= splitPoint else 0 for x in testData[:, i]]

decisionTree = creatDecisionTree(trainData, featNames)
classifyLable = [classify(decisionTree, featNames, td) for td in testData]
scoreL.append(1.0 * sum(classifyLable == testData[:, -1]) / len(classifyLable))
print 'score: ', np.mean(scoreL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
輸出結果為：score: 0.7335，即准確率有73%。每次訓練和預測的准確率分布如下：

數據離散化
然而，在上例中對特徵值離散化的劃分點實際上過於「野蠻」，此處介紹一種通過信息增益最大的標准來對數據進行離散化。原理很簡單，當信息增益最大時，說明用該點劃分能最大程度降低數據集的不確定性。
具體步驟如下：

對每個特徵所包含的數值型特徵值排序
對相鄰兩個特徵值取均值，這些均值就是待選的劃分點
用每一個待選點把該特徵的特徵值劃分成兩類，小於該特徵點置為1， 大於該特徵點置為0，計算此時的條件熵，並計算出信息增益
選擇信息使信息增益最大的劃分點進行特徵離散化
實現代碼如下：

def filterRawData(dataSet, colIndex, value, tag):
""" 用於把每個特徵的連續值按照區分點分成兩類，加入tag參數，可用於標記篩選的是哪一部分數據"""
filterDataList = []
for r in dataSet:
if (tag and r[colIndex] <= value) or ((not tag) and r[colIndex] > value):
newR = r[:colIndex]
newR = np.append(newR, (r[colIndex + 1:]))
filterDataList.append(newR)
return np.array(filterDataList)

def dataDiscretization(dataSet, featName):
""" 對數據每個特徵的數值型特徵值進行離散化 """
featureNum = dataSet.shape[1] - 1
entropy = calShannonEnt(dataSet)

for featIndex in range(featureNum): #對於每一個特徵
uniqueValues = sorted(np.unique(dataSet[:, featIndex]))
meanPoint = []

for i in range(len(uniqueValues) - 1): # 求出相鄰兩個值的平均值
meanPoint.append(float(uniqueValues[i+1] + uniqueValues[i]) / 2.0)
bestInfoGain = 0.0
bestMeanPoint = -1
for mp in meanPoint: #對於每個劃分點
subEntropy = 0.0 #計算該劃分點的信息熵
for tag in range(2): #分別劃分為兩類
subDataSet = filterRawData(dataSet, featIndex, mp, tag)
p = 1.0 * len(subDataSet) / len(dataSet)
subEntropy += p * calShannonEnt(subDataSet)

## 計算信息增益
infoGain = entropy - subEntropy
## 選擇最大信息增益
if infoGain >= bestInfoGain:
bestInfoGain = infoGain
bestMeanPoint = mp
featName[featIndex] = featName[featIndex] + "<=" + "{:.3f}".format(bestMeanPoint)
dataSet[:, featIndex] = [1 if x <= bestMeanPoint else 0 for x in dataSet[:, featIndex]]
return dataSet, featName
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
重新對數據進行離散化，並重復該步驟1000次，同時用sklearn中的DecisionTreeClassifier對相同數據進行分類，分別統計平均准確率。運行代碼如下:

from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
scoreL = []
scoreL_sk = []
for i in range(1000): #對該過程進行1000次
featNames = iris.feature_names[:]
trainData, testData = train_test_split(data) #區分測試集和訓練集
trainData_tmp = .(trainData)
testData_tmp = .(testData)
discritizationData, discritizationFeatName= dataDiscretization(trainData, featNames) #根據信息增益離散化
for i in range(testData.shape[1]-1): #根據測試集的區分點離散化訓練集
splitPoint = float(discritizationFeatName[i].split('<=')[-1])
testData[:, i] = [1 if x<=splitPoint else 0 for x in testData[:, i]]
decisionTree = creatDecisionTree(trainData, featNames)
classifyLable = [classify(decisionTree, featNames, td) for td in testData]
scoreL.append(1.0 * sum(classifyLable == testData[:, -1]) / len(classifyLable))

clf = DecisionTreeClassifier('entropy')
clf.fit(trainData[:, :-1], trainData[:, -1])
clf.predict(testData[:, :-1])
scoreL_sk.append(clf.score(testData[:, :-1], testData[:, -1]))

print 'score: ', np.mean(scoreL)
print 'score-sk: ', np.mean(scoreL_sk)
fig = plt.figure(figsize=(10, 4))
plt.subplot(1,2,1)
pd.Series(scoreL).hist(grid=False, bins=10)
plt.subplot(1,2,2)
pd.Series(scoreL_sk).hist(grid=False, bins=10)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
兩者准確率分別為：
score: 0.7037894736842105
score-sk: 0.7044736842105263

准確率分布如下：

兩者的結果非常一樣。
（但是。。為什麼根據信息熵離散化得到的准確率比直接用均值離散化的准確率還要低啊？？哇的哭出聲。。）

最後一次決策樹圖形如下：

決策樹剪枝
由於決策樹是完全依照訓練集生成的，有可能會有過擬合現象，因此一般會對生成的決策樹進行剪枝。常用的是通過決策樹損失函數剪枝，決策樹損失函數表示為:
C a ( T ) = ∑ t = 1 T N t H t ( T ) + α ∣ T ∣ C_a(T) = \sum_{t=1}^TN_tH_t(T) +\alpha|T|
C
a

(T)=
t=1
∑
T

N
t

H
t

(T)+α∣T∣

其中，H t ( T ) H_t(T)H
t

(T)表示葉子節點t的熵值，T表示決策樹的深度。前項∑ t = 1 T N t H t ( T ) \sum_{t=1}^TN_tH_t(T)∑
t=1
T

N
t

H
t

(T)是決策樹的經驗損失函數當隨著T的增加，該節點被不停的劃分的時候，熵值可以達到最小，然而T的增加會使後項的值增大。決策樹損失函數要做的就是在兩者之間進行平衡，使得該值最小。
對於決策樹損失函數的理解，如何理解決策樹的損失函數? - 陶輕松的回答 - 知乎這個回答寫得挺好，可以按照答主的思路理解一下

C4.5演算法
ID3演算法通過信息增益來進行特徵選擇會有一個比較明顯的缺點：即在選擇的過程中該演算法會優先選擇類別較多的屬性（這些屬性的不確定性小，條件熵小，因此信息增益會大），另外，ID3演算法無法解決當每個特徵屬性中每個分類都只有一個樣本的情況（此時每個屬性的條件熵都為0）。
C4.5演算法ID3演算法的改進，它不是依據信息增益進行特徵選擇，而是依據信息增益率，它添加了特徵分裂信息作為懲罰項。定義分裂信息：
S p l i t I n f o ( X , Y ) = − ∑ i n ∣ X i ∣ ∣ X ∣ log ⁡ ∣ X i ∣ ∣ X ∣ SplitInfo(X, Y) =-\sum_i^n\frac{|X_i|}{|X|}\log\frac{|X_i|}{|X|}
SplitInfo(X,Y)=−
i
∑
n

∣X∣
∣X
i

∣

log
∣X∣
∣X
i

∣

則信息增益率為：
G a i n R a t i o ( X , Y ) = d ( X , Y ) S p l i t I n f o ( X , Y ) GainRatio(X,Y)=\frac{d(X,Y)}{SplitInfo(X, Y)}
GainRatio(X,Y)=
SplitInfo(X,Y)
d(X,Y)

關於ID3和C4.5演算法
在學習分類回歸決策樹演算法時，看了不少的資料和博客。關於這兩個演算法，ID3演算法是最早的分類演算法，這個演算法剛出生的時候其實帶有很多缺陷：

無法處理連續性特徵數據
特徵選取會傾向於分類較多的特徵
沒有解決過擬合的問題
沒有解決缺失值的問題
即該演算法出生時是沒有帶有連續特徵離散化、剪枝等步驟的。C4.5作為ID3的改進版本彌補列ID3演算法不少的缺陷：

通過信息最大增益的標准離散化連續的特徵數據
在選擇特徵是標准從「最大信息增益」改為「最大信息增益率」
通過加入正則項系數對決策樹進行剪枝
對缺失值的處理體現在兩個方面：特徵選擇和生成決策樹。初始條件下對每個樣本的權重置為1。
特徵選擇：在選取最優特徵時，計算出每個特徵的信息增益後，需要乘以一個**「非缺失值樣本權重占總樣本權重的比例」**作為系數來對比每個特徵信息增益的大小
生成決策樹：在生成決策樹時，對於缺失的樣本我們按照一定比例把它歸屬到每個特徵值中，比例為該特徵每一個特徵值占非缺失數據的比重
關於C4.5和CART回歸樹
作為ID3的改進版本，C4.5克服了許多缺陷，但是它自身還是存在不少問題：

C4.5的熵運算中涉及了對數運算，在數據量大的時候效率非常低。
C4.5的剪枝過於簡單
C4.5隻能用於分類運算不能用於回歸
當特徵有多個特徵值是C4.5生成多叉樹會使樹的深度加深
————————————————
版權聲明：本文為CSDN博主「Sarah Huang」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/weixin_44794704/article/details/89406612

❷ 通過ID3演算法得出的決策樹怎麼去測試別的實例啊還有ID3演算法是只能分析數值型的數據嗎

如果通過訓練集已經得出決策樹的話， 那使用測試集測試就很簡單了。 可以人工測試，也可以用數據分析軟體。

數據可以有很多種類型，關鍵是看你怎麼提取出數據的屬性進行分析。

請採納最佳答案~

❸ ID3演算法的介紹

ID3演算法是一種貪心演算法，用來構造決策樹。ID3演算法起源於概念學習系統（CLS），以信息熵的下降速度為選取測試屬性的標准，即在每個節點選取還尚未被用來劃分的具有最高信息增益的屬性作為劃分標准，然後繼續這個過程，直到生成的決策樹能完美分類訓練樣例。

❹ ID3演算法的背景知識

ID3演算法最早是由羅斯昆（J. Ross Quinlan）於1975年在悉尼大學提出的一種分類預測演算法，演算法的核心是「信息熵」。ID3演算法通過計算每個屬性的信息增益，認為信息增益高的是好屬性，每次劃分選取信息增益最高的屬性為劃分標准，重復這個過程，直至生成一個能完美分類訓練樣例的決策樹。
決策樹是對數據進行分類，以此達到預測的目的。該決策樹方法先根據訓練集數據形成決策樹，如果該樹不能對所有對象給出正確的分類，那麼選擇一些例外加入到訓練集數據中，重復該過程一直到形成正確的決策集。決策樹代表著決策集的樹形結構。
決策樹由決策結點、分支和葉子組成。決策樹中最上面的結點為根結點，每個分支是一個新的決策結點，或者是樹的葉子。每個決策結點代表一個問題或決策，通常對應於待分類對象的屬性。每一個葉子結點代表一種可能的分類結果。沿決策樹從上到下遍歷的過程中，在每個結點都會遇到一個測試，對每個結點上問題的不同的測試輸出導致不同的分支，最後會到達一個葉子結點，這個過程就是利用決策樹進行分類的過程，利用若干個變數來判斷所屬的類別。

❺ 簡述ID3演算法基本原理和步驟

1.基本原理：
以信息增益/信息熵為度量，用於決策樹結點的屬性選擇的標准，每次優先選取信息量最多（信息增益最大）的屬性，即信息熵值最小的屬性，以構造一顆熵值下降最快的決策樹，到葉子節點處的熵值為0。（信息熵 無條件熵 條件熵 信息增益 請查找其他資料理解）
決策樹將停止生長條件及葉子結點的類別取值：
①數據子集的每一條數據均已經歸類到每一類，此時，葉子結點取當前樣本類別值。
②數據子集類別仍有混亂，但已經找不到新的屬性進行結點分解，此時，葉子結點按當前樣本中少數服從多數的原則進行類別取值。
③數據子集為空，則按整個樣本中少數服從多數的原則進行類別取值。

步驟：
理解了上述停止增長條件以及信息熵，步驟就很簡單

❻ 向大神求教！python寫的決策樹的ID3演算法怎麼一直提示bestfeat=labels[bestfeat_index]超出索引啊！

1、對當前訓練集，計算各屬性的信息增益（假設有屬性A1,A2,…An）；
2、選擇信息增益最大的屬性Ak（1<=k<=n），作為根節點；
3、把在Ak處取值相同的例子歸於同一子集，作為該節點的一個樹枝，Ak取幾個值就得幾個子集；
4、若在某個子集中的所有樣本都是屬於同一個類型（本位只討論正(Y)、反(N)兩種類型的情況），則給該分支標上類型號作為葉子節點；
5、對於同時含有多種（兩種）類型的子集，則遞歸調用該演算法思路來完成樹的構造。

❼ 用vb語言實現id3演算法

給你個例題看

Function ID3(R：一個非類別的屬性集合，C：類別屬性，S：一個訓練集)
Begin
If S為空, 返回一個值為FAILURE的單個節點；
If S是由其值均為相同類別屬性值的記錄組成，
返回一個帶有該值的單個節點；
If R為空,則返回一個單節點，其值為在S記錄中找出的頻率最高的類別屬性值；
將R中屬性之間具有最大gain(D，S)值的屬性賦值給D；
將屬性D的值賦值給{dj |j =1,2,3 …m}；
將分別由對應於D的值為dj的記錄組成的S的子集賦給{sj|j=1,2,3 …,m}；
返回一顆樹,其根標記為D,樹枝標記為d1， d2，…，dm ；
在分別遞歸構造以下樹：ID3(R-{D},C,S 1) , ID3(R-{D},C,S2) …, ID3(R-{D},C,Sm) ；
End ID3；
如圖：
屬性 天氣 氣溫 濕度 風 適合打高爾夫
1 多雲 熱 高 無風 不適合
2 晴 熱 高 無風 適合
3 多雲 熱 高 大風 不適合
4 晴 熱 高 中風 適合
5 雨 適中 高 無風 不適合
6 多雲 熱 高 中風 不適合
7 雨 熱 正常 無風 適合
8 雨 適中 高 中風 不適合
9 雨 冷 正常 中風 不適合
10 晴 冷 正常 大風 適合
11 雨 熱 正常 大風 不適合
12 晴 冷 正常 中風 適合
13 多雲 適中 高 中風 不適合
14 多雲 冷 正常 無風 適合
15 多雲 適中 高 無風 不適合
16 雨 適中 正常 無風 不適合
17 多雲 冷 正常 中風 適合
18 雨 適中 正常 中風 不適合
19 多雲 適中 正常 中風 適合
20 多雲 適中 正常 大風 適合
21 晴 適中 高 大風 適合
22 晴 適中 高 中風 適合
23 晴 熱 正常 無風 適合
24 雨 適中 高 大風 不適合
GAIN天氣熵=7/24（-7/7LOG2（7/7）-0）+9/24（4/9LOG2（4/9）+5/9LOG2（5/9））+8/24（1/8LOG2（1/8）+7/8LOG2（7/8）=0.5529
同理：GAIN 氣溫熵=0.9173 濕度熵=0.9184 風熵=1 所以選最小的天氣建樹最後遞歸生成樹：
天氣

晴 多雲 雨

適合） 濕度 氣溫
高 正常
（ 適合） （不適合） 熱 冷 適中
（不適合）（不適合）
風
大風 無風
（適合） （ 不適合）

❽ ID3演算法的ID3演算法

ID3演算法是由Quinlan首先提出的。該演算法是以資訊理論為基礎，以信息熵和信息增益度為衡量標准，從而實現對數據的歸納分類。以下是一些資訊理論的基本概念：
定義1：若存在n個相同概率的消息，則每個消息的概率p是1/n，一個消息傳遞的信息量為-Log2(1/n)
定義2：若有n個消息，其給定概率分布為P=(p1,p2…pn)，則由該分布傳遞的信息量稱為P的熵，記為
。
定義3：若一個記錄集合T根據類別屬性的值被分成互相獨立的類C1C2..Ck，則識別T的一個元素所屬哪個類所需要的信息量為Info(T)=I(p)，其中P為C1C2…Ck的概率分布，即P=(|C1|/|T|,…..|Ck|/|T|)
定義4：若我們先根據非類別屬性X的值將T分成集合T1,T2…Tn，則確定T中一個元素類的信息量可通過確定Ti的加權平均值來得到，即Info(Ti)的加權平均值為：
Info(X, T)=(i=1 to n 求和)((|Ti|/|T|)Info(Ti))
定義5：信息增益度是兩個信息量之間的差值，其中一個信息量是需確定T的一個元素的信息量，另一個信息量是在已得到的屬性X的值後需確定的T一個元素的信息量，信息增益度公式為：
Gain(X, T)=Info(T)-Info(X, T)
ID3演算法計算每個屬性的信息增益，並選取具有最高增益的屬性作為給定集合的測試屬性。對被選取的測試屬性創建一個節點，並以該節點的屬性標記，對該屬性的每個值創建一個分支據此劃分樣本.
數據描述
所使用的樣本數據有一定的要求,ID3是:
描述-屬性-值相同的屬性必須描述每個例子和有固定數量的價值觀。
預定義類-實例的屬性必須已經定義的,也就是說,他們不是學習的ID3。
離散類-類必須是尖銳的鮮明。連續類分解成模糊范疇(如金屬被「努力,很困難的,靈活的,溫柔的,很軟」都是不可信的。
足夠的例子——因為歸納概括用於(即不可查明)必須選擇足夠多的測試用例來區分有效模式並消除特殊巧合因素的影響。
屬性選擇
ID3決定哪些屬性如何是最好的。一個統計特性,被稱為信息增益,使用熵得到給定屬性衡量培訓例子帶入目標類分開。信息增益最高的信息(信息是最有益的分類)被選擇。為了明確增益,我們首先從資訊理論借用一個定義，叫做熵。每個屬性都有一個熵。

❾ 實現ID3決策樹學習演算法

http://www.rulequest.com/download.html
http://www.rulequest.com/See5-demo.zip
這里有些。
Diversity(整體)-diversity(左節點)-diversity(右節點)，值越大，分割就越好。

三種diversity的指標：

1. min(P(c1),P(c2))

2. 2P(c1)P(c2)

3. [P(c1)logP(c1)]+[P(c2)logP(c2)]

這幾個參數有相同的性質：當其中的類是均勻分布的時候，值最大；當有一個類的個數為0的時候，值為0。

選擇分割的時候，對每個欄位都考慮；對每個欄位中的值先排序，然後再一一計算。最後選出最佳的分割。

樹的生成：

錯誤率的衡量：最初生成的樹中也是有錯誤率的！因為有些葉子節點並不是「Pure」的。

樹的修剪：是不是當所以的葉子都很純是，這棵樹就能工作的很好呢?

修剪的要點是：應該回溯多少、如何從眾多的子樹總尋找最佳的。

1) 鑒別生成候選子樹 ：使用一個調整的錯誤率。AE(T)=E(T)+aleaf_count(T)。一步步的生成一些候選子樹。

2) 對子樹的評估：通過test set找到最佳子樹

3) 對最佳子樹進行評估：使用evaluation set。

4) 考慮代價(cost)的問題

❿ 如何用信息增益方法選擇最佳劃分點

文中所說的最佳劃分點，是在統計學中很重要的「決策分類問題」。

首先一點，為什麼要進行劃分，因為劃分方法就是建模的過程，為什麼要建模？因為為了要預測。。。

（如果你明白建模的意義，下面一段可以忽略）

比如你出去約會一個女生，你不知道怎麼樣穿衣服才能約會成功。。現在你手中有1000個約會案例，每個人穿著什麼樣的衣服，褲子，顏色，鞋子款式，有沒有帽子，這些「因素」都有記錄，最終的結果就是約會成功與否，那麼我們就可以構建一個數學模型，它的輸入是「衣服，褲子，顏色，鞋子款式」，輸出是約會成功與否。。。當這個模型建立成功，你輸入你今天穿的衣服，就能知道今天約會會不會成功了。。。

ok

下面要講解ID3演算法。（如果您明白ID3或者類似的演算法，可以忽略下面的）

我們先在腦子里想像，你現在是一個活動組織者，你如何根據天氣判斷明天的活動能不能開展呢。。。你不知道，沒關系，旅遊協會給你一張表

outlook temperature humidity windy
---------------------------------------------------------
sunny hot high false N
sunny hot high true N
overcast hot high false P
rain mild high false P
rain cool normal false P
rain cool normal true N
overcast cool normal true P
sunn y mild high false N
sunny cool normal false P
rain mild normal false P
sunny mild normal true P
overcast mild high true P
overcast hot normal false P
rain mild high true N

這張表列舉了前幾次活動中，天氣(outlook)，溫度，濕度，有沒有風(windy)，對活動最終是否能成功舉辦的影響。。。我們的問題時，如何用這張表作為判斷依據，當我得知天氣數據時，就能對能否舉辦活動作出預測？？

好，下面我們要介紹「信息熵」這個概念。

信息熵這個概念完全是數學家自己設計出來的。。。（香農：我不是數學家！！）

所以你不用太較真於公式。但是我先把公式給出來。