[譯] 一份完備的整合學習手冊（附 Python 程式碼）

摘要： 原文作者：AISHWARYA SINGH 編譯：紅色石頭 引言 ： 試想一下，當你想買一輛新車時，你會直接走到第一家汽車商店，並根據經銷商的建議購買一輛車嗎？這顯然不太可能。 你可能會瀏覽一些入口網站，在那裡檢視人們對於不同車型的比較和評論，瞭解它們的特點和價格。你...

原文作者：AISHWARYA SINGH

編譯：紅色石頭

引言 ：

試想一下，當你想買一輛新車時，你會直接走到第一家汽車商店，並根據經銷商的建議購買一輛車嗎？這顯然不太可能。

你可能會瀏覽一些入口網站，在那裡檢視人們對於不同車型的比較和評論，瞭解它們的特點和價格。你也可能會向朋友和同事徵求一下他們的意見。簡而言之，你不會直接給出一個結論，而是會綜合考慮其他人的意見再做出決定。

機器學習中的整合模型（Ensemble Models）採用了類似的思想。整合模型結合多個模型的決策，以提高整體效能。這可以通過多種方式來實現，本文將一一介紹。

本文的目的是介紹整合學習的概念，並理解使用這種技術的演算法。為了加強您對不同演算法的理解，我們將對實際問題的案例使用 Python 來解釋這些高階演算法。

注意：弄懂本文需要對機器學習演算法有一個基本的瞭解，我建議你通過這篇文章來熟悉一些基本概念：

ofollow,noindex"> 一份機器學習的自白書

目錄：

1. 整合學習簡介

2. 基本的整合技術

   2.1 最大化

2.2 平均化


2.3 加權平均

3. 高階整合技術

3.1 Stacking

3.2 Blending

3.3 Bagging

3.4 Boosting

4. 基於 Bagging 和 Boosting 的演算法

4.1 Bagging meta-estimator

4.2 Random Forest

4.3 AdaBoost

4.4 GBM

4.5 XGB

4.6 Light GBM

4.7 CatBoost

1. 整合學習簡介

讓我們通過一個例子來理解整合學習的概念。假設你是一個電影導演，你對一個非常重要和有趣的話題都創作了一部電影短片。現在，你想在公映之前對這部電影進行初步的反饋（打分）。該怎麼做呢？

A: 你可以諮詢一個好朋友來對電影進行打分

這種方法完全有可能會出現一種情況，就是電影很糟糕，但是你的好朋友不忍心傷你的心，因此不會打一星。

B: 你可以諮詢 5 位同事來對電影進行打分

這種方法要好些，可以為你的電影提供較誠實的評價。但問題依然存在，這 5 個人可能不是該電影主題的專家，雖然他們可能知道攝影、鏡頭、音訊等一些電影知識。

C: 你可以諮詢 50 個人來對電影進行打分

其中一些可能是你的朋友，有些可能是你的同事，有些甚至可能是陌生人。

這種打分方法，反應會更加普遍和多樣化，因為打分的人更多更多樣了。事實證明，相比 A 和 B，C 更加科學。

通過這些例子，你可以推斷出相比一個人的意見，綜合多個人的意見可能做出更好的決定。這個例子對於多模型和單模型的比較也是成立的。機器學習中的這種多樣化是通過一種稱為整合學習的技術實現的。

現在，你已經掌握了整合學習的要點。接下來讓我們看看整合學習中的各種技術及其實現方法。

2. 基本的整合技術

在本節中，我們將介紹一些簡單但功能強大的技術：

• 最大化

• 平均化

• 加權平均

2.1 最大化

最大化通常用於分類問題。這種技術，所有模型都對該例項進行預測，每個模型的預測都可以看成是一次投票。獲得投票數最多的那一類別就是最終的預測結果。

例如剛才的例子，5 個同事給你的電影打分，其中 3 人打了 5 星，2 人打了 4 星。則根據最大化原則，打 5 星的人數更多，最終判斷電影評分為 5 星。

示例程式碼：

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 個同事給你的電影打分，其中 3 人打了 5 星，2 人打了 4 星。則根據平均化原則，計算最終打分為：

(5 + 5 + 5 + 4 + 4) / 5 = 4.6

示例程式碼：

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 加權平均

