獨家｜從基礎到實現：集成學習綜合教程（附Python代碼）

作者：AISHWARYA SINGH

翻譯：和中華

校對：丁楠雅

本文約8000字，建議閱讀10+分鐘。

本文從基礎集成技術講起，隨後介紹了高級的集成技術，最後特別介紹了一些流行的基於Bagging和Boosting的算法，幫助讀者對集成學習建立一個整體印象。

介紹

當你想購買一輛新車時，你會走到第一家汽車商店就根據經銷商的建議購買一輛車嗎？這是不太可能的。

你可能會瀏覽一些人們發佈評論並比較不同車型的門戶網站，檢查其功能和價格。你也可能會問你的朋友和同事們的意見。總之，你不會直接得出結論，還會參考其他人的意見做出決定。

機器學習中的集成模型也是類似的思路。它們結合了多個模型的決策來提高整體性能。這可以通過各種方式實現，本文將會帶你一起探索。

本文的目的是介紹集成學習的概念並理解使用這種技術的算法。為了鞏固你對這個多元化主題的理解，我們將用真實問題的動手案例，配合Python來解釋其中的高級算法。

注意：本文假定你對機器學習算法有基本的瞭解。我建議閱讀這篇文章以熟悉這些概念。

文章鏈接：

https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/

目錄

• 集成學習介紹
• 基礎集成技術
• 最大投票（Max Voting）法
• 平均（Averaging）法
• 加權平均（Weighted Average）法
• 高級集成技術
• 堆疊（Stacking）
• 混合（Blending）
• Bagging
• 提升（Boosting）
• 基於Bagging和Boosting的算法
• Bagging meta-estimator
• 隨機森林
• AdaBoost
• GBM
• XGB
• Light GBM
• CatBoost

一、集成學習介紹

我們通過一個例子來理解集成學習的概念。假設你是一名電影導演，你依據一個非常重要且有趣的話題創作了一部短片。現在，你想在公開發布前獲得影片的初步反饋（評級）。有哪些可行的方法呢？

A：可以請一位朋友為電影打分。

於是完全有可能出現這種結果：你所選擇的人由於非常愛你，並且不希望給你這部糟糕的影片打1星評級來傷害你脆弱的小心臟。

B：另一種方法是讓你的5位同事評價這部電影。

這個辦法應該更好，可能會為電影提供更客觀誠實的評分。但問題依然存在。這5個人可能不是電影主題方面的“專家”。當然，他們可能懂電影攝製，鏡頭或音效，但他們可能並不是黑色幽默的最佳評判者。

C：讓50個人評價這部電影呢？

其中一些可以是你的朋友，可以是你的同事，甚至是完完全全的陌生人。

在這種情況下，回應將更加普遍化和多樣化，因為他們擁有不同的技能。事實證明，與我們之前看到的情況相比，這是獲得誠實評級的更好方法。

通過這些例子，你可以推斷，與個人相比，不同群體的人可能會做出更好的決策。與單一模型相比，各種不同模型也是這個道理。機器學習中的多樣化是通過稱為集成學習（Ensemble learning）的技術實現的。

現在你已經掌握了集成學習的要旨，接下來讓我們看看集成學習中的各種技術及其實現。

二、簡單集成技術

這一節中，我們會看一些簡單但是強大的技術，比如：

• 最大投票法
• 平均法
• 加權平均法

2.1 最大投票法

最大投票方法通常用於分類問題。這種技術中使用多個模型來預測每個數據點。每個模型的預測都被視為一次“投票”。大多數模型得到的預測被用作最終預測結果。

例如，當你讓5位同事評價你的電影時（最高5分）; 我們假設其中三位將它評為4，而另外兩位給它一個5。由於多數人評分為4，所以最終評分為4。你可以將此視為採用了所有預測的眾數（mode）。

最大投票的結果有點像這樣：

示例代碼：

這裡x_train由訓練數據中的自變量組成，y_train是訓練數據的目標變量。驗證集是x_test（自變量）和y_test（目標變量）。

model1 = tree.DecisionTreeClassifier()

model2 = KNeighborsClassifier()

model3= LogisticRegression()

model1.fit(x_train,y_train)

