本文目錄一覽：
XGBoost演算法思想
一、boosting模式
boosting屬於集成學習框架之一，與bagging類似，boosting也不再是用單一的模型來進行預測，而是組合 若干弱學習器 來產生一個 強學習器
boosting：整個訓練過程呈階梯狀，弱學習器按照次序逐一進行訓練，與bagging不同在於每個弱學習器的訓練集，都按照 某種策略進行一定的轉化 ，最後對所有弱學習器的預測結果進行 線性綜合 來產生最終的預測結果。即：
關於boosting演算法比較常見的有： AdaBoost、GBDT 以及本文分析的 XGBoost
二、集成學習模型的偏差和方差
這裡我們可以用 期望 這個統計量來描述模型的 偏差
由方差和協方差的基本定義出發：
對於集成學習模型，通過計算弱學習器模型的 期望和方差 ，我們可以得到 模型整體的期望和方差。 而且不論是bagging還是boosting，其 弱學習器都是線性組成的 ，我們設每個弱學習器為 ，總共有 個弱學習器， 對應的權重為 ， 為整個模型
則模型的期望 為：
模型的方差 為：
這裡需要用到二項展開公式
帶入模型方差展開得
我們再引入2個統計量： 標準差 和相關係數 ，用來代表整體模型的標準差和相關係數，其基本定義為：
將 和 帶入模型方差，得
推導至此，我們得到了 集成學習整體模型的期望 和 方差 的數學表達式
集成學習模型的整體偏差和方差的關係可形象的展示為：
接下來我們分別討論在bagging或boosting演算法下模型整體的期望和方差
三、bagging的期望和方差
對於bagging來說，每個弱學習器的權重 都為 ，且每個弱學習器訓練的樣本都是從原始樣本採取 有放回式隨機抽樣 ，故每個弱學習器的 期望 近似相等 為
則bagging的期望為：
bagging的方差為：
我們也可以看到， 隨機森林( Random Forest)採取對 訓練集的特徵進行隨機抽樣的策略 ，使得各個弱學習器的 相關性降低 ，從而達到 減少方差 的效果
四、boosting的偏差和方差
對於boosting來說，訓練集抽樣是 強相關 的，即模型的相關係數 近似等於1
則boosting的期望為：
boosting的方差為：
五、XGBoost的基礎模型
XGBoost（Extreme Gradient Boosting）是 GBDT 的一種高效實現，其弱學習器除了可以是 CART回歸樹 ，也可以是 線性分類器 。這裡我們用CART樹來當作弱學習器
考慮場景：我們要預測一家人對電子遊戲的喜好程度，為此可以構建2顆CART樹
第1顆CART樹：考慮到年輕和年老相比，年輕更可能喜歡電子遊戲，故使用「年齡」作為第1個特徵來二分樣本集；再考慮到男性和女性相比，男性更喜歡電子遊戲，故使用「性別」作為第2個特徵來二分子樣本集，最後逐一給各人在電子遊戲喜好程度上打分
第2顆CART樹：考慮到喜歡電子遊戲的人每天使用電腦的頻率較高，故使用「每天使用電腦的頻率」作為特徵來二分子樣本集，最後逐一給各人在電子遊戲喜好程度上打分
對於上述兩顆CART樹，我們要計算小男孩的預測分數，只需在每顆CART樹中找到小男孩落在的樹葉位置，將樹葉對應的分數累加即可
我們將上述場景數學化
設 是樣本 的最終 預測分數 ， 是第i顆樹的葉子 打分映射 ，則 預測函數 為
所有樹的葉子打分映射將共同構成模型的 函數空間 ，即
（PS：注意這裡不再是模型的 參數空間 ，而是 函數空間 ）
六、XGBoost的目標函數
我們繼續定義出模型的 損失函數 為
接下來我們再定義出模型的複雜度為
我們對上述模型的損失函數和複雜度進行線性組合，便得到了XGBoost的目標函數
顯然，XGBoost的目標函數加入了 正則項 ，即： 用 表示模型的偏度（期望），用 表示模型的複雜度（方差）
七、優化目標函數
從數學角度看，目標函數 的定義是一個 泛函 ，優化目標函數等價於 泛函最優化問題 ，這使得我們很難進行優化
（PS： 的自變數包含K個函數 ，即 是 函數的函數—泛函 ）
我們將上述思想進行數學化，即
加入第0顆樹，當前模型的預測結果為
加入第1顆樹，當前模型的預測結果為
加入第2顆樹，當前模型的預測結果為
根據數學歸納法，加入第t顆樹，即第t次迭代，當前模型的預測結果為
將上述迭代結果帶入目標函數，則目標函數改為 迭代版本 如下
下面我們需要對目標函數進行一些 數學上的近似處理
我們知道二階泰勒公式的迭代形式為
這裡我們將目標函數 類比 二階泰勒公式，即
且定義 和 來 類比 二階泰勒公式中的 一階導數和二階導數 ，即
有了上述近似類比，我們將目標函數在 處進行 二階泰勒展開 ，得
我們繼續優化目標函數
由於目標函數 只受到基學習器 的影響 ，上一次的誤差 是常數項， 對本次迭代沒有影響 （常量微分為0），於是我們可以 刪除掉常數項 ，即
至此我們得到了迭代過程下，目標函數的 近似表達式 ，繼續優化之前，我們需要先討論每棵樹的函數表達式
八、樹的函數表達式的拆分
我們將第t顆樹的函數表達式 ，拆分成 樹結構部分q 和 葉子權重部分w ，即
如上圖，樹的物理意義為：
我們將其數學化，即定義：
至此，我們可以將樹的函數表達式 寫為
九、模型的複雜度定義
緊接著我們定義出模型的複雜度
我們用葉子節點的個數 和每片葉子的權重 的L2範數來共同描述模型的複雜度，即
其中 和 是超參數， 用來 收縮葉子個數 ， 控制葉子權重分數不會過 大，二者同時 防止模型過擬合
十、繼續優化目標函數
有了樹的函數表達式 的拆分和模型的複雜度 ，我們繼續優化目標函數
將二者帶入目標函數，得
下面需要用到一個 數學技巧 ，仔細觀察上式
上式中，紅色部分表示： 對整個樣本集合的遍歷 ；藍色部分表示： 對所有葉節點的遍歷
為了將 二者的累加形式統一 ，我們有如下結論
因此我們定義 表示樹中 第j個葉子中樣本的集合 ，即
將 帶入目標函數，我們就可以統一兩個 的物理意義和數學形式，即
緊接著我們定義 和 來簡化目標函數
帶入則目標函數最終可以化簡為
至此，我們一步步推導出了XGBoost目標函數的最終表達式，接下來就可以求解其極值
十一、求解目標函數極值
此時弱學習器—樹已經構造完成，即 樹結構 確定 ，為了使得目標函數達到最小值，我們令 對每個葉子的偏導數為0 ，即
求解上述偏導數，便可解出 每個葉子的最優權重 為：
將其帶入目標函數，便得到 模型的最小損失 為：
至此，我們完成了 XGBoost對目標函數的最優化過程。且從本質上講，這就是轉化為一個二次函數最優化問題
十二、樹節點分裂演算法
下面我們需要關心XGBoost的基學習器—樹到底長什麼樣子？
那麼 一個節點應該怎麼分裂？ 就成為了接下來我們要探討的關鍵
我們採取 貪心演算法 來分裂樹節點
關於Gain增益的計算，我們使用當前樹的最小損失，用節點 分裂前 的損失值減去 分裂後 的損失值，作為按當前特徵和候選點分裂的增益量化
按照貪心演算法構建樹，有下面兩種構建方案
這裡我們選取方案二進行建樹剪枝
十三、XGBoost的演算法步驟
從上面步驟可以看到，關鍵點是 樹的構造和剪枝
十四、案例演示
下面我們用原生python來實現myXGBoost模型（不考慮並行計算）
訓練樣本集為
首先構造樹節點類和方法
下面構造樹模型類和方法
用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:
copyFeatureName = featureName[:]
subDataSet = filterSubDataSet(dataSet, bestFeatureIndex, v)
decisionTree[bestFeatureName][v] = creatDecisionTree(subDataSet, copyFeatureName)
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 = copy.copy(trainData)
testData_tmp = copy.copy(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版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：
python哪個包實現apriori
要用apriori不需要哪個包，要有一個實現apriori功能的.py文件，將這個文件放置在你要調用的文件相同的地址，然後用 from apriori import * 來使用。。
apriori.py下載地址：鏈接：
密碼：aug8
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/297587.html
微信掃一掃 
支付寶掃一掃 