sklearn梯度提升树(GBDT)调参小结

原文链接

1. sklearn GBDT类库概述

\qquad 在sklearn中,GradientBoostingClassifier为GBDT的分类类, 而GradientBoostingRegressor为GBDT的回归类。两者的参数类型完全相同,当然有些参数比如损失函数loss的可选择项并不相同。这些参数中,类似于Adaboost,我们把重要参数分为两类,第一类是Boosting框架的重要参数,第二类是弱学习器即CART回归树的重要参数。

\qquad 下面我们就从这两个方面来介绍这些参数的使用。

2. GBDT类库boosting框架参数

\qquad 首先,我们来看boosting框架相关的重要参数。由于GradientBoostingClassifier和GradientBoostingRegressor的参数绝大部分相同,我们下面会一起来讲,不同点会单独指出。

\qquad 1) n_estimators: 也就是弱学习器的最大迭代次数,或者说最大的弱学习器的个数。一般来说n_estimators太小,容易欠拟合,n_estimators太大,又容易过拟合,一般选择一个适中的数值。默认是100。在实际调参的过程中,我们常常将n_estimators和下面介绍的参数learning_rate一起考虑。

\qquad 2) learning_rate: 即每个弱学习器的权重缩减系数 ν \nu ν,也称作步长,在原理篇的正则化章节我们也讲到了,加上了正则化项,我们的强学习器的迭代公式为 f k ( x ) = f k − 1 ( x ) + ν h k ( x ) f_k(x)=f_{k−1}(x)+\nu h_k(x) fk(x)=fk1(x)+νhk(x) ν \nu ν的取值范围为 0 &lt; ν ≤ 1 0&lt;\nu≤1 0<ν1。对于同样的训练集拟合效果,较小的 ν \nu ν意味着我们需要更多的弱学习器的迭代次数。通常我们用步长和迭代最大次数一起来决定算法的拟合效果。所以这两个参数n_estimatorslearning_rate要一起调参。一般来说,可以从一个小一点的ν开始调参,默认是1。

\qquad 3) subsample: 即我们在原理篇的正则化章节讲到的子采样,取值为(0,1]。注意这里的子采样和随机森林不一样,随机森林使用的是放回抽样,而这里是不放回抽样。如果取值为1,则全部样本都使用,等于没有使用子采样。如果取值小于1,则只有一部分样本会去做GBDT的决策树拟合。选择小于1的比例可以减少方差,即防止过拟合,但是会增加样本拟合的偏差,因此取值不能太低。推荐在[0.5, 0.8]之间,默认是1.0,即不使用子采样。

\qquad 4) init: 即我们的初始化的时候的弱学习器,拟合对应原理篇里面的 f 0 ( x ) f_0(x) f0(x),如果不输入,则用训练集样本来做样本集的初始化分类回归预测。否则用init参数提供的学习器做初始化分类回归预测。一般用在我们对数据有先验知识,或者之前做过一些拟合的时候,如果没有的话就不用管这个参数了。

\qquad 5) loss: 即我们GBDT算法中的损失函数。分类模型和回归模型的损失函数是不一样的。

\qquad \qquad 对于分类模型,有对数似然损失函数"deviance"和指数损失函数"exponential"两者输入选择。默认是对数似然损失函数"deviance"。在原理篇中对这些分类损失函数有详细的介绍。一般来说,推荐使用默认的"deviance"。它对二元分离和多元分类各自都有比较好的优化。而指数损失函数等于把我们带到了Adaboost算法。

\qquad \qquad 对于回归模型,有均方差"ls", 绝对损失"lad", Huber损失"huber"和分位数损失“quantile”。默认是均方差"ls"。一般来说,如果数据的噪音点不多,用默认的均方差"ls"比较好。如果是噪音点较多,则推荐用抗噪音的损失函数"huber"。而如果我们需要对训练集进行分段预测的时候,则采用“quantile”。

\qquad 6) alpha:这个参数只有GradientBoostingRegressor有,当我们使用Huber损失"huber"和分位数损失“quantile”时,需要指定分位数的值。默认是0.9,如果噪音点较多,可以适当降低这个分位数的值。

3. GBDT类库弱学习器参数