這是平均化方法的一個擴充套件，所有的模型被賦予不同的權重（定義為在預測中不同模型所佔的重要性）。例如，如果你的兩個同事在這方面比較專業，那麼他們兩人的意見所佔的比重就更大一些。假設這兩人佔的比重均為 0.23，其他三人佔的比重均為 0.18，則加權平均後的結果為：

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. 高階整合技術

上文我們已經瞭解了基本的整合技術，接下來將介紹一下高階的整合技術。

3.1 Stacking

Stacking 是使用多個模型（例如決策樹、KNN、SVM）來構建新的模型的整合技術。該模型在測試集上進行預測。下面是一個簡單的 Stacking 整合的詳細步驟解釋。

1）將訓練集劃分為 10 個子集。

2）在其中 9 個子集上訓練一個基本模型（例如決策樹模型），在第 10 個子集上進行測試。遍歷每個子集，重複進行 10 次。得到的 DT 長度與 Train set 相同。

3）在整個訓練集上使用該模型（決策樹）進行建模。

4）使用建模的模型在測試集上進行測試。

5）使用另一種演算法（例如 knn），重複步驟 2～4，作用在 Train set 和 Test set 上，得到另一組值。

6）使用得到的 DT 和 knn 組合作為新的特徵 TRAIN PREDICTION SET，訓練新的模型（例如邏輯迴歸）。

7）使用訓練好的模型對 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)

最後，使用邏輯迴歸，進行訓練和預測。

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)

為了將問題簡單化，我們所建立的 Stacking 模型只有兩層。第一層是建立決策樹和 knn 模型，第二層是建立邏輯迴歸模型。實際應用中可以使用多個層次的複雜結構。

3.2 Blending

Blending 與 Stacking 類似，但是僅從訓練集上劃分一部分作為 holdout（驗證集），沒有使用 k 折驗證。Holdout 集結果作為下一層的訓練資料。下面是 Blending 的詳細步驟解釋。

1）將所有的訓練資料劃分為訓練集和驗證集。

2）在訓練集上訓練模型。

3）在驗證集和整體測試集上進行模型測試。

4）驗證集和測試結果作為元特徵，進行第二層的模型訓練。

5）使用該模型在整體測試集的元特徵上進行模型驗證。

示例程式碼：

首先，我們在訓練集上訓練兩個模型：決策樹和 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）技術使用這些子集（bags）來得到一個相對公平的分佈（完全集）。子集的大小也可能少於原始集。

1）從原始資料集中建立多個子集，有放回地進行取樣。

2）在每個子集上訓練一個基本模型（弱模型）。

3）這些模型相互平行且獨立。

4）最後的預測結果由所有模型共同決定。

3.4 Boosting

在我們進一步討論之前，還有一個問題：如果一個數據點被第一個模型預測錯誤，那麼下一個模型（可能是所有的模型）組合預測會預測正確嗎？這樣的情況可以通過 boosting 來處理。

Boosting 是一個循序漸進的過程，其中每一個後續模型都試圖糾正前一個模型的錯誤。後一個模型依賴於先前的模型。下面讓我們來了解 Boosting 的工作方式。

1）從原始資料集中建立一個子集。

2）起始狀態，所有資料點都賦予相同的權重。

3）在這個子集上訓練一個基本模型。

4）使用該模型在整個資料集上進行預測。

5）根據實際值和預測值計算誤差。

6）對預測錯誤的資料點給予更高的權重（如上圖中預測錯誤的藍色的“+”將賦予更大的權重）。

7）在此資料集上訓練一個新的模型並預測（該模型試圖糾正上一個模型中的錯誤點）。

Line"/>

8）類似地建立多個模型，每個模型校正前一個模型的錯誤。

9）最終的模型（強學習器）是所有模型（弱學習器）的加權平均。

因此，Boosting 演算法結合了一些弱學習器，形成一個強大的學習器。單個模型在整個資料集上表現不好，但是它們在部分資料集上可能表現得很好。因此，每個模型實際上提升了集合的效能。

4.  基於 Bagging 和 Boosting 的演算法

Bagging 和 Boosting 是機器學習中最常用的兩種技術。在這一節中，我們將詳細地研究它們。以下是我們將重點研究的演算法：

Bagging 演算法：

• Bagging 元估計

• 隨機森林

Boosting 演算法：

• AdaBoost

• GBM

• XGBM

• Light

• GBM

• CatBoost

或者在本節中討論的所有演算法，我們將遵循這個過程：

• 演算法介紹

• 示例程式碼

• 引數

這篇文章中，我將討論貸款預測問題。您可以從這裡下載資料集：

