（搬運）XGBoost中參數調整的完整指南（包含Python中的代碼）

介紹

如果事情不適合預測建模，請使用XGboost。XGBoost算法已成為許多數據科學家的終極武器。它是一種高度復雜的算法，功能強大，足以處理各種不規則的數據。

使用XGBoost構建模型很容易。但是，使用XGBoost改進模型很困難（至少我很掙紮）。該算法使用多個參數。要改進模型，必須進行參數調整。很難得到像實際問題的答案 - 你應該調整哪一組參數？獲得最佳輸出的這些參數的理想值是多少？

本文最適合XGBoost新手。在本文中，我們將學習參數調整的技巧以及有關XGBoost的一些有用信息。

你應該知道什麽？

XGBoost（eXtreme Gradient Boosting）是梯度增強算法的高級實現。由於我在上一篇文章 - Gradient Boosting中的參數調整完整指南（GBM）中詳細介紹了Gradient Boosting Machine ，我強烈建議在進一步閱讀之前先仔細閱讀。它將幫助您加強對GBM的增強和參數調整的理解。

特別感謝：就個人而言，我要感謝Sudalai Rajkumar先生 （又名SRK）提供的永恒支持，目前是 AV等級2。沒有他的幫助，這篇文章是不可能的。他正在幫助我們指導數千名數據科學家。

目錄

1. XGBoost優勢
2. 了解XGBoost參數
3. 調整參數（帶示例）

1. XGBoost優勢

我一直很欽佩這種算法在預測模型中註入的增強功能。當我在高精度下探索更多有關其性能和科學的知識時，我發現了許多優點：

1. 正則：
   • 標準GBM實現沒有像XGBoost那樣的正則化，因此它也有助於減少過度擬合。
   • 實際上，XGBoost也被稱為“ 正則化增強 ”技術。
2. 並行處理：
   • XGBoost實現了並行處理，與GBM相比，速度更快。
   • 但請繼續，我們知道提升是順序進程，那麽它如何並行化呢？我們知道每棵樹只能在前一棵樹之後構建，那麽是什麽阻止我們使用所有核心制作樹？我希望你能得到我來自的地方。
     請查看此鏈接以進一步探索。
   • XGBoost還支持Hadoop上的實現。
3. 高靈活性
   • XGBoost允許用戶定義自定義優化目標和評估標準。
   • 這為模型增加了一個全新的維度，我們可以做的事情沒有限制。
4. 處理缺失值
   • XGBoost有一個內置的例程來處理缺失值。
   • 用戶需要提供與其他觀察值不同的值，並將其作為參數傳遞。XGBoost會嘗試不同的事情，因為它在每個節點上遇到缺失值，並了解將來丟失值的路徑。
5. 樹修剪：
   • 當GBM在分割中遇到負損失時，它將停止分割節點。因此，它更像是一種貪婪的算法。
   • 另一方面，XGBoost分割到指定的max_depth，然後開始向後修剪樹並刪除沒有正增益的分裂。
   • 另一個優點是，有時負損失的分裂表示-2後可能會出現正損失+10的分裂。GBM會在遇到-2時停止。但是XGBoost會更深入，它會看到分裂的+8和兩者的綜合效果。
6. 內置交叉驗證
   • XGBoost允許用戶在每次增強過程的叠代中運行交叉驗證，因此很容易在一次運行中獲得精確的最佳增強叠代次數。
   • 這與GBM不同，我們必須運行網格搜索，並且只能測試有限的值。
7. 繼續使用現有模型
   • 用戶可以從上一次運行的最後一次叠代開始訓練XGBoost模型。這在某些特定應用中具有顯著優勢。
   • sklearn的GBM實現也具有此功能，因此它們甚至在這一點上。

我希望你現在能理解XGBoost算法的強大功能。請註意，這些是我可以集合的要點。你知道更多嗎？隨意在下面發表評論，我會更新列表。

我有胃口嗎？好。您可以參考以下網頁以獲得更深入的了解：

• XGBoost指南 - Boosted Trees簡介
• 來自XGBoost作者的話 [視頻]

2. XGBoost參數

