机器学习系列(11)_Python中Gradient Boosting Machine(GBM）调参方法详解

╰半橙微兮° 2022-06-06 08:55 280阅读 0赞

# 机器学习系列(11)\_Python中Gradient Boosting Machine(GBM）调参方法详解 #

原文链接：http://blog.csdn.net/han\_xiaoyang/article/details/52663170

原创 2016年09月25日 17:33:34

*  标签：
 *  [python][] /
 *  [增强树][Link 1] /
 *  [GBM][] /
 *  [机器学习][Link 2] /
 *  [调参][Link 3]

原文地址：[Complete Guide to Parameter Tuning in Gradient Boosting (GBM) in Python][Complete Guide to Parameter Tuning in Gradient Boosting _GBM_ in Python] by Aarshay Jain  
原文翻译与校对：@酒酒Angie(drmr\_anki@qq.com) && [ 寒小阳][Link 4]（hanxiaoyang.ml@gmail.com）  
时间：2016年9月。  
出处：[http://blog.csdn.net/han\_xiaoyang/article/details/52663170][http_blog.csdn.net_han_xiaoyang_article_details_52663170]  
声明：版权所有，转载请联系作者并注明出

## **1.前言** ##

*如果一直以来你只把GBM当作黑匣子，只知调用却不明就里，是时候来打开这个黑匣子一探究竟了！*

这篇文章是受Owen Zhang (DataRobot的首席产品官，在Kaggle比赛中位列第三)在NYC Data Science Academy里提到的方法启发而成。他当时的演讲大约有2小时，我在这里取其精华，总结一下主要内容。

不像bagging算法只能改善模型高方差（high variance）情况，Boosting算法对同时控制偏差（bias）和方差都有非常好的效果，而且更加高效。如果你需要同时处理模型中的方差和偏差，认真理解这篇文章一定会对你大有帮助，因为我不仅会用Python阐明GBM算法，更重要的是会介绍如何对GBM调参，而恰当的参数往往能令结果大不相同。

*特别鸣谢：* 非常感谢Sudalai Rajkumar对我的大力帮助，他在AV Rank中位列第二。如果没有他的指导就不会有这篇文章了。

## **2.目录** ##

1.  Boosing是怎么工作的？
2.  理解GBM模型中的参数
3.  学会调参（附详例）

## **3.Boosting是如何工作的？** ##

Boosting可以将一系列弱学习因子（weak learners）相结合来提升总体模型的预测准确度。在任意时间t，根据t-1时刻得到的结果我们给当前结果赋予一个权重。之前正确预测的结果获得较小权重，错误分类的结果得到较大权重。回归问题的处理方法也是相似的。

让我们用图像帮助理解：

![图像][boosting.png]

1.  图一： 第一个弱学习因子的预测结果（从左至右）  
    
    
     *  一开始所有的点具有相同的权重（以点的尺寸表示）。
     *  分类线正确地分类了两个正极和五个负极的点。
2.  图二： 第二个弱学习因子的预测结果  
    
    
     *  在图一中被正确预测的点有较小的权重（尺寸较小），而被预测错误的点则有较大的权重。
     *  这时候模型就会更加注重具有大权重的点的预测结果，即上一轮分类错误的点，现在这些点被正确归类了，但其他点中的一些点却归类错误。

对图3的输出结果的理解也是类似的。这个算法一直如此持续进行直到所有的学习模型根据它们的预测结果都被赋予了一个权重，这样我们就得到了一个总体上更为准确的预测模型。

现在你是否对Boosting更感兴趣了？不妨看看下面这些文章（主要讨论GBM）：

*  [Learn Gradient Boosting Algorithm for better predictions (with codes in R)][Learn Gradient Boosting Algorithm for better predictions _with codes in R]
 *  [Quick Introduction to Boosting Algorithms in Machine Learning][]
 *  [Getting smart with Machine Learning – AdaBoost and Gradient Boost][Getting smart with Machine Learning _ AdaBoost and Gradient Boost]

## **4.GBM参数** ##

总的来说GBM的参数可以被归为三类：

1.  **树参数：**调节模型中每个决定树的性质
2.  **Boosting参数：**调节模型中boosting的操作
3.  **其他模型参数：**调节模型总体的各项运作

从树参数开始，首先一个决定树的大致结构是这样的：

![tree-infographic.png][]

现在我们看一看定义一个决定树所需要的参数。注意我在这里用的都是python里scikit-learn里面的术语，和其他软件比如R里用到的可能不同，但原理都是相同的。

1.  **min\_ samples\_split**  
    
    
     *  定义了树中一个节点所需要用来分裂的最少样本数。
     *  可以避免过度拟合(over-fitting)。如果用于分类的样本数太小，模型可能只适用于用来训练的样本的分类，而用较多的样本数则可以避免这个问题。
     *  但是如果设定的值过大，就可能出现欠拟合现象(under-fitting)。因此我们可以用CV值（离散系数）考量调节效果。
2.  **min\_ samples\_leaf**  
    
    
     *  定义了树中终点节点所需要的最少的样本数。
     *  同样，它也可以用来防止过度拟合。
     *  在不均等分类问题中(imbalanced class problems)，一般这个参数需要被设定为较小的值，因为大部分少数类别（minority class）含有的样本都比较小。
3.  **min\_ weight\_ fraction\_leaf**  
    
    
     *  和上面**min\_ samples\_ leaf**很像，不同的是这里需要的是一个比例而不是绝对数值：终点节点所需的样本数占总样本数的比值。
     *  \#2和\#3只需要定义一个就行了
4.  **max\_ depth**  
    
    
     *  定义了树的最大深度。
     *  它也可以控制过度拟合，因为分类树越深就越可能过度拟合。
     *  当然也应该用CV值检验。
5.  **max\_ leaf\_ nodes**  
    
    
     *  定义了决定树里最多能有多少个终点节点。
     *  这个属性有可能在上面max\_ depth里就被定义了。比如深度为n的二叉树就有最多2^n个终点节点。
     *  如果我们定义了max\_ leaf\_ nodes，GBM就会忽略前面的max\_depth。
6.  **max\_ features**  
    
    
     *  决定了用于分类的特征数，是人为随机定义的。
     *  根据经验一般选择总特征数的平方根就可以工作得很好了，但还是应该用不同的值尝试，最多可以尝试总特征数的30%-40%.
     *  过多的分类特征可能也会导致过度拟合。

在继续介绍其他参数前，我们先看一个简单的GBM二分类伪代码：

1. 初始分类目标的参数值
    2. 对所有的分类树进行迭代：
        2.1 根据前一轮分类树的结果更新分类目标的权重值（被错误分类的有更高的权重）
        2.2 用训练的子样本建模
        2.3 用所得模型对所有的样本进行预测
        2.4 再次根据分类结果更新权重值
    3. 返回最终结果
       
        
         1 
         2 
         3 
         4 
         5 
         6 
         7

以上步骤是一个极度简化的BGM模型，而目前我们所提到的参数会影响2.2这一步，即建模的过程。现在我们来看看影响boosting过程的参数：

1.  **learning\_ rate**  
    
    
     *  这个参数决定着每一个决定树对于最终结果（步骤2.4）的影响。GBM设定了初始的权重值之后，每一次树分类都会更新这个值，而learning\_ rate控制着每次更新的幅度。
     *  一般来说这个值不应该设的比较大，因为较小的learning rate使得模型对不同的树更加稳健，就能更好地综合它们的结果。
2.  **n\_ estimators**  
    
    
     *  定义了需要使用到的决定树的数量（步骤2）
     *  虽然GBM即使在有较多决定树时仍然能保持稳健，但还是可能发生过度拟合。所以也需要针对learning rate用CV值检验。
3.  **subsample**
    
     *  训练每个决定树所用到的子样本占总样本的比例，而对于子样本的选择是随机的。
     *  用稍小于1的值能够使模型更稳健，因为这样减少了方差。
     *  一把来说用~0.8就行了，更好的结果可以用调参获得。
    
    好了，现在我们已经介绍了树参数和boosting参数，此外还有第三类参数，它们能影响到模型的总体功能：
4.  **loss**
    
     *  指的是每一次节点分裂所要最小化的损失函数(loss function)
     *  对于分类和回归模型可以有不同的值。一般来说不用更改，用默认值就可以了，除非你对它及它对模型的影响很清楚。
5.  **init**  
    
    
     *  它影响了输出参数的起始化过程
     *  如果我们有一个模型，它的输出结果会用来作为GBM模型的起始估计，这个时候就可以用init
6.  **random\_ state**  
    
    
     *  作为每次产生随机数的随机种子
     *  使用随机种子对于调参过程是很重要的，因为如果我们每次都用不同的随机种子，即使参数值没变每次出来的结果也会不同，这样不利于比较不同模型的结果。
     *  任一个随即样本都有可能导致过度拟合，可以用不同的随机样本建模来减少过度拟合的可能，但这样计算上也会昂贵很多，因而我们很少这样用
7.  **verbose**  
    
    
     *  决定建模完成后对输出的打印方式：  
        
        
         *  0：不输出任何结果（默认）
         *  1：打印特定区域的树的输出结果
         *  >1：打印所有结果
8.  **warm\_ start**  
    
    
     *  这个参数的效果很有趣，有效地使用它可以省很多事
     *  使用它我们就可以用一个建好的模型来训练额外的决定树，能节省大量的时间，对于高阶应用我们应该多多探索这个选项。
9.  **presort**  
    
    
     *  决定是否对数据进行预排序，可以使得树分裂地更快。
     *  默认情况下是自动选择的，当然你可以对其更改

我知道我列了太多的参数，所以我在我的GitHub里整理出了一张表，可以直接下载：[GitHub地址][GitHub]

## **5.参数调节实例** ##

接下来要用的数据集来自Data Hackathon 3.x AV hackathon。比赛的细节可以在比赛网站上找到（[http://datahack.analyticsvidhya.com/contest/data-hackathon-3x][http_datahack.analyticsvidhya.com_contest_data-hackathon-3x]），数据可以从这里下载：[http://www.analyticsvidhya.com/wp-content/uploads/2016/02/Dataset.rar][http_www.analyticsvidhya.com_wp-content_uploads_2016_02_Dataset.rar]。我对数据做了一些清洗：

*  City这个变量已经被我舍弃了，因为有太多种类了。
 *  DOB转为Age|DOB,舍弃了DOB
 *  创建了`EMI_Loan_Submitted_Missing`这个变量，当`EMI_Loan_Submitted` 变量值缺失时它的值为1，否则为0。然后舍弃了`EMI_Loan_Submitted`。
 *  EmployerName的值也太多了，我把它也舍弃了
 *  Existing\_EMI的缺失值被填补为0（中位数），因为只有111个缺失值
 *  创建了`Interest_Rate_Missing`变量，类似于\#3，当`Interest_Rate`有值时它的值为0，反之为1，原来的Interest\_Rate变量被舍弃了
 *  Lead\_Creation\_Date也被舍弃了，因为对结果看起来没什么影响
 *  用`Loan_Amount_Applied`和 `Loan_Tenure_Applied`的中位数填补了缺失值
 *  创建了`Loan_Amount_Submitted_Missing`变量，当`Loan_Amount_Submitted`有缺失值时为1，反之为0，原本的`Loan_Amount_Submitted`变量被舍弃
 *  创建了`Loan_Tenure_Submitted_Missing`变量，当`Loan_Tenure_Submitted`有缺失值时为1，反之为0，原本的`Loan_Tenure_Submitted`变量被舍弃
 *  舍弃了LoggedIn,和Salary\_Account
 *  创建了`Processing_Fee_Missing`变量，当`Processing_Fee`有缺失值时为1，反之为0，原本的`Processing_Fee`变量被舍弃
 *  Source-top保留了2个，其他组合成了不同的类别
 *  对一些变量采取了数值化和独热编码（One-Hot-Coding）操作

你们可以从GitHub里data\_preparation iPython notebook中看到这些改变。

首先，我们加载需要的library和数据：

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

然后我们来写一个创建GBM模型和CV值的函数。

def modelfit(alg, dtrain, predictors, performCV=True, printFeatureImportance=True, cv_folds=5):
        #Fit the algorithm on the data
        alg.fit(dtrain[predictors], dtrain['Disbursed'])
    
        #Predict training set:
        dtrain_predictions = alg.predict(dtrain[predictors])
        dtrain_predprob = alg.predict_proba(dtrain[predictors])[:,1]
    
        #Perform cross-validation:
        if performCV:
            cv_score = cross_validation.cross_val_score(alg, dtrain[predictors], dtrain['Disbursed'], cv=cv_folds, scoring='roc_auc')
    
        #Print model report:
        print "\nModel Report"
        print "Accuracy : %.4g" % metrics.accuracy_score(dtrain['Disbursed'].values, dtrain_predictions)
        print "AUC Score (Train): %f" % metrics.roc_auc_score(dtrain['Disbursed'], dtrain_predprob)
    
        if performCV:
            print "CV Score : Mean - %.7g | Std - %.7g | Min - %.7g | Max - %.7g" % (np.mean(cv_score),np.std(cv_score),np.min(cv_score),np.max(cv_score))
    
        #Print Feature Importance:
        if printFeatureImportance:
            feat_imp = pd.Series(alg.feature_importances_, predictors).sort_values(ascending=False)
            feat_imp.plot(kind='bar', title='Feature Importances')
            plt.ylabel('Feature Importance Score')
    
       
        
         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

接着就要创建一个基线模型（baseline model）。这里我们用AUC来作为衡量标准，所以用常数的话AUC就是0.5。一般来说用默认参数设置的GBM模型就是一个很好的基线模型，我们来看看这个模型的输出和特征重要性：

#Choose all predictors except target & IDcols
    predictors = [x for x in train.columns if x not in [target, IDcol]]
    gbm0 = GradientBoostingClassifier(random_state=10)
    modelfit(gbm0, train, predictors)
       
        
         1 
         2 
         3 
         4

![1.-modelfit1.png][]

从图上看出，CV的平均值是0.8319，后面调整的模型会做得比这个更好。

### **5.1 参数调节的一般方法** ###

之前说过，我们要调节的参数有两种：树参数和boosting参数。learning rate没有什么特别的调节方法，因为只要我们训练的树足够多learning rate总是小值来得好。

虽然随着决定树的增多GBM并不会明显得过度拟合，高learing rate还是会导致这个问题，但如果我们一味地减小learning rate、增多树,计算就会非常昂贵而且需要运行很长时间。了解了这些问题，我们决定采取以下方法调参：

1.  选择一个相对来说**稍微高一点的learning rate**。一般默认的值是0.1，不过针对不同的问题，0.05到0.2之间都可以
2.  决定**当前learning rate下最优的决定树数量**。它的值应该在40-70之间。记得选择一个你的电脑还能快速运行的值，因为之后这些树会用来做很多测试和调参。
3.  接着**调节树参数**来调整learning rate和树的数量。我们可以选择不同的参数来定义一个决定树，后面会有这方面的例子
4.  **降低learning rate**，同时会增加相应的决定树数量使得模型更加稳健

### **5.2固定 learning rate和需要估测的决定树数量** ###

为了决定boosting参数，我们得先设定一些参数的初始值，可以像下面这样：

1.  **min\_ samples\_ split=500:** 这个值应该在总样本数的0.5-1%之间，由于我们研究的是不均等分类问题，我们可以取这个区间里一个比较小的数，500。
2.  **min\_ samples\_ leaf=50:** 可以凭感觉选一个合适的数，只要不会造成过度拟合。同样因为不均等分类的原因，这里我们选择一个比较小的值。
3.  **max\_ depth=8:** 根据观察数和自变量数，这个值应该在5-8之间。这里我们的数据有87000行，49列，所以我们先选深度为8。
4.  **max\_ features=’sqrt’:** 经验上一般都选择平方根。
5.  **subsample=0.8:** 开始的时候一般就用0.8

注意我们目前定的都是初始值，最终这些参数的值应该是多少还要靠调参决定。现在我们可以根据learning rate的默认值0.1来找到所需要的最佳的决定树数量，可以利用网格搜索（grid search）实现，以10个数递增，从20测到80。

#Choose all predictors except target & IDcols
    predictors = [x for x in train.columns if x not in [target, IDcol]]
    param_test1 = {
         'n_estimators':range(20,81,10)}
    gsearch1 = GridSearchCV(estimator = GradientBoostingClassifier(learning_rate=0.1, min_samples_split=500,min_samples_leaf=50,max_depth=8,max_features='sqrt',subsample=0.8,random_state=10), 
    param_grid = param_test1, scoring='roc_auc',n_jobs=4,iid=False, cv=5)
    gsearch1.fit(train[predictors],train[target])
       
        
         1 
         2 
         3 
         4 
         5 
         6

来看一下输出结果：

gsearch1.grid_scores_, gsearch1.best_params_, gsearch1.best_score_
       
        
         1

![2.-gsearch-1.png][]

可以看出对于0.1的learning rate, 60个树是最佳的，而且60也是一个合理的决定树数量，所以我们就直接用60。但在一些情况下上面这段代码给出的结果可能不是我们想要的，比如：

1.  如果给出的输出是20，可能就要降低我们的learning rate到0.05，然后再搜索一遍。
2.  如果输出值太高，比如100，因为调节其他参数需要很长时间，这时候可以把learniing rate稍微调高一点。

### **5.3 调节树参数** ###

树参数可以按照这些步骤调节：

1.  调节max\_depth和 `num_samples_split`
2.  调节`min_samples_leaf`
3.  调节max\_features

需要注意一下**调参顺序**，对结果影响最大的参数应该优先调节，就像`max_depth`和`num_samples_split`。

**重要提示：接着我会做比较久的网格搜索(grid search)，可能会花上15-30分钟。你在自己尝试的时候应该根据电脑情况适当调整需要测试的值。**

max\_depth可以相隔两个数从5测到15，而`min_samples_split`可以按相隔200从200测到1000。这些完全凭经验和直觉，如果先测更大的范围再用迭代去缩小范围也是可行的。

param_test2 = {
         'max_depth':range(5,16,2), 'min_samples_split':range(200,1001,200)}
    gsearch2 = GridSearchCV(estimator = GradientBoostingClassifier(learning_rate=0.1, n_estimators=60, max_features='sqrt', subsample=0.8, random_state=10), 
    param_grid = param_test2, scoring='roc_auc',n_jobs=4,iid=False, cv=5)
    gsearch2.fit(train[predictors],train[target])
    gsearch2.grid_scores_, gsearch2.best_params_, gsearch2.best_score_
       
        
         1 
         2 
         3 
         4 
         5

![3.-gsearch-2-1024x776.png][]

从结果可以看出，我们从30种组合中找出最佳的max\_depth是9，而最佳的`min_smaples_split`是1000。1000是我们设定的范围里的最大值，有可能真正的最佳值比1000还要大，所以我们还要继续增加`min_smaples_split`。树深就用9。接着就来调节`min_samples_leaf`，可以测30，40，50，60，70这五个值，同时我们也试着调大`min_samples_leaf`的值。

param_test3 = {
         'min_samples_split':range(1000,2100,200), 'min_samples_leaf':range(30,71,10)}
    gsearch3 = GridSearchCV(estimator = GradientBoostingClassifier(learning_rate=0.1, n_estimators=60,max_depth=9,max_features='sqrt', subsample=0.8, random_state=10), 
    param_grid = param_test3, scoring='roc_auc',n_jobs=4,iid=False, cv=5)
    gsearch3.fit(train[predictors],train[target])
    gsearch3.grid_scores_, gsearch3.best_params_, gsearch3.best_score_
       
        
         1 
         2 
         3 
         4 
         5

![4.-gsearcg-3-1024x724.png][]

这样`min_samples_split`的最佳值是1200，而`min_samples_leaf`的最佳值是60。注意现在CV值增加到了0.8396。现在我们就根据这个结果来重新建模，并再次评估特征的重要性。

modelfit(gsearch3.best_estimator_, train, predictors)
       
        
         1

![5.-modelfit-2-768x529.png][]

比较之前的基线模型结果可以看出，现在我们的模型用了更多的特征，并且基线模型里少数特征的重要性评估值过高，分布偏斜明显，现在分布得更加均匀了。

接下来就剩下最后的树参数`max_features`了，可以每隔两个数从7测到19。

param_test4 = {'max_features':range(7,20,2)}
    gsearch4 = GridSearchCV(estimator = GradientBoostingClassifier(learning_rate=0.1, n_estimators=60,max_depth=9, min_samples_split=1200, min_samples_leaf=60, subsample=0.8, random_state=10),
    param_grid = param_test4, scoring='roc_auc',n_jobs=4,iid=False, cv=5)
    gsearch4.fit(train[predictors],train[target])
    gsearch4.grid_scores_, gsearch4.best_params_, gsearch4.best_score_
    
       
        
         1 
         2 
         3 
         4 
         5 
         6

![6.-gsearch-4-768x240.png][]

最佳的结果是7，正好就是我们设定的初始值（平方根）。当然你可能还想测测小于7的值，我也鼓励你这么做。而按照我们的设定，现在的树参数是这样的：

*  `min_samples_split`: 1200
 *  `min_samples_leaf`: 60
 *  `max_depth`: 9
 *  `max_features`: 7

### **5.4 调节子样本比例来降低learning rate** ###

接下来就可以调节子样本占总样本的比例，我准备尝试这些值：0.6,0.7,0.75,0.8,0.85,0.9。

param_test5 = {
         'subsample':[0.6,0.7,0.75,0.8,0.85,0.9]}
    gsearch5 = GridSearchCV(estimator = GradientBoostingClassifier(learning_rate=0.1, n_estimators=60,max_depth=9,min_samples_split=1200, min_samples_leaf=60, subsample=0.8, random_state=10,max_features=7),
    param_grid = param_test5, scoring='roc_auc',n_jobs=4,iid=False, cv=5)
    gsearch5.fit(train[predictors],train[target])
    gsearch5.grid_scores_, gsearch5.best_params_, gsearch5.best_score_
       
        
         1 
         2 
         3 
         4 
         5

![7.-gsearch-5-768x217.png][]

给出的结果是0.85。这样所有的参数都设定好了，现在我们要做的就是进一步减少learning rate，就相应地增加了树的数量。需要注意的是树的个数是被动改变的，可能不是最佳的，但也很合适。随着树个数的增加，找到最佳值和CV的计算量也会加大，为了看出模型执行效率，我还提供了我每个模型在比赛的排行分数（leaderboard score），怎么得到这个数据不是公开的，你很难重现这个数字，它只是为了更好地帮助我们理解模型表现。

现在我们先把learning rate降一半，至0.05，这样树的个数就相应地加倍到120。

predictors = [x for x in train.columns if x not in [target, IDcol]]
    gbm_tuned_1 = GradientBoostingClassifier(learning_rate=0.05, n_estimators=120,max_depth=9, min_samples_split=1200,min_samples_leaf=60, subsample=0.85, random_state=10, max_features=7)
    modelfit(gbm_tuned_1, train, predictors)
       
        
         1 
         2 
         3

![8.-tuned-1.png][]

**排行得分：0.844139**

接下来我们把learning rate进一步减小到原值的**十分之一**,即0.01，相应地，树的个数变为600。

predictors = [x for x in train.columns if x not in [target, IDcol]]
    gbm_tuned_2 = GradientBoostingClassifier(learning_rate=0.01, n_estimators=600,max_depth=9, min_samples_split=1200,min_samples_leaf=60, subsample=0.85, random_state=10, max_features=7)
    modelfit(gbm_tuned_2, train, predictors)
       
        
         1 
         2 
         3

![9.-tuned-2-1024x718.png][]

**排行得分：0.848145**

继续把learning rate缩小至**二十分之一**，即0.005,这时候我们有1200个树。

predictors = [x for x in train.columns if x not in [target, IDcol]]
    gbm_tuned_3 = GradientBoostingClassifier(learning_rate=0.005, n_estimators=1200,max_depth=9, min_samples_split=1200, min_samples_leaf=60, subsample=0.85, random_state=10, max_features=7,
    warm_start=True)
    modelfit(gbm_tuned_3, train, predictors, performCV=False)
       
        
         1 
         2 
         3 
         4

![10.-tuned-3-1024x685.png][]

**排行得分：0.848112**

排行得分稍微降低了，我们停止减少learning rate，只单方面增加树的个数，试试1500个树。

predictors = [x for x in train.columns if x not in [target, IDcol]]
    gbm_tuned_4 = GradientBoostingClassifier(learning_rate=0.005, n_estimators=1500,max_depth=9, min_samples_split=1200, min_samples_leaf=60, subsample=0.85, random_state=10, max_features=7,
    warm_start=True)
    modelfit(gbm_tuned_4, train, predictors, performCV=False)
       
        
         1 
         2 
         3 
         4

![11.-tuned-4-1024x691.png][]

**排行得分：0.848747**

看，就这么简单，排行得分已经从0.844升高到0.849了，这可是一个很大的提升。

还有一个技巧就是用“warm\_start”选项。这样每次用不同个数的树都不用重新开始。所有的代码都可以从我的Github里下载到。

## **6.总结** ##

这篇文章详细地介绍了GBM模型。我们首先了解了**何为boosting**，然后详细介绍了**各种参数**。 这些参数可以被分为3类：树参数，boosting参数，和其他影响模型的参数。最后我们提到了用GBM解决问题的 **一般方法**，并且用**AV Data Hackathon 3.x problem**数据运用了这些方法。最后，希望这篇文章确实帮助你更好地理解了GBM，在下次运用GBM解决问题的时候也更有信心。

*  本文已收录于以下专栏：
 *  [机器学习与数据挖掘][Link 5]

[![1_sherri_du.jpg][]][1_sherri_du.jpg 1]

[![qq\_23353551][qq_23353551]][qq_23353551_qq_23353551]

*  #### [qq\_23353551][qq_23353551_qq_23353551] ####
    
    2017-05-18 12:15 8楼
 *  谢谢大师分享！有个问题求教，“max\_ depth=8: 根据观察数和自变量数，这个值应该在5-8之间。这里我们的数据有87000行，49列，所以我们先选深度为8”。这个8是怎么计算出来的，非常感谢！
 *

[![qq\_23353551][qq_23353551]][qq_23353551_qq_23353551]

*  #### [qq\_23353551][qq_23353551_qq_23353551] ####
    
    2017-05-18 12:14 7楼
 *  谢谢大师分享！  
    有个问题请教，“max\_ depth=8: 根据观察数和自变量数，这个值应该在5-8之间。这里我们的数据有87000行，49列，所以我们先选深度为8”，这个8是怎么算出来的，非常感谢！
 *

[![yangws2004][]][yangws2004 1]

*  #### [yangws2004][yangws2004 1] ####
    
    2017-04-27 14:48 6楼
 *  多谢翻译，很有帮助
 *

### 相关文章推荐 ###

## [机器学习系列(12)\_XGBoost参数调优完全指南（附Python代码）][12_XGBoost_Python] ##

这篇文章主要讲了如何提升XGBoost模型的表现。首先，我们介绍了相比于GBM，为何XGBoost可以取得这么好的表现。紧接着，我们介绍了每个参数的细节。我们定义了一个可以重复使用的构造模型的函数。...

*  [![yaoqiang2011][]][yaoqiang2011 1]
 *  [yaoqiang2011][yaoqiang2011 1]
 *  2016-09-25 23:35
 *  33125

## [Hyperopt][] ##

1.简介 Hyperopt是一个python库，结合MongoDB可以进行分布式调参，快速找到相对较优的参数。安装的时候需要指定dev版本才能使用模拟退火调参，也支持暴力调参、随机调参等策略。 2...

*  [![a819825294][]][a819825294 1]
 *  [a819825294][a819825294 1]
 *  2016-06-28 14:09
 *  5153

![0f000aXtG381N7btWBlV1f.jpg][]

## 月薪30k的前端程序员都避开了哪些坑？ ##

程序员薪水有高有低，同样工作5年的程序员，有的人月薪30K、50K，有的人可能只有5K、8K。是什么因素导致了这种差异？

## [numpy基础练习100题（01-40）][numpy_100_01-40] ##

numpy基础练习100题（01-40） github项目地址：https://github.com/rougier/numpy-100

*  [![qinhanmin2010][]][qinhanmin2010 1]
 *  [qinhanmin2010][qinhanmin2010 1]
 *  2017-09-18 16:36
 *  81

## [xgboost特征选择][xgboost] ##

Xgboost在各大数据挖掘比赛中是一个大杀器，往往可以取得比其他各种机器学习算法更好的效果。数据预处理，特征工程，调参对Xgboost的效果有着非常重要的影响。这里介绍一下运用xgboost的特征选...

*  [![qq\_34264472][qq_34264472]][qq_34264472_qq_34264472]
 *  [qq\_34264472][qq_34264472_qq_34264472]
 *  2016-11-27 11:22
 *  9178

## [Hyperopt][Hyperopt 1] ##

hyper parameter 调参框架：optunity：http://optunity.readthedocs.io/en/latest/index.htmlHyperoptH...

*  [![zhangweijiqn][]][zhangweijiqn 1]
 *  [zhangweijiqn][zhangweijiqn 1]
 *  2016-11-18 11:16
 *  1013

## [python机器学习模型选择&调参工具Hyperopt-sklearn（1）——综述&分类问题][python_Hyperopt-sklearn_1] ##

针对特定的数据集选择合适的机器学习算法是冗长的过程，即使是针对特定的机器学习算法，亦需要花费大量时间和精力调整参数，才能让模型获得好的效果，Hyperopt-sklearn可以辅助解决这样的问题。

*  [![qinhanmin2010][]][qinhanmin2010 1]
 *  [qinhanmin2010][qinhanmin2010 1]
 *  2017-03-23 15:46
 *  1660

## [python调参神器hyperopt][python_hyperopt] ##

Hyperopt库为python中的模型选择和参数优化提供了算法和并行方案。机器学习常见的模型有KNN,SVM，PCA，决策树，GBDT等一系列的算法，但是在实际应用中，我们需要选取合适的模型，并对模...

*  [![qq\_34139222][qq_34139222]][qq_34139222_qq_34139222]
 *  [qq\_34139222][qq_34139222_qq_34139222]
 *  2017-03-04 11:28
 *  2657

## [pImpl的原理][pImpl] ##

城门失火殃及池鱼pImpl惯用手法的运用方式大家都很清楚，其主要作用是解开类的使用接口和实现的耦合。如果不使用pImpl惯用手法，代码会像这样： //c.hpp ...

*  [![dongguan131][]][dongguan131 1]
 *  [dongguan131][dongguan131 1]
 *  2011-08-13 11:49
 *  385

## [机器学习系列(11)\_Python中Gradient Boosting Machine(GBM）调参方法详解][11_Python_Gradient Boosting Machine_GBM] ##

原文地址：Complete Guide to Parameter Tuning in Gradient Boosting (GBM) in Python by Aarshay Jain 原文翻译与校...

*  [![u010480899][]][u010480899 1]
 *  [u010480899][u010480899 1]
 *  2016-12-24 12:35
 *  433

## [Complete Guide to Parameter Tuning in Gradient Boosting (GBM) in Python][Complete Guide to Parameter Tuning in Gradient Boosting _GBM_ in Python 1] ##

本文转载自https://www.analyticsvidhya.com/blog/2016/02/complete-guide-parameter-tuning-gradient-boosting-...

*  [![u013764485][]][u013764485 1]
 *  [u013764485][u013764485 1]
 *  2016-12-29 10:52
 *  196

## [Complete Guide to Parameter Tuning in Gradient Boosting (GBM) in Python][Complete Guide to Parameter Tuning in Gradient Boosting _GBM_ in Python 2] ##

本文转载自:https://www.analyticsvidhya.com/blog/2016/02/complete-guide-parameter-tuning-gradient-boosting...

*  [![chivalrousli][]][chivalrousli 1]
 *  [chivalrousli][chivalrousli 1]
 *  2016-08-31 18:47
 *  767

## [机器学习（三）GBDT（Gradient Boosting Decision Tree）迭代决策树][GBDT_Gradient Boosting Decision Tree] ##

阿里的比赛一直是跟着大神们的脚步，现在大家讨论最多的

*  [![lszdh][]][lszdh 1]
 *  [lszdh][lszdh 1]
 *  2014-06-22 16:04
 *  6018

## [『机器学习笔记 』GBDT原理-Gradient Boosting Decision Tree][_GBDT_-Gradient Boosting Decision Tree] ##

背景Gradient Boosting提升树boosting tree回归问题提升树算法Gradient Boosting Decision Tree算法Shrinkage总结附录参...

*  [![shine19930820][]][shine19930820 1]
 *  [shine19930820][shine19930820 1]
 *  2017-03-24 17:01
 *  3584

## [机器学习中的数学(3)-模型组合(Model Combining)之Boosting与Gradient Boosting][3_-_Model Combining_Boosting_Gradient Boosting] ##

本文由LeftNotEasy发布于http://leftnoteasy.cnblogs.com前言： 本来上一章的结尾提到，准备写写线性分类的问题，文章都已经写得差不多了，但是突然听...

*  [![a444501101][]][a444501101 1]
 *  [a444501101][a444501101 1]
 *  2015-05-11 15:51
 *  204

## [机器学习中的数学(3)-模型组合(Model Combining)之Boosting与Gradient Boosting][3_-_Model Combining_Boosting_Gradient Boosting 1] ##

发布于http://leftnoteasy.cnblogs.com,最近看的一些论文中发现了模型组合的好处，比如GBDT(Gradient Boosting Decision Tree)或者r...

*  [![zimohuakai][]][zimohuakai 1]
 *  [zimohuakai][zimohuakai 1]
 *  2011-10-30 13:21
 *  453

## [机器学习中的数学(3)-模型组合(Model Combining)之Boosting与Gradient Boosting][3_-_Model Combining_Boosting_Gradient Boosting 2] ##

本文转载自http://www.cnblogs.com/LeftNotEasy/archive/2011/01/02/machine-learning-boosting-and-gradient-bo...

*  [![LIWENHUI199302][]][LIWENHUI199302 1]
 *  [LIWENHUI199302][LIWENHUI199302 1]
 *  2016-04-13 20:49
 *  123

## [机器学习中的数学-模型组合(Model Combining)之Boosting与Gradient Boosting][-_Model Combining_Boosting_Gradient Boosting] ##

文章出处：http://leftnoteasy.cnblogs.com。关于机器学习的博文都很不错Boosting方法： Boosting这其实思想相当的简单，大概是，对一份数据...

*  [![xinsuixiaofeiyu][]][xinsuixiaofeiyu 1]
 *  [xinsuixiaofeiyu][xinsuixiaofeiyu 1]
 *  2015-07-07 21:32
 *  534

## [机器学习中的数学(3)-模型组合(Model Combining)之Boosting与Gradient Boosting][3_-_Model Combining_Boosting_Gradient Boosting 3] ##

*  [![chenbang110][]][chenbang110 1]
 *  [chenbang110][chenbang110 1]
 *  2012-05-20 14:00
 *  477

[python]: http://so.csdn.net/so/search/s.do?q=python&t=blog
[Link 1]: http://so.csdn.net/so/search/s.do?q=增强树&t=blog
[GBM]: http://so.csdn.net/so/search/s.do?q=GBM&t=blog
[Link 2]: http://so.csdn.net/so/search/s.do?q=机器学习&t=blog
[Link 3]: http://so.csdn.net/so/search/s.do?q=调参&t=blog
[Complete Guide to Parameter Tuning in Gradient Boosting _GBM_ in Python]: https://www.analyticsvidhya.com/blog/2016/02/complete-guide-parameter-tuning-gradient-boosting-gbm-python/
[Link 4]: http://blog.csdn.net/han_xiaoyang
[http_blog.csdn.net_han_xiaoyang_article_details_52663170]: http://blog.csdn.net/han_xiaoyang/article/details/52663170
[boosting.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/boosting.png
[Learn Gradient Boosting Algorithm for better predictions _with codes in R]: http://www.analyticsvidhya.com/blog/2015/09/complete-guide-boosting-methods/
[Quick Introduction to Boosting Algorithms in Machine Learning]: http://www.analyticsvidhya.com/blog/2015/11/quick-introduction-boosting-algorithms-machine-learning/
[Getting smart with Machine Learning _ AdaBoost and Gradient Boost]: http://www.analyticsvidhya.com/blog/2015/05/boosting-algorithms-simplified/
[tree-infographic.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/tree-infographic.png
[GitHub]: https://github.com/aarshayj/Analytics_Vidhya/tree/master/Articles/Parameter_Tuning_GBM_with_Example
[http_datahack.analyticsvidhya.com_contest_data-hackathon-3x]: http://datahack.analyticsvidhya.com/contest/data-hackathon-3x
[http_www.analyticsvidhya.com_wp-content_uploads_2016_02_Dataset.rar]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/Dataset.rar
[1.-modelfit1.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/1.-modelfit1.png
[2.-gsearch-1.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/2.-gsearch-1.png
[3.-gsearch-2-1024x776.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/3.-gsearch-2-1024x776.png
[4.-gsearcg-3-1024x724.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/4.-gsearcg-3-1024x724.png
[5.-modelfit-2-768x529.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/5.-modelfit-2-768x529.png
[6.-gsearch-4-768x240.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/6.-gsearch-4-768x240.png
[7.-gsearch-5-768x217.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/7.-gsearch-5-768x217.png
[8.-tuned-1.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/8.-tuned-1.png
[9.-tuned-2-1024x718.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/9.-tuned-2-1024x718.png
[10.-tuned-3-1024x685.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/10.-tuned-3-1024x685.png
[11.-tuned-4-1024x691.png]: http://www.analyticsvidhya.com/wp-content/uploads/2016/02/11.-tuned-4-1024x691.png
[Link 5]: http://blog.csdn.net/column/details/machine-learning-dm.html
[1_sherri_du.jpg]: /images/20220606/146997c5b20a461f9e383d3ec2c4f9b2.png
[1_sherri_du.jpg 1]: http://my.csdn.net/sherri_du
[qq_23353551]: http://avatar.csdn.net/3/E/5/3_qq_23353551.jpg
[qq_23353551_qq_23353551]: /images/20220606/d1fa43f92ef747de8aa93fffdb1e117a.png
[yangws2004]: /images/20220606/81f4380001b8408f8e54dab526b0d50c.png
[yangws2004 1]: http://blog.csdn.net/yangws2004
[12_XGBoost_Python]: http://blog.csdn.net/han_xiaoyang/article/details/52665396
[yaoqiang2011]: /images/20220606/8a6dd6de1aa748c189bc4d951f9f5f59.png
[yaoqiang2011 1]: http://blog.csdn.net/yaoqiang2011
[Hyperopt]: http://blog.csdn.net/a819825294/article/details/51775418
[a819825294]: /images/20220606/21a28f729a6d4144aaa44d2c48734c62.png
[a819825294 1]: http://blog.csdn.net/a819825294
[0f000aXtG381N7btWBlV1f.jpg]: http://ubmcmm.baidustatic.com/media/v1/0f000aXtG381N7btWBlV1f.jpg
[numpy_100_01-40]: http://blog.csdn.net/qinhanmin2010/article/details/78020789
[qinhanmin2010]: /images/20220606/9d02c665c32c40138884ed8a7075bb11.png
[qinhanmin2010 1]: http://blog.csdn.net/qinhanmin2010
[xgboost]: /images/20220606/ce11b3c013a24488b6f9327e278d68be.png/article/details/53363384
[qq_34264472]: http://avatar.csdn.net/A/C/3/2_qq_34264472.jpg
[qq_34264472_qq_34264472]: /images/20220606/ce11b3c013a24488b6f9327e278d68be.png
[Hyperopt 1]: http://blog.csdn.net/zhangweijiqn/article/details/53214239
[zhangweijiqn]: /images/20220606/869a9c3a756f4d0fac536bd8298867ab.png
[zhangweijiqn 1]: http://blog.csdn.net/zhangweijiqn
[python_Hyperopt-sklearn_1]: http://blog.csdn.net/qinhanmin2010/article/details/65444570
[python_hyperopt]: /images/20220606/8beeeeb70b764d9a865f8e85068f808c.png/article/details/60322995
[qq_34139222]: http://avatar.csdn.net/8/9/1/2_qq_34139222.jpg
[qq_34139222_qq_34139222]: /images/20220606/8beeeeb70b764d9a865f8e85068f808c.png
[pImpl]: http://blog.csdn.net/dongguan131/article/details/6683918
[dongguan131]: /images/20220606/8f72b3b8f0004e32b1e41d79899bd513.png
[dongguan131 1]: http://blog.csdn.net/dongguan131
[11_Python_Gradient Boosting Machine_GBM]: http://blog.csdn.net/u010480899/article/details/53858051
[u010480899]: /images/20220606/63d361d0c4174460a0dd27cd0af9fa4a.png
[u010480899 1]: http://blog.csdn.net/u010480899
[Complete Guide to Parameter Tuning in Gradient Boosting _GBM_ in Python 1]: http://blog.csdn.net/u013764485/article/details/53925092
[u013764485]: /images/20220606/fe95dc0ce394431fa3a2d010d93309d5.png
[u013764485 1]: http://blog.csdn.net/u013764485
[Complete Guide to Parameter Tuning in Gradient Boosting _GBM_ in Python 2]: http://blog.csdn.net/chivalrousli/article/details/52387792
[chivalrousli]: /images/20220606/0de14150239c499cabab0ebba5dea4b4.png
[chivalrousli 1]: http://blog.csdn.net/chivalrousli
[GBDT_Gradient Boosting Decision Tree]: http://blog.csdn.net/lszdh/article/details/33305257
[lszdh]: /images/20220606/0003ce23065147348fc927f68e72ae60.png
[lszdh 1]: http://blog.csdn.net/lszdh
[_GBDT_-Gradient Boosting Decision Tree]: http://blog.csdn.net/shine19930820/article/details/65633436
[shine19930820]: /images/20220606/219e22cdbc414edca3be779dc2668c69.png
[shine19930820 1]: http://blog.csdn.net/shine19930820
[3_-_Model Combining_Boosting_Gradient Boosting]: http://blog.csdn.net/a444501101/article/details/45644879
[a444501101]: /images/20220606/e47f7606f4e743b99af0e3178a152443.png
[a444501101 1]: http://blog.csdn.net/a444501101
[3_-_Model Combining_Boosting_Gradient Boosting 1]: http://blog.csdn.net/zimohuakai/article/details/6918597
[zimohuakai]: /images/20220606/4df13a9946bc4f4b836ab14071dad922.png
[zimohuakai 1]: http://blog.csdn.net/zimohuakai
[3_-_Model Combining_Boosting_Gradient Boosting 2]: http://blog.csdn.net/liwenhui199302/article/details/51146596
[LIWENHUI199302]: /images/20220606/ce96911c393f4e988dd98a03afe58a82.png
[LIWENHUI199302 1]: http://blog.csdn.net/LIWENHUI199302
[-_Model Combining_Boosting_Gradient Boosting]: http://blog.csdn.net/xinsuixiaofeiyu/article/details/46794483
[xinsuixiaofeiyu]: /images/20220606/e8162dfd39cf49ceb456911e11a475b0.png
[xinsuixiaofeiyu 1]: http://blog.csdn.net/xinsuixiaofeiyu
[3_-_Model Combining_Boosting_Gradient Boosting 3]: http://blog.csdn.net/chenbang110/article/details/7584741
[chenbang110]: /images/20220606/a04c5fb651794e07b01c53d9d1a36709.png
[chenbang110 1]: http://blog.csdn.net/chenbang110