model2.fit(x_train,y_train)

model3.fit(x_train,y_train)

pred1=model1.predict(x_test)

pred2=model2.predict(x_test)

pred3=model3.predict(x_test)

final_pred = np.array([])

for i in range(0,len(x_test)):

final_pred =np.append(final_pred, mode([pred1[i], pred2[i], pred3[i]]))

或者，你也可以在sklearn中使用“VotingClassifier”模塊，如下所示：

from sklearn.ensemble import VotingClassifier

model1 = LogisticRegression(random_state=1)

model2 = tree.DecisionTreeClassifier(random_state=1)

model = VotingClassifier(estimators=[('lr', model1), ('dt', model2)], voting='hard')

model.fit(x_train,y_train)

model.score(x_test,y_test)

2.2 平均法

類似於最大投票技術，這裡對每個數據點的多次預測進行平均。在這種方法中，我們從所有模型中取平均值作為最終預測。平均法可用於在迴歸問題中進行預測或在計算分類問題的概率時使用。

例如，在下面的情況中，平均法將取所有值的平均值。

即（5 + 4 + 5 + 4 + 4）/ 5 = 4.4

示例代碼：

model1 = tree.DecisionTreeClassifier()

model2 = KNeighborsClassifier()

model3= LogisticRegression()

model1.fit(x_train,y_train)

model2.fit(x_train,y_train)

model3.fit(x_train,y_train)

pred1=model1.predict_proba(x_test)

pred2=model2.predict_proba(x_test)

pred3=model3.predict_proba(x_test)

finalpred=(pred1+pred2+pred3)/3

2.3 加權平均法

這是平均法的擴展。為所有模型分配不同的權重，定義每個模型的預測重要性。例如，如果你的兩個同事是評論員，而其他人在這方面沒有任何經驗，那麼與其他人相比，這兩個朋友的答案就更加重要。

計算結果為[（5 * 0.23）+（4 * 0.23）+（5 * 0.18）+（4 * 0.18）+（4 * 0.18）] = 4.41。

示例代碼：

model1 = tree.DecisionTreeClassifier()

model2 = KNeighborsClassifier()

model3= LogisticRegression()

model1.fit(x_train,y_train)

model2.fit(x_train,y_train)

model3.fit(x_train,y_train)

pred1=model1.predict_proba(x_test)

pred2=model2.predict_proba(x_test)

pred3=model3.predict_proba(x_test)

finalpred=(pred1*0.3+pred2*0.3+pred3*0.4)

三、高級集成技術

我們已經介紹了基礎的集成技術，讓我們繼續瞭解高級的技術。

3.1 堆疊（Stacking）

堆疊是一種集成學習技術，它使用多個模型（例如決策樹，knn或svm）的預測來構建新模型。該新模型用於對測試集進行預測。以下是簡單堆疊集成法的逐步解釋：

第一步：把訓練集分成10份

第二步：基礎模型（假設是決策樹）在其中9份上擬合，並對第10份進行預測。

第三步：

第四步：然後將基礎模型（此處是決策樹）擬合到整個訓練集上。

第五步：使用此模型，在測試集上進行預測。

第六步：對另一個基本模型（比如knn）重複步驟2到4，產生對訓練集和測試集的另一組預測。

第七步：訓練集預測被用作構建新模型的特徵。

第八步：該新模型用於對測試預測集（test prediction set，上圖的右下角）進行最終預測。

示例代碼：

我們首先定義一個函數來對n折的訓練集和測試集進行預測。此函數返回每個模型對訓練集和測試集的預測。

def Stacking(model,train,y,test,n_fold):

folds=StratifiedKFold(n_splits=n_fold,random_state=1)

test_pred=np.empty((test.shape[0],1),float)

train_pred=np.empty((0,1),float)

for train_indices,val_indices in folds.split(train,y.values):

x_train,x_val=train.iloc[train_indices],train.iloc[val_indices]

y_train,y_val=y.iloc[train_indices],y.iloc[val_indices]

model.fit(X=x_train,y=y_train)

train_pred=np.append(train_pred,model.predict(x_val))

test_pred=np.append(test_pred,model.predict(test))