XGBoost作者將整體參數分為3類：

1. 一般參數： 指導整體功能
2. 助推器參數： 在每個步驟指導個體助推器（樹/回歸）
3. 學習任務參數： 指導執行的優化

我將在這裏對GBM進行類比，並強烈建議閱讀本文 以從基礎知識中學習。

一般參數

這些定義了XGBoost的整體功能。

1. 助推器[默認= gbtree]
   • 選擇要在每次叠代時運行的模型類型。它有2個選項：
     • gbtree：基於樹的模型
     • gblinear：線性模型
2. 無聲[default = 0]：
   • 靜音模式激活設置為1，即不會打印正在運行的消息。
   • 保持0通常是好的，因為消息可能有助於理解模型。
3. nthread [默認為未設置的最大線程數]
   • 這用於並行處理，應輸入系統中的核心數
   • 如果您希望在所有核心上運行，則不應輸入值，並且算法將自動檢測

還有2個參數由XGBoost自動設置，您無需擔心它們。讓我們轉到Booster參數。

助推器參數

雖然有兩種類型的助推器，但我 在這裏只考慮 樹助推器，因為它總是優於線性助力器，因此後者很少使用。

1. eta [默認= 0.3]
   • 類似於GBM中的學習率
   • 通過縮小每一步的權重，使模型更加健壯
   • 使用的典型最終值：0.01-0.2
2. min_child_weight [default = 1]
   • 定義兒童所需觀察的最小權重總和。
   • 這類似於GBM中的min_child_leaf，但並不完全相同。這指的是觀察的最小“權重總和”，而GBM具有最小“觀察數”。
   • 用於控制過度擬合。較高的值會阻止模型學習關系，這種關系可能對為樹選擇的特定樣本高度特定。
   • 太高的值會導致欠擬合，因此應使用CV進行調整。
3. max_depth [default = 6]
   • 樹的最大深度，與GBM相同。
   • 用於控制過度擬合，因為更高的深度將允許模型學習非常特定於特定樣本的關系。
   • 應該使用CV進行調整。
   • 典型值：3-10
4. max_leaf_nodes
   • 樹中終端節點或葉子的最大數量。
   • 可以定義代替max_depth。由於創建了二叉樹，因此深度‘n‘將產生最多2 ^ n個葉子。
   • 如果已定義，則GBM將忽略max_depth。
5. gamma [default = 0]
   • 僅當結果分割給出損失函數的正減少時，才會分割節點。Gamma指定進行拆分所需的最小損失減少量。
   • 使算法保守。值可能會根據損耗函數而有所不同，因此應進行調整。
6. max_delta_step [default = 0]
   • 在最大增量步長中，我們允許每棵樹的權重估計。如果該值設置為0，則表示沒有約束。如果將其設置為正值，則可以幫助使更新步驟更加保守。
   • 通常不需要此參數，但當類非常不平衡時，它可能有助於邏輯回歸。
   • 這通常不使用，但如果您願意，可以進一步探索。
7. 子樣本[default = 1]
   • 與GBM的子樣本相同。表示觀察的比例是每棵樹的隨機樣本。
   • 較低的值使算法更加保守並防止過度擬合，但是太小的值可能導致不合適。
   • 典型值：0.5-1
8. colsample_bytree [default = 1]
   • 與GBM中的max_features類似。表示每個樹的隨機樣本列的分數。
   • 典型值：0.5-1
9. colsample_bylevel [default = 1]
   • 表示每個級別中每個拆分的列的子采樣率。
   • 我不經常使用它，因為subsample和colsample_bytree將為您完成這項工作。但如果你有這種感覺，你可以進一步探索。
10. lambda [default = 1]
    • 關於權重的L2正則項（類似於嶺回歸）
    • 這用於處理XGBoost的正則化部分。雖然許多數據科學家不經常使用它，但應該探索減少過度擬合。
11. alpha [默認= 0]
    • 關於權重的L1正則化項（類似於Lasso回歸）
    • 可以在非常高的維度的情況下使用，以便算法在實現時運行得更快
