從基礎到實現：整合學習綜合教程（附Python程式碼）

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

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

本文的目的是介紹整合學習的概念並理解使用這種技術的演算法。為了鞏固你對這個多元化主題的理解，我們將用真實問題的動手案例，配合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 演算法:

• 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，缺失值和異常值處理等步驟。

#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 AdaBoostClassifierfrom 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'引數

• 它是一個整數值，用於定義訓練的隨機種子

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

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

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

相關報導：

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