return test_pred.reshape(-1,1),train_pred

現在我們將創建兩個基本模型：決策樹和knn。

model1 = tree.DecisionTreeClassifier(random_state=1)

test_pred1 ,train_pred1=Stacking(model=model1,n_fold=10, train=x_train,test=x_test,y=y_train)

train_pred1=pd.DataFrame(train_pred1)

test_pred1=pd.DataFrame(test_pred1)

model2 = KNeighborsClassifier()

test_pred2 ,train_pred2=Stacking(model=model2,n_fold=10,train=x_train,test=x_test,y=y_train)

train_pred2=pd.DataFrame(train_pred2)

test_pred2=pd.DataFrame(test_pred2)

創建第三個模型，邏輯迴歸，在決策樹和knn模型的預測之上。

df = pd.concat([train_pred1, train_pred2], axis=1)

df_test = pd.concat([test_pred1, test_pred2], axis=1)

model = LogisticRegression(random_state=1)

model.fit(df,y_train)

model.score(df_test, y_test)

為了簡化上面的解釋，我們創建的堆疊模型只有兩層。決策樹和knn模型建立在零級，而邏輯迴歸模型建立在第一級。其實可以隨意的在堆疊模型中創建多個層次。

3.2 混合（Stacking）

混合遵循與堆疊相同的方法，但僅使用來自訓練集的一個留出(holdout)/驗證集來進行預測。換句話說，與堆疊不同，預測僅在留出集上進行。留出集和預測用於構建在測試集上運行的模型。以下是混合過程的詳細說明：

第一步：原始訓練數據被分為訓練集合驗證集。

第二步：在訓練集上擬合模型。

第三步：在驗證集和測試集上進行預測。

第四步：驗證集及其預測用作構建新模型的特徵。

第五步：該新模型用於對測試集和元特徵(meta-features)進行最終預測。

示例代碼：

我們將在訓練集上建立兩個模型，決策樹和knn，以便對驗證集進行預測。

model1 = tree.DecisionTreeClassifier()

model1.fit(x_train, y_train)

val_pred1=model1.predict(x_val)

test_pred1=model1.predict(x_test)

val_pred1=pd.DataFrame(val_pred1)

test_pred1=pd.DataFrame(test_pred1)

model2 = KNeighborsClassifier()

model2.fit(x_train,y_train)

val_pred2=model2.predict(x_val)

test_pred2=model2.predict(x_test)

val_pred2=pd.DataFrame(val_pred2)

test_pred2=pd.DataFrame(test_pred2)

結合元特徵和驗證集，構建邏輯迴歸模型以對測試集進行預測。

df_val=pd.concat([x_val, val_pred1,val_pred2],axis=1)

df_test=pd.concat([x_test, test_pred1,test_pred2],axis=1)

model = LogisticRegression()

model.fit(df_val,y_val)

model.score(df_test,y_test)

3.3 Bagging

Bagging背後的想法是結合多個模型的結果（例如，所有決策樹）來獲得泛化的結果。這有一個問題：如果在同樣一組數據上創建所有模型並將其組合起來，它會有用嗎？這些模型極大可能會得到相同的結果，因為它們獲得的輸入相同。那我們該如何解決這個問題呢？其中一種技術是自舉(bootstrapping)。

Bootstrapping是一種採樣技術，我們有放回的從原始數據集上創建觀察子集，子集的大小與原始集的大小相同。

Bagging（或Bootstrap Aggregating）技術使用這些子集（包）來獲得分佈的完整概念（完備集）。為bagging創建的子集的大小也可能小於原始集。

第一步：從原始數據集有放回的選擇觀測值來創建多個子集。

第二步：在每一個子集上創建一個基礎模型（弱模型）。

第三步：這些模型同時運行，彼此獨立。

第四步：通過組合所有模型的預測來確定最終預測。

3.4 Boosting

在我們進一步討論之前，這裡有另一個問題：如果第一個模型錯誤地預測了某一個數據點，然後接下來的模型（可能是所有模型），將預測組合起來會提供更好的結果嗎？Boosting就是來處理這種情況的。