12. scale_pos_weight [default = 1]
    • 在高級別不平衡的情況下，應使用大於0的值，因為它有助於更??快收斂。

學習任務參數

這些參數用於定義要在每個步驟計算的度量的優化目標。

1. 客觀[default = reg：linear]
   • 這定義了要最小化的損失函數。最常用的值是：
     • binary：logistic -logistic回歸用於二進制分類，返回預測概率（不是類）
     • multi：使用softmax目標的softmax -multiclass分類，返回預測類（不是概率）
       • 您還需要設置一個額外的 num_class （類數）參數，用於定義唯一類的數量
     • multi：softprob -same as softmax，但返回屬於每個類的每個數據點的預測概率。
2. eval_metric [默認根據目標]
   • 用於驗證數據的度量標準。
   • 回歸的默認值為rmse，分類的誤差為rmse。
   • 典型值為：
     • rmse - 均方根誤差
     • mae - 平均絕對誤差
     • logloss - 負對數似然
     • 錯誤 - 二進制分類錯誤率（0.5閾值）
     • merror - 多類分類錯誤率
     • mlogloss - 多類logloss
     • auc： 曲線下面積
3. 種子[默認= 0]
   • 隨機數種子。
   • 可用於生成可重現的結果，也可用於參數調整。

如果您到目前為止一直在使用Scikit-Learn，那麽這些參數名稱可能看起來並不熟悉。一個好消息是python中的xgboost模塊有一個名為XGBClassifier的sklearn包裝器。它使用sklearn樣式命名約定。將更改的參數名稱為：

1. eta - > learning_rate
2. lambda - > reg_lambda
3. alpha - > reg_alpha

您必須想知道我們已經定義了除GBM中“n_estimators”參數之外的所有內容。那麽它作為XGBClassifier中的參數存在。但是，在標準xgboost實現中調用fit函數時，必須將其作為“num_boosting_rounds”傳遞。

我建議您閱讀xgboost指南的以下部分，以便更好地理解參數和代碼：

1. XGBoost參數（官方指南）
2. XGBoost演示代碼（xgboost GitHub存儲庫）
3. Python API參考（官方指南）

3.使用示例進行參數調整

我們將從Data Hackathon 3.x AV黑客馬拉松中獲取數據集，與GBM文章中的相同。問題的詳細信息可以在競賽頁面上找到。您可以從此處下載數據集。我執行了以下步驟：

1. 城市變量因類別太多而下降
2. DOB轉換為Age | DOB掉線了
3. EMI_Loan_Submitted_Missing已創建，如果EMI_Loan_Submitted缺失則為1，否則為0 | 原始變量EMI_Loan_Submitted掉線
4. 由於類別太多，EmployerName被刪除
5. Existing_EMI估算為0（中位數），因為只有111個值丟失
6. Interest_Rate_Missing創建，如果Interest_Rate丟失則為1，否則為0 | 原始變量Interest_Rate下降
7. Lead_Creation_Date被刪除，因為對結果的影響很小
8. Loan_Amount_Applied，Loan_Tenure_Applied用中值估算
9. 已創建Loan_Amount_Submitted_Missing，如果Loan_Amount_Submitted缺失則為1，否則為0 原始變量Loan_Amount_Submitted丟棄
10. 已創建Loan_Tenure_Submitted_Missing，如果Loan_Tenure_Submitted缺失則為1，否則為0 原始變量Loan_Tenure_Submitted丟棄
11. LoggedIn，Salary_Account下降了
12. 如果Processing_Fee丟失，則創建Processing_Fee_Missing為1，否則為0 | 原始變量Processing_Fee掉線
13. 來源 - 前2名保持不變，所有其他人合並為不同類別
14. 執行數字和單熱編碼

對於那些從競爭中獲得原始數據的人，您可以從存儲庫中的data_preparation iPython筆記本中查看這些步驟。

讓我們從導入所需的庫並加載數據開始：

 1 #Import libraries:
 2 import pandas as pd
 3 import numpy as np
 4 import xgboost as xgb
 5 from xgboost.sklearn import XGBClassifier
 6 from sklearn import cross_validation, metrics   #Additional scklearn functions
 7 from sklearn.grid_search import GridSearchCV   #Perforing grid search
 8 
 9 import matplotlib.pylab as plt