https://datahack.analyticsvidhya.com/contest/practice-problem-loan-prediction-iii/

請注意，對於每個演算法，一些程式碼（讀取資料、分割訓練集、測試集等）是相同的。為了避免重複，我已經在下面寫下這些相同的程式碼，之後只會深入討論演算法的核心程式碼。

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

類似地，關於資料填充、缺失值、異常值的處理，本文不做具體介紹。可參閱這篇文章瞭解相關內容：

https://www.analyticsvidhya.com/blog/2015/04/comprehensive-guide-data-exploration-sas-using-python-numpy-scipy-matplotlib-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 元估計

Bagging 元估計是一種整合演算法，可用於分類（BaggingClassifier）和迴歸（BaggingRegressor）問題。它遵循典型的 Bagging 技術進行預測。下面是 Bagging 元估計演算法的步驟：

1）從原始資料集中建立隨機子集（Bootstrapping）。

2）子集包含所有特徵。

3）使用者指定的基本估計器在這些子集上進行訓練。

4）每個模型的預測結合形成最終的結果。

程式碼：

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:

  並行執行的任務數量。將該值設定為與系統中的核心相等。 如果設定為 -1，任務數量等於核心數。

• random_state:

  它指定了隨機劃分的方法。當兩個模型的隨機狀態值相同時，它們的隨機選擇相同。比較不同的模型時，這個引數是有用的。
  

4.2 隨機森林

隨機森林遵循 Bagging 技術的另一種整合機器學習演算法。它是 Bagging 估計演算法的一個擴充套件。隨機森林中的基本學習器是決策樹。與 Bagging 元估計不同，隨機森林隨機選擇一組特徵，這些特徵用於在決策樹的每個節點處決定最佳分割。

隨機森林演算法的詳細步驟如下：

1） 從原始資料集中建立隨機子集（Bootstrapping）。

2）在決策樹中的每個節點，使用隨機特徵來決定最佳分割。

3）在每個子集上訓練一個決策樹模型。

4）最後的結果是對所有決策樹的預測計算平均值。

注：隨機森林中的決策樹可以建立在資料和特徵的子集上。特別地，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

自適應 Boosting（AdaBoost）是最簡單的 Boosting 演算法之一。通常，決策樹用於建模。順序建立多個模型，每個模型校正前一個模型的錯誤。AdaBoost 為上一個模型中預測錯誤的資料點分配更大的權重，在此模型工作以便能夠正確地預測。

下面是 AdaBoost 演算法的步驟：

1）最初，對資料集中的所有資料點賦予相同的權重。

2）在資料子集上建立模型。

3）使用該模型，對整個資料集進行預測。

4）通過比較預測值和實際值來計算誤差。

5）在建立下一個模型時，對預測不正確的資料點給出更高的權重。

6）可以使用誤差值確定權重。例如，誤差大的賦予更大的權重。

7）重複這個過程直到誤差函式不改變，或者達到學習器的最大數量。

程式碼：

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_estimator:

  它有助於指定基本估計器的型別，也就是說，被用作基礎學習器的 機器學習演算法 。

• n_estimators:

  它定義了基本學習器的數量。預設值為10，但應設定更大的值以獲得更好的效能。

• learning_rate:

  該引數控制最終組合中學習的貢獻率。learning_rate 和 n_estimators 之間需要權衡。

• max_depth:

  定義單個估計器的最大深度。調整此引數以獲得最佳效能。

• n_jobs:

  指定允許使用的處理器的數量。設定為 -1 時允許使用所有的處理器。

• random_state:

  它指定了隨機劃分的方法。如果給定相同的引數和訓練資料，相同的 random_state 值總會產生相同的結果。

4.4 Gradient Boosting (GBM)

梯度提升（GBM）是另一種整合機器學習演算法，它同時適用於迴歸和分類問題。GBM 使用提升技術，結合一些弱學習器形成一個強大的學習器。迴歸樹作為基礎學習器，每個後續的樹是建立在由前一棵樹計算的誤差上的。

我們將使用一個簡單的例子來理解 GBM 演算法。使用以下資料來預測一組人的年齡：

1）平均年齡被假定為在資料集中的所有觀察值的預測值。

2）使用該平均預測值和實際年齡值計算誤差。

3）使用上面計算的誤差作為目標變數建立樹模型。我們的目標是找到最佳的分割，以儘量減少誤差。