Boosting是一個順序過程，每個後續模型都會嘗試糾正先前模型的錯誤。後續的模型依賴於之前的模型。接下來一起看看boosting的工作方式：

第一步：從原始數據集創建一個子集。

第二步：最初，所有數據點都具有相同的權重。

第三步：在此子集上創建基礎模型。

第四步：該模型用於對整個數據集進行預測。

第五步：使用實際值和預測值計算誤差。

第六步：預測錯誤的點獲得更高的權重。（這裡，三個錯誤分類的藍色加號點將被賦予更高的權重）

第七步：創建另一個模型並對數據集進行預測（此模型嘗試更正先前模型中的錯誤）。

第八步：類似地，創建多個模型，每個模型校正先前模型的錯誤。

第九步：最終模型（強學習器）是所有模型（弱學習器）的加權平均值。

因此，boosting算法結合了許多弱學習器來形成一個強學習器。單個模型在整個數據集上表現不佳，但它們在數據集的某些部分上表現很好。因此，每個模型實際上提升了集成的整體性能。

四、基於Bagging和Boosting的算法

Bagging和Boosting是機器學習中最常用的兩種技術。在本節中，我們將詳細介紹它們。以下是我們將關注的算法：

Bagging 算法:

• Bagging meta-estimator
• 隨機森林

Boosting算法：

• AdaBoost
• GBM
• XGBM
• Light GBM
• CatBoost

對於本節中討論的所有算法，我們將遵循以下順序：

• 算法介紹
• 示例代碼
• 參數

本文中，我使用了貸款預測問題。你可以從此處下載數據集。請注意，對於每種算法，某些代碼（讀取數據，劃分訓練測試集等）將是相同的。為了避免重複，我在下面編寫了相同的代碼，並且只對算法相關的代碼進行進一步討論。

#importing important packages

import pandas as pd

import numpy as np

#reading the dataset

df=pd.read_csv("/home/user/Desktop/train.csv")

#filling missing values

df['Gender'].fillna('Male', inplace=True)

同理，對所有列進行值填充。本文只考慮所討論的主題，已跳過EDA，缺失值和異常值處理等步驟。要了解這些主題，可以閱讀此文：Ultimate guide for Data Explorationin Python using NumPy, Matplotlib and Pandas.

#split dataset into train and test

from sklearn.model_selection import train_test_split

train, test = train_test_split(df, test_size=0.3, random_state=0)

x_train=train.drop('Loan_Status',axis=1)

y_train=train['Loan_Status']

x_test=test.drop('Loan_Status',axis=1)

y_test=test['Loan_Status']

#create dummies

x_train=pd.get_dummies(x_train)

x_test=pd.get_dummies(x_test)

讓我們來探索bagging和boosting算法。

4.1 Bagging meta-estimator

Bagging meta-estimator是一種集成算法，可用於分類(BaggingClassifier)和迴歸(BaggingRegressor)問題。它採用典型的bagging技術進行預測。以下是Bagging meta-estimator算法的步驟：

第一步：從原始數據集（Bootstrapping）創建隨機子集。

第二步：數據集的子集包括所有特徵。

第三步用戶指定的基礎估計器在這些較小的集合上擬合。

第四步：將每個模型的預測結合起來得到最終結果。

示例代碼：

from sklearn.ensemble import BaggingClassifier

from sklearn import tree

model = BaggingClassifier(tree.DecisionTreeClassifier(random_state=1))

model.fit(x_train, y_train)

model.score(x_test,y_test)

0.75135135135135134

迴歸問題示例代碼：

from sklearn.ensemble import BaggingRegressor

model = BaggingRegressor(tree.DecisionTreeRegressor(random_state=1))

model.fit(x_train, y_train)

model.score(x_test,y_test)

算法中用到的參數：

• base_estimator
• 定義了在隨機子集上擬合所用的基礎估計器
• 沒有指明時，默認使用決策樹
• n_estimators
• 創建的基礎估計器數量
• 要小心微調這個參數，因為數字越大運行時間越長，相反太小的數字可能無法提供最優結果
• max_samples
• 該參數控制子集的大小
• 它是訓練每個基礎估計器的最大樣本數量
• max_features
• 控制從數據集中提取多少個特徵
• 它是訓練每個基礎估計器的最大特徵數量
• n_jobs
• 同時運行的job數量
• 將這個值設為你係統的CPU核數
• 如果設為-1，這個值會被設為你係統的CPU核數
• random_state
• 定義了隨機分割的方法。當兩個模型的random_state值一樣時，它們的隨機選擇也一樣
• 如果你想對比不同的模型，這個參數很有用