\qquad 参照决策树参数sklearn决策树类库使用小结

4. GBDT调参实例

\qquad 样例数据下载

\qquad 首先,我们载入需要的类库:

import pandas as pd
from sklearn import metrics
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.grid_search import GridSearchCV

\qquad 接着,我们把解压的数据用下面的代码载入,顺便看看数据的类别分布。

train = pd.read_csv('train_modified.csv')
target='Disbursed' # Disbursed的值就是二元分类的输出
IDcol = 'ID'
train['Disbursed'].value_counts() 
"""
0    19680
1      320
Name: Disbursed, dtype: int64
"""

\qquad 现在我们得到我们的训练集。最后一列Disbursed是分类输出。前面的所有列(不考虑ID列)都是样本特征。

# 最后一列Disbursed是分类输出,前面的所有列(不考虑ID列)都是样本特征。
x_columns = [x for x in train.columns if x not in [target, IDcol]]
X = train[x_columns]
y = train['Disbursed']

\qquad 不管任何参数,都用默认的,我们拟合下数据看看:

gbm0 = GradientBoostingClassifier(random_state=10)
gbm0.fit(X, y)
y_pred = gbm0.predict(X)
y_predprob = gbm0.predict_proba(X)[:, 1]

print("Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred))  # Accuracy : 0.9852
print("AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob))  # AUC Score (Train): 0.900531

\qquad 拟合还可以,我们下面看看怎么通过调参提高模型的泛化能力。

\qquad 首先我们从步长(learning rate)和迭代次数(n_estimators)入手。一般来说,开始选择一个较小的步长来网格搜索最好的迭代次数。这里,我们将步长初始值设置为0.1。对于迭代次数进行网格搜索如下:

param_test1 = {'n_estimators': list(range(20, 81, 10))}
gsearch1 = GridSearchCV(
    estimator=GradientBoostingClassifier(learning_rate=0.1, min_samples_split=300, min_samples_leaf=20, max_depth=8,
                                         max_features='sqrt', subsample=0.8, random_state=10),
    param_grid=param_test1, scoring='roc_auc', iid=False, cv=5)
gsearch1.fit(X, y)
print(gsearch1.grid_scores_, gsearch1.best_params_, gsearch1.best_score_)

"""
[mean: 0.81285, std: 0.01967, params: {'n_estimators': 20}, 
 mean: 0.81438, std: 0.01947, params: {'n_estimators': 30}, 
 mean: 0.81451, std: 0.01933, params: {'n_estimators': 40}, 
 mean: 0.81618, std: 0.01848, params: {'n_estimators': 50}, 
 mean: 0.81779, std: 0.01736, params: {'n_estimators': 60}, 
 mean: 0.81585, std: 0.01843, params: {'n_estimators': 70}, 
 mean: 0.81381, std: 0.01790, params: {'n_estimators': 80}] 

{'n_estimators': 60} 

0.8177893165650406
"""

\qquad 找到了一个合适的迭代次数,现在我们开始对决策树进行调参。首先我们对决策树最大深度max_depth和内部节点再划分所需最小样本数min_samples_split进行网格搜索。

param_test2 = {'max_depth': list(range(3, 14, 2)), 'min_samples_split': list(range(100, 801, 200))}
gsearch2 = GridSearchCV(
    estimator=GradientBoostingClassifier(learning_rate=0.1, n_estimators=60, min_samples_leaf=20,
                                         max_features='sqrt', subsample=0.8, random_state=10),
    param_grid=param_test2, scoring='roc_auc', iid=False, cv=5)
gsearch2.fit(X, y)
print(gsearch2.grid_scores_, gsearch2.best_params_, gsearch2.best_score_)

"""
[mean: 0.81199, std: 0.02073, params: {'min_samples_split': 100, 'max_depth': 3}, 
 mean: 0.81267, std: 0.01985, params: {'min_samples_split': 300, 'max_depth': 3}, 
 mean: 0.81238, std: 0.01937, params: {'min_samples_split': 500, 'max_depth': 3}, 
 mean: 0.80925, std: 0.02051, params: {'min_samples_split': 700, 'max_depth': 3},
 mean: 0.81846, std: 0.01843, params: {'min_samples_split': 100, 'max_depth': 5}, 
 mean: 0.81630, std: 0.01810, params: {'min_samples_split': 300, 'max_depth': 5}, 
 mean: 0.81315, std: 0.01898, params: {'min_samples_split': 500, 'max_depth': 5}, 
 mean: 0.81262, std: 0.02090, params: {'min_samples_split': 700, 'max_depth': 5}, 
 mean: 0.81826, std: 0.02030, params: {'min_samples_split': 100, 'max_depth': 7}, 
 mean: 0.82137, std: 0.01733, params: {'min_samples_split': 300, 'max_depth': 7}, 
 mean: 0.81703, std: 0.01773, params: {'min_samples_split': 500, 'max_depth': 7}, 
 mean: 0.81383, std: 0.02327, params: {'min_samples_split': 700, 'max_depth': 7}, 
 mean: 0.81040, std: 0.02083, params: {'min_samples_split': 100, 'max_depth': 9}, 
 mean: 0.80845, std: 0.02724, params: {'min_samples_split': 300, 'max_depth': 9}, 
 mean: 0.81476, std: 0.01973, params: {'min_samples_split': 500, 'max_depth': 9}, 
 mean: 0.81601, std: 0.02576, params: {'min_samples_split': 700, 'max_depth': 9}, 
 mean: 0.81146, std: 0.02273, params: {'min_samples_split': 100, 'max_depth': 11}, 
 mean: 0.81309, std: 0.02696, params: {'min_samples_split': 300, 'max_depth': 11}, 
 mean: 0.81704, std: 0.02382, params: {'min_samples_split': 500, 'max_depth': 11}, 
 mean: 0.81347, std: 0.02702, params: {'min_samples_split': 700, 'max_depth': 11}, 
 mean: 0.81482, std: 0.01777, params: {'min_samples_split': 100, 'max_depth': 13}, 
 mean: 0.80912, std: 0.02153, params: {'min_samples_split': 300, 'max_depth': 13}, 
 mean: 0.81959, std: 0.01654, params: {'min_samples_split': 500, 'max_depth': 13}, 
 mean: 0.81470, std: 0.02299, params: {'min_samples_split': 700, 'max_depth': 13}] 
 
 {'min_samples_split': 300, 'max_depth': 7} 
 
 0.8213724275914632
"""

\qquad 由于决策树深度7是一个比较合理的值,我们把它定下来,对于内部节点再划分所需最小样本数min_samples_split,我们暂时不能一起定下来,因为这个还和决策树其他的参数存在关联。下面我们再对内部节点再划分所需最小样本数min_samples_split和叶子节点最少样本数min_samples_leaf一起调参。

param_test3 = {'min_samples_split': list(range(800, 1900, 200)), 'min_samples_leaf': list(range(60, 101, 10))}
gsearch3 = GridSearchCV(
    estimator=GradientBoostingClassifier(learning_rate=0.1, n_estimators=60, max_depth=7,
                                         max_features='sqrt', subsample=0.8, random_state=10),
    param_grid=param_test3, scoring='roc_auc', iid=False, cv=5)
gsearch3.fit(X, y)
print(gsearch3.grid_scores_, gsearch3.best_params_, gsearch3.best_score_)
"""
[mean: 0.81828, std: 0.02251, params: {'min_samples_leaf': 60, 'min_samples_split': 800}, 
mean: 0.81752, std: 0.02340, params: {'min_samples_leaf': 60, 'min_samples_split': 1000}, 
mean: 0.82220, std: 0.02250, params: {'min_samples_leaf': 60, 'min_samples_split': 1200}, 
mean: 0.81447, std: 0.02125, params: {'min_samples_leaf': 60, 'min_samples_split': 1400}, 
mean: 0.81495, std: 0.01626, params: {'min_samples_leaf': 60, 'min_samples_split': 1600}, 
mean: 0.81528, std: 0.02140, params: {'min_samples_leaf': 60, 'min_samples_split': 1800}, 
mean: 0.81590, std: 0.02517, params: {'min_samples_leaf': 70, 'min_samples_split': 800}, 
mean: 0.81573, std: 0.02207, params: {'min_samples_leaf': 70, 'min_samples_split': 1000}, 
mean: 0.82021, std: 0.02521, params: {'min_samples_leaf': 70, 'min_samples_split': 1200}, 
mean: 0.81512, std: 0.01995, params: {'min_samples_leaf': 70, 'min_samples_split': 1400}, 
mean: 0.81395, std: 0.02081, params: {'min_samples_leaf': 70, 'min_samples_split': 1600}, 
mean: 0.81587, std: 0.02082, params: {'min_samples_leaf': 70, 'min_samples_split': 1800}, 
mean: 0.82064, std: 0.02698, params: {'min_samples_leaf': 80, 'min_samples_split': 800}, 
mean: 0.81490, std: 0.02475, params: {'min_samples_leaf': 80, 'min_samples_split': 1000}, 
mean: 0.82009, std: 0.02568, params: {'min_samples_leaf': 80, 'min_samples_split': 1200}, 
mean: 0.81850, std: 0.02226, params: {'min_samples_leaf': 80, 'min_samples_split': 1400}, 
mean: 0.81855, std: 0.02099, params: {'min_samples_leaf': 80, 'min_samples_split': 1600}, 
mean: 0.81666, std: 0.02249, params: {'min_samples_leaf': 80, 'min_samples_split': 1800}, 
mean: 0.81960, std: 0.02437, params: {'min_samples_leaf': 90, 'min_samples_split': 800}, 
mean: 0.81560, std: 0.02235, params: {'min_samples_leaf': 90, 'min_samples_split': 1000}, 
mean: 0.81936, std: 0.02542, params: {'min_samples_leaf': 90, 'min_samples_split': 1200}, 
mean: 0.81362, std: 0.02254, params: {'min_samples_leaf': 90, 'min_samples_split': 1400}, 
mean: 0.81429, std: 0.02417, params: {'min_samples_leaf': 90, 'min_samples_split': 1600}, 
mean: 0.81299, std: 0.02262, params: {'min_samples_leaf': 90, 'min_samples_split': 1800}, 
mean: 0.82000, std: 0.02511, params: {'min_samples_leaf': 100, 'min_samples_split': 800}, 
mean: 0.82209, std: 0.01816, params: {'min_samples_leaf': 100, 'min_samples_split': 1000}, 
mean: 0.81821, std: 0.02337, params: {'min_samples_leaf': 100, 'min_samples_split': 1200}, 
mean: 0.81941, std: 0.02404, params: {'min_samples_leaf': 100, 'min_samples_split': 1400}, 
mean: 0.81545, std: 0.02221, params: {'min_samples_leaf': 100, 'min_samples_split': 1600}, 
mean: 0.81704, std: 0.02509, params: {'min_samples_leaf': 100, 'min_samples_split': 1800}] 

{'min_samples_leaf': 60, 'min_samples_split': 1200} 

0.8222032996697154
"""

\qquad 我们调了这么多参数了,终于可以都放到GBDT类里面去看看效果了。现在我们用新参数拟合数据:

gbm1 = GradientBoostingClassifier(learning_rate=0.1, n_estimators=60, max_depth=7, min_samples_leaf=60,
                                  min_samples_split=1200, max_features='sqrt', subsample=0.8, random_state=10)
gbm1.fit(X, y)
y_pred = gbm1.predict(X)
y_predprob = gbm1.predict_proba(X)[:, 1]

"""
对比我们最开始完全不调参的拟合效果,可见精确度稍有下降,主要原理是我们使用了0.8的子采样,20%的数据没有参与拟合。
"""
print("Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred))  # Accuracy : 0.984
print("AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob))  # AUC Score (Train): 0.908099

\qquad 对比我们最开始完全不调参的拟合效果,可见精确度稍有下降,主要原理是我们使用了0.8的子采样,20%的数据没有参与拟合。

\qquad 现在我们再对最大特征数max_features进行网格搜索。

param_test4 = {'max_features': list(range(7, 20, 2))}
gsearch4 = GridSearchCV(
    estimator=GradientBoostingClassifier(learning_rate=0.1, n_estimators=60, max_depth=7, min_samples_leaf=60,
                                         min_samples_split=1200, subsample=0.8, random_state=10),
    param_grid=param_test4, scoring='roc_auc', iid=False, cv=5)
gsearch4.fit(X, y)
print(gsearch4.grid_scores_, gsearch4.best_params_, gsearch4.best_score_)

"""
[mean: 0.82220, std: 0.02250, params: {'max_features': 7}, 
mean: 0.82241, std: 0.02421, params: {'max_features': 9}, 
mean: 0.82108, std: 0.02302, params: {'max_features': 11}, 
mean: 0.82064, std: 0.01900, params: {'max_features': 13}, 
mean: 0.82198, std: 0.01514, params: {'max_features': 15}, 
mean: 0.81355, std: 0.02053, params: {'max_features': 17}, 
mean: 0.81877, std: 0.01863, params: {'max_features': 19}] 

{'max_features': 9} 

0.822412506351626
"""

\quad 现在我们再对子采样的比例进行网格搜索:

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=7, min_samples_leaf=60,
                                         min_samples_split=1200, max_features=9, random_state=10),
    param_grid=param_test5, scoring='roc_auc', iid=False, cv=5)
gsearch5.fit(X, y)
print(gsearch5.grid_scores_, gsearch5.best_params_, gsearch5.best_score_)
"""
[mean: 0.81828, std: 0.02392, params: {'subsample': 0.6}, 
mean: 0.82344, std: 0.02708, params: {'subsample': 0.7}, 
mean: 0.81673, std: 0.02196, params: {'subsample': 0.75}, 
mean: 0.82241, std: 0.02421, params: {'subsample': 0.8}, 
mean: 0.82285, std: 0.02446, params: {'subsample': 0.85}, 
mean: 0.81738, std: 0.02236, params: {'subsample': 0.9}] 

{'subsample': 0.7} 

0.8234378969766262
"""

\qquad 现在我们基本已经得到我们所有调优的参数结果了。这时我们可以减半步长,最大迭代次数加倍来增加我们模型的泛化能力。再次拟合我们的模型:

gbm2 = GradientBoostingClassifier(learning_rate=0.05, n_estimators=120, max_depth=7, min_samples_leaf=60,
                                  min_samples_split=1200, max_features=9, subsample=0.7, random_state=10)
gbm2.fit(X, y)
y_pred = gbm2.predict(X)
y_predprob = gbm2.predict_proba(X)[:, 1]
"""
可以看到AUC分数比起之前的版本稍有下降,这个原因是我们为了增加模型泛化能力,
为防止过拟合而减半步长,最大迭代次数加倍,同时减小了子采样的比例,从而减少了训练集的拟合程度。
"""
print("Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred))  # Accuracy : 0.984
print("AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob))  # AUC Score (Train): 0.905324

\qquad 可以看到AUC分数比起之前的版本稍有下降,这个原因是我们为了增加模型泛化能力,为防止过拟合而减半步长,最大迭代次数加倍,同时减小了子采样的比例,从而减少了训练集的拟合程度。

\qquad 下面我们继续将步长缩小5倍,最大迭代次数增加5倍,继续拟合我们的模型:


gbm3 = GradientBoostingClassifier(learning_rate=0.01, n_estimators=600, max_depth=7, min_samples_leaf=60,
                                  min_samples_split=1200, max_features=9, subsample=0.7, random_state=10)
gbm3.fit(X, y)
y_pred = gbm3.predict(X)
y_predprob = gbm3.predict_proba(X)[:, 1]
print("Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred))  # Accuracy : 0.984
print("AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob))  # AUC Score (Train): 0.908688

\qquad 最后我们继续步长缩小一半,最大迭代次数增加2倍,拟合我们的模型:

gbm4 = GradientBoostingClassifier(learning_rate=0.005, n_estimators=1200, max_depth=7, min_samples_leaf=60,
                                  min_samples_split=1200, max_features=9, subsample=0.7, random_state=10)
gbm4.fit(X, y)
y_pred = gbm4.predict(X)
y_predprob = gbm4.predict_proba(X)[:, 1]
print("Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred))  # Accuracy : 0.984
print("AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob))  # AUC Score (Train): 0.908232

\qquad 此时由于步长实在太小,导致拟合效果反而变差,也就是说,步长不能设置的过小

  • 7
    点赞
  • 58
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值