10 %matplotlib inline
11 from matplotlib.pylab import rcParams
12 rcParams[‘figure.figsize‘] = 12, 4
13 
14 train = pd.read_csv(‘train_modified.csv‘)
15 target = ‘Disbursed‘
16 IDcol = ‘ID‘

請註意，我已導入2種形式的XGBoost：

1. xgb - 這是直接的xgboost庫。我將使用此庫中的特定函數“cv”
2. XGBClassifier - 這是XGBoost的sklearn包裝器。這使得我們可以像對待GBM一樣使用sklearn的網格搜索和並行處理

在繼續之前，讓我們定義一個函數，它將幫助我們創建XGBoost模型並執行交叉驗證。最好的部分是您可以按原樣使用此功能，稍後將其用於您自己的模型。

 1 def modelfit(alg, dtrain, predictors,useTrainCV=True, cv_folds=5, early_stopping_rounds=50):
 2     
 3     if useTrainCV:
 4         xgb_param = alg.get_xgb_params()
 5         xgtrain = xgb.DMatrix(dtrain[predictors].values, label=dtrain[target].values)
 6         cvresult = xgb.cv(xgb_param, xgtrain, num_boost_round=alg.get_params()[‘n_estimators‘], nfold=cv_folds,
 7             metrics=‘auc‘, early_stopping_rounds=early_stopping_rounds, show_progress=False)
 8         alg.set_params(n_estimators=cvresult.shape[0])
 9     
10     #Fit the algorithm on the data
11     alg.fit(dtrain[predictors], dtrain[‘Disbursed‘],eval_metric=‘auc‘)
12         
13     #Predict training set:
14     dtrain_predictions = alg.predict(dtrain[predictors])
15     dtrain_predprob = alg.predict_proba(dtrain[predictors])[:,1]
16         
17     #Print model report:
18     print "\nModel Report"
19     print "Accuracy : %.4g" % metrics.accuracy_score(dtrain[‘Disbursed‘].values, dtrain_predictions)
20     print "AUC Score (Train): %f" % metrics.roc_auc_score(dtrain[‘Disbursed‘], dtrain_predprob)
21                     
22     feat_imp = pd.Series(alg.booster().get_fscore()).sort_values(ascending=False)
23     feat_imp.plot(kind=‘bar‘, title=‘Feature Importances‘)
24     plt.ylabel(‘Feature Importance Score‘)

參數調整的一般方法

我們將在這裏使用類似於GBM的方法。要執行的各個步驟是：

1. 選擇相對較高的學習率。通常學習率為0.1，但介於0.05到0.3之間，可能適用於不同的問題。確定此學習率的最佳樹木數量。XGBoost有一個非常有用的函數叫做“cv”，它在每次增強叠代時執行交叉驗證，從而返回所需的最佳樹數。
2. 調整樹特定參數 （max_depth，min_child_weight，gamma，subsample，colsample_bytree）以確定學習速率和樹木數量。請註意，我們可以選擇不同的參數來定義樹，我將在這裏舉一個例子。
3. 調整 xgboost的正則化參數（lambda，alpha），這有助於降低模型復雜性並提高性能。
4. 降低學習率並確定最佳參數。

讓我們看一個更詳細的一步一步的方法。

步驟1：修復學習率和用於調整基於樹的參數的估計量的數量

為了決定提升參數，我們需要設置其他參數的一些初始值。讓我們采取以下價值觀：

1. max_depth = 5 ：這應該在3-10之間。我從5開始，但你也可以選擇不同的數字。4-6可以是很好的起點。
2. min_child_weight = 1 ：選擇較小的值是因為它是一個高度不平衡的類問題，並且葉節點可以具有較小的大小組。
3. gamma = 0 ：也可以選擇較小的值如0.1-0.2來啟動。無論如何，這將在以後進行調整。
4. subsample，colsample_bytree = 0.8：這是一個常用的使用起始值。典型值介於0.5-0.9之間。
5. scale_pos_weight = 1：由於高級別的不平衡。