4.2 隨機森林

隨機森林是另一種遵循bagging技術的集成機器學習算法。它是bagging-estimator算法的擴展。隨機森林中的基礎估計器是決策樹。與bagging meta-estimator不同，隨機森林隨機選擇一組特徵，這些特徵用於決定決策樹的每個節點處的最佳分割。

隨機森林的具體步驟如下:

第一步：從原始數據集（Bootstrapping）創建隨機子集。

第二步：在決策樹中的每個節點處，僅考慮一組隨機特徵來決定最佳分割。

第三步：在每個子集上擬合決策樹模型。

第四步：通過對所有決策樹的預測求平均來計算最終預測。

注意：隨機林中的決策樹可以構建在數據和特徵的子集上。特別地，sklearn中的隨機森林使用所有特徵作為候選，並且候選特徵的隨機子集用於在每個節點處分裂。

總而言之，隨機森林隨機選擇數據點和特徵，並構建多個樹（森林）。

示例代碼：

from sklearn.ensemble import RandomForestClassifier

model= RandomForestClassifier(random_state=1)

model.fit(x_train, y_train)

model.score(x_test,y_test)

0.77297297297297296

你可以通過在隨機林中使用model.feature_importances_來查看特徵重要性。

for i, j in sorted(zip(x_train.columns, model.feature_importances_)):

print(i, j)

結果如下：

ApplicantIncome 0.180924483743

CoapplicantIncome 0.135979758733

Credit_History 0.186436670523

.

.

.

Property_Area_Urban 0.0167025290557

Self_Employed_No 0.0165385567137

Self_Employed_Yes 0.0134763695267

迴歸問題示例代碼：

from sklearn.ensemble import RandomForestRegressor

model= RandomForestRegressor()

model.fit(x_train, y_train)

model.score(x_test,y_test)

參數：

• n_estimators
• 定義隨機森林中要創建的決策樹數量
• 通常，越高的值會讓預測更強大更穩定，但是過高的值會讓訓練時間很長
• criterion
• 定義了分割用的函數
• 該函數用來衡量使用每個特徵分割的質量從而選擇最佳分割
• max_features
• 定義了每個決策樹中可用於分割的最大特徵數量
• 增加最大特徵數通常可以改善性能，但是一個非常高的值會減少各個樹之間的差異性
• max_depth
• 隨機森林有多個決策樹，此參數定義樹的最大深度
• min_samples_split
• 用於在嘗試拆分之前定義葉節點中所需的最小樣本數
• 如果樣本數小於所需數量，則不分割節點
• min_samples_leaf
• 定義了葉子節點所需的最小樣本數
• 較小的葉片尺寸使得模型更容易捕獲訓練數據中的噪聲
• max_leaf_nodes
• 此參數指定每個樹的最大葉子節點數
• 當葉節點的數量變得等於最大葉節點時，樹停止分裂
• n_jobs
• 這表示並行運行的作業數
• 如果要在系統中的所有核心上運行，請將值設置為-1
• random_state
• 此參數用於定義隨機選擇
• 它用於各種模型之間的比較

4.3 AdaBoost

自適應增強或AdaBoost是最簡單的boosting算法之一。通常用決策樹來建模。創建多個順序模型，每個模型都校正上一個模型的錯誤。AdaBoost為錯誤預測的觀測值分配權重，後續模型來正確預測這些值。

以下是執行AdaBoost算法的步驟：

第一步：最初，數據集中的所有觀察值都具有相同的權重。

第二步：在數據子集上建立一個模型。

第三步：使用此模型，可以對整個數據集進行預測。

第四步：通過比較預測值和實際值來計算誤差。

第五步：在創建下一個模型時，會給預測錯誤的數據點賦予更高的權重。