4）該模型的預測結果與 predicion1 相結合。

5）上面計算的值就是新的預測值。

6）利用該預測值和實際值計算新的誤差。

7）重複步驟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 倍。它還包括各種正則化技術減少過擬合來提高整體效能。因此，它也被稱為“regularized boosting”技術。

讓我們看看 XGBoost 是如何比其他技術更好的：

1） 正則化

標準 GBM 沒有像 XGBoost 那樣的正則化。因此 XGBoost 有助於減少過擬合。

2） 並行處理

XGBoost  實現並行處理，並且比 GBM 更快。 XGBoost  還支援在 Hadoop 上實現。

3） 高靈活性

XGBoost  允許使用者自定義優化目標和評價標準，為模型新增一個新的維度。

4） 處理缺失值

XGBoost 有一個內建功能來處理缺失值。

5） 樹修剪

XGBoost 進行分割到最大深度後，然後開始由下到上修剪樹，移除沒有正增益的分割。

6） 內建交叉驗證

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 指定了分裂所需的損失函式減少的最小值。使得演算法保守，gamma 可以根據損失函式而變化，並且應該除錯。

• subsample:

  與 GBM 的 subsample 相同。表示每個樹隨機取樣的資料點的分數。較低的值使演算法更保守，並防止過擬合，但值太小可能導致欠擬合。

• colsample_bytree :

  它與 GBM 中的  max_features  特徵相似。表示要為每個樹隨機抽樣的列的分數。

4.6 LightGBM

在討論 LightGBM 如何工作之前，讓我們先了解為什麼需要這個演算法。我們已經有這麼多 Boosting 演算法了（如上面介紹的），當資料集非常大時，Light GBM 則優於其它所有的演算法。與其他演算法相比，Light GBM 在巨大的資料集上執行所消耗的時間更少。

LightGBM 是一個梯度增強框架，它使用基於樹的演算法，並遵循 leaf-wise 方式，而其他演算法以 level-wise 方式工作。下面的圖片將幫助你更好地理解差異。

level-wise 在資料量少的時候 可能會導致過擬合，但是可以通過使用引數 max_depth 可以 避免這種情況發生。你可以閱讀下面的文章瞭解更多 Light GBM 及其與 XGB 的比較：

https://www.analyticsvidhya.com/blog/2017/06/which-algorithm-takes-the-crown-light-gbm-vs-xgboost/

程式碼：

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 :

  它定義要執行的 boosting 迭代數。

• num_leaves :

  此引數用於設定樹中要形成的葉子的數量。對於 Light GBM，由於分裂發生在 level-wise  方向而不是 depth-wise  方向，所以num_leaft必須小於 2 的 max_depth 次方，否則可能導致過擬合。

• min_data_in_leaf :

  該值過小可能導致過度擬合。它也是處理過擬合的最重要的引數之一。

• max_depth:

  定義樹可以生長的最大深度或高度。這個引數過大會導致過擬合。

• bagging_fraction :

  它用於指定每次迭代要使用的資料比例。這個引數通常用於加速訓練。

• max_bin :

  定義特徵值將被插入的容器的最大數目。較小的 max_bin 值可以節省大量時間，因為它將特徵值儲存到離散的容器中，計算代價小。

4.7 CatBoost

處理分類變數是一個乏味的過程，尤其有大量這樣的變數。當分類變數的標籤太多（例如高度基數）時，對它們進行獨熱編碼會指數地增加維度，這讓資料處理非常困難。

CatBoost 可以自動處理分類變數，並且不需要像其他機器學習演算法那樣進行額外的資料預處理。下面是一篇詳細介紹 CatBoost  的文章：

https://www.analyticsvidhya.com/blog/2017/08/catboost-automated-categorical-data/

程式碼：

CatBoost  演算法能有效地處理分類變數。因此，不需要對分類變數進行獨熱編碼。只需載入檔案，填入缺失值，就可以了。

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，它是一個整數， 定義用於訓練的隨機種子。

結語

集合建模可以指數地提高模型的效能！在本文中，我們介紹了各種整合學習技術，並瞭解了這些技術在機器學習演算法中的應用。此外，我們實現了我們的貸款預測資料集的演算法。

這篇文章將使你對這個話題有一個全面的瞭解。此外，鼓勵你自己動手實現這些演算法並與我們分享你的結果！

【推薦閱讀】

我的深度學習入門路線

【乾貨】我的機器學習入門路線圖