請註意，以上所有內容僅為初步估算值，稍後會進行調整。讓我們在這裏采用默認的學習率0.1，並使用xgboost的cv函數檢查樹的最佳數量。上面定義的函數將為我們完成。

 1 #Choose all predictors except target & IDcols
 2 predictors = [x for x in train.columns if x not in [target, IDcol]]
 3 xgb1 = XGBClassifier(
 4  learning_rate =0.1,
 5  n_estimators=1000,
 6  max_depth=5,
 7  min_child_weight=1,
 8  gamma=0,
 9  subsample=0.8,
10  colsample_bytree=0.8,
11  objective= ‘binary:logistic‘,
12  nthread=4,
13  scale_pos_weight=1,
14  seed=27)
15 modelfit(xgb1, train, predictors)

正如您所看到的，我們在這裏得到140作為0.1學習率的最佳估計。請註意，根據系統的功率，此值可能太高。在這種情況下，您可以提高學習率並重新運行命令以減少估算量。

註意：您將在此處的輸出中看到測試AUC為“AUC分數（測試）”。但是，如果您嘗試在系統上運行該命令，則不會出現這種情況，因為數據未公開。這裏提供的僅供參考。生成此輸出的代碼部分已在此處刪除。

第2步：調整max_depth和min_child_weight

我們先調整它們，因為它們對模型結果的影響最大。首先，讓我們設置更寬的範圍，然後我們將為更小的範圍執行另一次叠代。

重要說明：我將在本節中搜索一些重型網格，這可能需要15-30分鐘甚至更長的時間才能運行，具體取決於您的系統。您可以根據系統可以處理的內容來更改要測試的值的數量。

 1 param_test1 = { 
 2  ‘max_depth‘：range（3,10,2），
 3  ‘min_child_weight‘：range（1,6,2）
 4 } 
 5 gsearch1 = GridSearchCV（estimator = XGBClassifier（learning_rate = 0.1，n_estimators = 140，max_depth = 5，
 6  min_child_weight = 1，gamma = 0，subsample = 0.8，colsample_bytree = 0.8，
 7  objective =‘binary：logistic‘，nthread = 4，scale_pos_weight = 1，seed = 27），
 8  param_grid = param_test1，scoring =‘roc_auc‘，n_jobs = 4， iid = False，cv = 5）
 9 gsearch1.fit（train [predictors]，train [target]）
10 gsearch1.grid_scores_，gsearch1.best_params_，gsearch1.best_score_

在這裏，我們運行了12種組合，值之間的間隔更寬。理想值是5 MAX_DEPTH和5 min_child_weight。讓我們更進一步，尋找最佳價值。我們將搜索高於和低於最佳值的值1，因為我們間隔為2。

 1 param_test2 = { 
 2  ‘max_depth‘：[4,5,6]，
 3  ‘min_child_weight‘：[4,5,6] 
 4 } 
 5 gsearch2 = GridSearchCV（estimator = XGBClassifier（learning_rate = 0.1，n_estimators = 140，max_depth = 5，
 6  min_child_weight = 2） ，gamma = 0，subsample = 0.8，colsample_bytree = 0.8，
 7  objective =‘binary：logistic‘，nthread = 4，scale_pos_weight = 1，seed = 27），
 8  param_grid = param_test2，scoring =‘roc_auc‘，n_jobs = 4，iid = False，cv = 5）
 9 gsearch2.fit（train [predictors]，train [target]）
10 gsearch2.grid_scores_，gsearch2.best_params_，gsearch2.best_score_

在這裏，我們得到的最佳值是4 MAX_DEPTH和6 min_child_weight。此外，我們可以看到CV分數略有增加。請註意，隨著模型性能的提高，甚至難以實現性能上的邊際收益。您會註意到我們在這裏得到6作為min_child_weight的最佳值，但我們沒有嘗試超過6的值。我們可以這樣做：

 1 param_test2b = {
 2  ‘min_child_weight‘:[6,8,10,12]
 3 }
 4 gsearch2b = GridSearchCV(estimator = XGBClassifier( learning_rate=0.1, n_estimators=140, max_depth=4,
 5  min_child_weight=2, gamma=0, subsample=0.8, colsample_bytree=0.8,
 6  objective= ‘binary:logistic‘, nthread=4, scale_pos_weight=1,seed=27), 
 7  param_grid = param_test2b, scoring=‘roc_auc‘,n_jobs=4,iid=False, cv=5)
 8 gsearch2b.fit(train[predictors],train[target])
 9 modelfit(gsearch3.best_estimator_, train, predictors)