第六步：可以使用誤差值確定權重。例如，誤差越大，分配給觀察值的權重越大。

第七步：重複該過程直到誤差函數沒有改變，或達到估計器數量的最大限制。

示例代碼：

from sklearn.ensemble import AdaBoostClassifier

model = AdaBoostClassifier(random_state=1)

model.fit(x_train, y_train)

model.score(x_test,y_test)

0.81081081081081086

迴歸問題示例代碼：

from sklearn.ensemble import AdaBoostRegressor

model = AdaBoostRegressor()

model.fit(x_train, y_train)

model.score(x_test,y_test)

參數：

• base_estimators
• 它用於指定基礎估計器的類型，即用作基礎學習器的機器學習算法
• n_estimators
• 它定義了基礎估計器的數量
• 默認值為10，但可以設為較高的值以獲得更好的性能
• learning_rate
• 此參數控制估計器在最終組合中的貢獻
• 在learning_rate和n_estimators之間需要進行權衡
• max_depth
• 定義單個估計器的最大深度
• 調整此參數以獲得最佳性能
• n_jobs
• 指定允許使用的處理器數
• 將值設為-1，可以使用允許的最大處理器數量
• random_state
• 用於指定隨機數據拆分的整數值
• 如果給出相同的參數和訓練數據，random_state的確定值將始終產生相同的結果

4.4 Gradient Boosting（梯度提升GBM）

Gradient Boosting或GBM是另一種集成機器學習算法，適用於迴歸和分類問題。GBM使用boosting技術，結合了許多弱學習器，以形成一個強大的學習器。迴歸樹用作基礎學習器，每個後續的樹都是基於前一棵樹計算的錯誤構建的。

我們將使用一個簡單的例子來理解GBM算法。我們會使用以下數據預測一群人的年齡：

第一步：假設平均年齡是數據集中所有觀測值的預測值。

第二步：使用該平均預測值和年齡的實際值來計算誤差：

第三步：使用上面計算的誤差作為目標變量創建樹模型。我們的目標是找到最佳分割以最小化誤差。

第四步：該模型的預測與預測1相結合：

第五步：上面計算的這個值是新的預測。

第六步：使用此預測值和實際值計算新誤差：

第七步：重複步驟2到6，直到最大迭代次數（或誤差函數不再改變）

示例代碼：

from sklearn.ensemble import GradientBoostingClassifier

model= GradientBoostingClassifier(learning_rate=0.01,random_state=1)

model.fit(x_train, y_train)

model.score(x_test,y_test)

0.81621621621621621

迴歸問題示例代碼：

from sklearn.ensemble import GradientBoostingRegressor

model= GradientBoostingRegressor()

model.fit(x_train, y_train)

model.score(x_test,y_test)

參數：

• min_samples_split
• 定義考慮被拆分的節點中所需的最小樣本數（或觀察值數）
• 用於控制過配合。較高的值會阻止模型學習關係，這種關係可能對為一棵樹選擇的特定樣本高度特定
• min_samples_leaf
• 定義終端或葉節點中所需的最小樣本數
• 一般來說，應該為不平衡的分類問題選擇較低的值，因為少數群體佔大多數的地區將非常小
• min_weight_fraction_leaf
• 與min_samples_leaf類似，但定義為觀察總數的一個比例而不是整數
• max_depth
• 樹的最大深度。
• 用於控制過擬合，因為更高的深度將讓模型學習到非常特定於某個樣本的關係
• 應該使用CV進行調整
• max_leaf_nodes
• 樹中終端節點或葉子的最大數量
• 可以用於代替max_depth。由於創建了二叉樹，因此深度'n'將產生最多2 ^ n個葉子
• 如果它被定義，則GBM會忽略max_depth
• max_features
• 搜索最佳拆分時要考慮的特徵數量。這些特徵將被隨機選擇。
• 作為一個經驗法則，特徵總數的平方根效果很好，但我們可以嘗試直到特徵總數的30-40％。
• 較高的值可能導致過度擬合，但通常取決於具體情況。

4.5 XGBoost

XGBoost（extreme Gradient Boosting）是梯度提升算法的高級實現。實踐證明，XGBoost是一種高效的ML算法，廣泛應用於機器學習競賽和黑客馬拉松。 XGBoost具有很高的預測能力，幾乎比其他梯度提升技術快10倍。它還包括各種正規化，可減少過擬合併提高整體性能。因此，它也被稱為“正則化提升”技術。

讓我們看看XGBoost為何比其他技術更好：

• 正則化：
• 標準GBM實現沒有像XGBoost那樣的正則化
• 因此，XGBoost還有助於減少過擬合
• 並行處理：
• XGBoost實現並行處理，並且比GBM更快
• XGBoost還支持Hadoop上的實現
• 高靈活性：
• XGBoost允許用戶自定義優化目標和評估標準，為模型添加全新維度
• 處理缺失值：
• XGBoost有一個內置的例程來處理缺失值
• 樹剪枝：
• XGBoost先進行分割，直到指定的max_depth，然後開始向後修剪樹並刪除沒有正向增益的分割
• 內置交叉驗證：
• XGBoost允許用戶在提升過程的每次迭代中運行交叉驗證，因此很容易在一次運行中獲得精確的最佳提升迭代次數

示例代碼：

由於XGBoost會自行處理缺失值，因此你不必再處理。你可以跳過上述代碼中缺失值插補的步驟。如下展示瞭如何應用xgboost：

import xgboost as xgb

model=xgb.XGBClassifier(random_state=1,learning_rate=0.01)

model.fit(x_train, y_train)

model.score(x_test,y_test)

0.82702702702702702

迴歸問題示例代碼：

import xgboost as xgb

model=xgb.XGBRegressor()

model.fit(x_train, y_train)

model.score(x_test,y_test)

參數：

• nthread
• 這用於並行處理，應輸入系統中的核心數
• 如果你希望在所有核心上運行，請不要輸入此值。該算法將自動檢測
• eta
• 類似於GBM中的學習率
• 通過縮小每一步的權重，使模型更加健壯
• min_child_weight
• 定義子節點中所有觀察值的最小權重和
• 用於控制過擬合。較高的值會阻止模型學習關係，這種關係可能高度特定於為某個樹所選的具體樣本
• max_depth
• 它用於定義最大深度
• 更高的深度將讓模型學習到非常特定於某個樣本的關係
• max_leaf_nodes
• 樹中終端節點或葉子的最大數量
• 可以用來代替max_depth。由於創建了二叉樹，因此深度'n'將產生最多2 ^ n個葉子
• 如果已定義，則GBM將忽略max_depth
• gamma
• 僅當產生的分割能給出損失函數的正向減少時，才分割節點。Gamma指定進行分割所需的最小損失減少量。
• 使算法保守。值可能會根據損失函數而有所不同，因此應進行調整
• subsample
• 與GBM的子樣本相同。表示用於每棵樹隨機採樣的觀察值的比例。
• 較低的值使算法更加保守並防止過擬合，但是太小的值可能導致欠擬合。
• colsample_bytree
• 它類似於GBM中的max_features
• 表示要為每個樹隨機採樣的列的比例

4.6 Light GBM

在討論Light GBM如何工作之前，先理解為什麼在我們有如此多其他算法時（例如我們上面看到的算法）我們還需要這個算法。當數據集非常大時，Light GBM會擊敗所有其他算法。與其他算法相比，Light GBM在較大的數據集上運行所需的時間較短。

LightGBM是一個梯度提升框架，它使用基於樹的算法並遵循逐葉子的方式（leaf-wise），而其他算法以逐層級（level-wise）模式工作。下圖幫助你更好地理解二者差異：

逐葉子方式可能在較小的數據集上導致過擬合，但可以通過使用'max_depth'參數來避免這種情況。你可以在本文中閱讀有關Light GBM及其與XGB比較的更多信息。

示例代碼：

import lightgbm as lgb

train_data=lgb.Dataset(x_train,label=y_train)

#define parameters

params = {'learning_rate':0.001}

model= lgb.train(params, train_data, 100)

y_pred=model.predict(x_test)

for i in range(0,185):

if y_pred[i]>=0.5:

y_pred[i]=1

else:

y_pred[i]=0

0.81621621621621621