10 gsearch2b.grid_scores_, gsearch2b.best_params_, gsearch2b.best_score_

第3步：調整伽瑪

現在讓我們使用上面已調整的參數調整伽馬值。Gamma可以采用各種值，但我會在這裏檢查5個值。您可以進入更精確的值。

1 param_test3 = { 
2  ‘gamma‘：[i / 10.0 for i in range（0,5）] 
3 } 
4 gsearch3 = GridSearchCV（estimator = XGBClassifier（learning_rate = 0.1，n_estimators = 140，max_depth = 4，
5  min_child_weight = 6，gamma = 0， subsample = 0.8，colsample_bytree = 0.8，
6  objective =‘binary：logistic‘，nthread = 4，scale_pos_weight = 1，seed = 27），
7  param_grid = param_test3，scoring =‘roc_auc‘，n_jobs = 4，iid = False，cv = 5 ）
8 gsearch3.fit（train [predictors]，train [target]）
9 gsearch3.grid_scores_，gsearch3.best_params_，gsearch3.best_score_

這表明我們的伽瑪原始值，即0是最佳值。在繼續之前，一個好主意是重新校準更新參數的增強輪數。

 1 xgb2 = XGBClassifier（
 2  learning_rate = 0.1，
 3  n_estimators = 1000，
 4  max_depth = 4，
 5  min_child_weight = 6，
 6  gamma = 0，
 7  subsample = 0.8，
 8  colsample_bytree = 0.8，
 9  objective =‘binary：logistic‘，
10  nthread = 4，
11  scale_pos_weight = 1，
12  seed = 27）
13 modelfit（xgb2，train，predictors）

在這裏，我們可以看到得分的提高。所以最終的參數是：

• max_depth：4
• min_child_weight：6
• gamma：0

第4步：調整子樣本和colsample_bytree

下一步是嘗試不同的subsample和colsample_bytree值。讓我們分兩個階段進行，並且兩者的值均為0.6,0.7,0.8,0.9。

 1 param_test4 = { 
 2  ‘subsample‘：[i / 10.0 for i in range（6,10）]，
 3  ‘colsample_bytree‘：[i / 10.0 for i in range（6,10）] 
 4 } 
 5 gsearch4 = GridSearchCV（estimator = XGBClassifier（learning_rate） = 0.1，n_estimators = 177，max_depth = 4，
 6  min_child_weight = 6，gamma = 0，subsample = 0.8，colsample_bytree = 0.8，
 7  objective =‘binary：logistic‘，nthread = 4，scale_pos_weight = 1，seed = 27），
 8  param_grid = param_test4，scoring =‘roc_auc‘，n_jobs = 4，iid = False，cv = 5）
 9 gsearch4.fit（train [predictors]，train [target]）
10 gsearch4.grid_scores_，gsearch4.best_params_，gsearch4.best_score_

在這裏，我們發現0.8是 subsample和colsample_bytree 的最佳值。現在我們應該圍繞這些值嘗試0.05區間的值。

1 param_test5 = { 
2  ‘subsample‘：[i / 100.0 for i in range（75,90,5）]，
3  ‘colsample_bytree‘：[i / 100.0 for i in range（75,90,5）] 
4 } 
5 gsearch5 = GridSearchCV（estimator） = XGBClassifier（learning_rate = 0.1，n_estimators = 177，max_depth = 4，
6  min_child_weight = 6，gamma = 0，subsample = 0.8，colsample_bytree = 0.8，
7  objective =‘binary：logistic‘，nthread = 4，scale_pos_weight = 1，seed = 27 ），
8  param_grid = param_test5，scoring =‘roc_auc‘，n_jobs = 4，iid = False，cv = 5）
9 gsearch5.fit（train [predictors]，train [target]）