迴歸問題示例代碼：

import lightgbm as lgb

train_data=lgb.Dataset(x_train,label=y_train)

params = {'learning_rate':0.001}

model= lgb.train(params, train_data, 100)

from sklearn.metrics import mean_squared_error

rmse=mean_squared_error(y_pred,y_test)**0.5

參數：

• num_iterations
• 它定義了要執行的提升迭代次數
• num_leaves
• 此參數用於設置要在樹中形成的葉子數
• 在Light GBM的情況下，由於拆分是按逐葉子方式而不是深度方式進行的，因此num_leaves必須小於2 ^（max_depth），否則可能導致過擬合
• min_data_in_leaf
• 非常小的值可能導致過擬合
• 它也是處理過擬合的最重要的參數之一
• max_depth
• 它指定樹可以生長到的最大深度或級別
• 此參數的值非常高可能會導致過擬合
• bagging_fraction
• 它用於指定每次迭代使用的數據比例
• 此參數通常用於加速訓練
• max_bin
• 定義特徵值將被分桶的最大分箱數
• 較小的max_bin值可以節省大量時間，因為它在離散分箱中存儲特徵值，這在計算開銷上是便宜的

4.7 CatBoost

處理類別型變量是一個繁瑣的過程，尤其是你有大量此類變量時。當你的類別變量有很多標籤（即它們是高度基數）時，對它們執行one-hot編碼會指數級的增加維度，會讓數據集的使用變得非常困難。

CatBoost可以自動處理類別型變量，並且不需要像其他機器學習算法那樣進行大量數據預處理。這篇文章詳細解釋了CatBoost。

示例代碼：

CatBoost算法有效地處理類別型變量。因此，無需對變量執行one-hot編碼。只需加載文件，估算缺失值，就可以了：

from catboost import CatBoostClassifier

model=CatBoostClassifier()

categorical_features_indices = np.where(df.dtypes != np.float)[0]

model.fit(x_train,y_train,cat_features=([ 0, 1, 2, 3, 4, 10]),eval_set=(x_test, y_test))

model.score(x_test,y_test)

0.80540540540540539

迴歸問題示例代碼：

from catboost import CatBoostRegressor

model=CatBoostRegressor()

categorical_features_indices = np.where(df.dtypes != np.float)[0]

model.fit(x_train,y_train,cat_features=([ 0, 1, 2, 3, 4, 10]),eval_set=(x_test, y_test))

model.score(x_test,y_test)

參數：

• loss_function
• 定義用於訓練的度量標準
• iterations
• 可以構建最多多少棵樹
• 樹的最終數量可能小於或等於此數字
• learning_rate
• 定義學習率
• 用於減少梯度步驟
• border_count
• 它指定數值型特徵的拆分數
• 它類似於max_bin參數
• depth
• 定義樹的深度
• random_seed
• 此參數類似於我們之前看到的'random_state'參數
• 它是一個整數值，用於定義訓練的隨機種子

現在來到了集成算法這一章節的末尾。我們在這篇文章中已經涵蓋了很多內容！

結語

集成模型可以指數級地提升模型的性能，有時可以成為第一名和第二名之間的決定因素！在本文中，我們介紹了各種集成學習技術，並瞭解了這些技術如何應用於機器學習算法。此外，我們在貸款預測數據集上運用了算法。

本文為你提供了此主題的紮實理解。如果還有任何建議或問題，請分享在下面的評論部分。此外，我鼓勵你實現這些算法，並與我們分享你的結果！

原文標題：

A Comprehensive Guide to Ensemble Learning(with Python codes)

原文鏈接：

https://www.analyticsvidhya.com/blog/2018/06/comprehensive-guide-for-ensemble-models/

譯者簡介

和中華，留德軟件工程碩士。由於對機器學習感興趣，碩士論文選擇了利用遺傳算法思想改進傳統kmeans。目前在杭州進行大數據相關實踐。加入數據派THU希望為IT同行們儘自己一份綿薄之力，也希望結交許多志趣相投的小夥伴。

運營人員：冉小山

閱讀更多 THU數據派 的文章

關鍵字: 本文 隨機森林 丁楠雅