我們再次得到與以前相同的值。因此，最佳值為：

• 子樣本：0.8
• colsample_bytree：0.8

第5步：調整正則化參數

下一步是應用正則化來減少過度擬合。雖然很多人不會使用這些參數，因為伽瑪提供了一種控制復雜性的實質方法。但我們應該總是嘗試一下。我將在這裏調整‘reg_alpha‘值並讓你嘗試不同的‘reg_lambda‘值。

param_test6 = {
 ‘reg_alpha‘:[1e-5, 1e-2, 0.1, 1, 100]
}
gsearch6 = GridSearchCV(estimator = XGBClassifier( learning_rate =0.1, n_estimators=177, max_depth=4,
 min_child_weight=6, gamma=0.1, subsample=0.8, colsample_bytree=0.8,
 objective= ‘binary:logistic‘, nthread=4, scale_pos_weight=1,seed=27), 
 param_grid = param_test6, scoring=‘roc_auc‘,n_jobs=4,iid=False, cv=5)
gsearch6.fit(train[predictors],train[target])
gsearch6.grid_scores_, gsearch6.best_params_, gsearch6.best_score_

我們可以看到CV得分低於之前的情況。但是嘗試的值非常普遍，我們應該嘗試接近最優值的值（0.01），看看我們是否能得到更好的東西。

1 param_test7 = {
2  ‘reg_alpha‘:[0, 0.001, 0.005, 0.01, 0.05]
3 }
4 gsearch7 = GridSearchCV(estimator = XGBClassifier( learning_rate =0.1, n_estimators=177, max_depth=4,
5  min_child_weight=6, gamma=0.1, subsample=0.8, colsample_bytree=0.8,
6  objective= ‘binary:logistic‘, nthread=4, scale_pos_weight=1,seed=27), 
7  param_grid = param_test7, scoring=‘roc_auc‘,n_jobs=4,iid=False, cv=5)
8 gsearch7.fit(train[predictors],train[target])
9 gsearch7.grid_scores_, gsearch7.best_params_, gsearch7.best_score_

你可以看到我們得到了更好的簡歷。現在我們可以在模型中應用此正則化並查看影響：

 1 xgb3 = XGBClassifier（
 2  learning_rate = 0.1，
 3  n_estimators = 1000，
 4  max_depth = 4，
 5  min_child_weight = 6，
 6  gamma = 0，
 7  subsample = 0.8，
 8  colsample_bytree = 0.8，
 9  reg_alpha = 0.005，
10  objective =‘binary：logistic‘，
11  nthread = 4，
12  scale_pos_weight = 1，
13  種子= 27）
14 modelfit（xgb3，train，predictors）

我們再次看到分數略有改善。

第6步：降低學習率

最後，我們應該降低學習率並增加更多樹木。讓我們使用XGBoost的cv函數再次完成工作。

 1 xgb4 = XGBClassifier（
 2  learning_rate = 0.01，
 3  n_estimators = 5000，
 4  max_depth = 4，
 5  min_child_weight = 6，
 6  gamma = 0，
 7  subsample = 0.8，
 8  colsample_bytree = 0.8，
 9  reg_alpha = 0.005，
10  objective =‘binary：logistic‘，
11  nthread = 4，
12  scale_pos_weight = 1，
13  種子= 27）
14 modelfit（xgb4，train，predictors）

現在我們可以看到性能的顯著提升，參數調整的效果更加清晰。

在我們結束時，我想分享兩個關鍵想法：

1. 這是很難得到一個非常大的飛躍只要使用在性能參數整定或略好機型。GBM的最高得分為0.8487，而XGBoost得分為0.8494。這是一個不錯的改進，但不是非常重要的事情。
2. 通過特征工程，創建模型集合，堆疊等其他方法可以獲得顯著的跳躍

您也可以從我的GitHub帳戶下載包含所有這些型號代碼的iPython筆記本。對於R中的代碼，您可以參考這篇文章。

XGBoost中參數調整的完整指南（包含Python中的代碼）