GBDT调参（Python 3.7）

在scikit-learn中，GradientBoostingClassifier为GBDT的分类类， 而GradientBoostingRegressor为GBDT的回归类。

1.GBDT类库boosting框架参数

• n_estimator
  弱学习器的最大迭代次数，或者说最大的弱学习器的个数。一般来说n_estimators太小，容易欠拟合，n_estimators太大，又容易过拟合，一般选择一个适中的数值。默认是100。在实际调参的过程中，常常将n_estimators和learning_rate一起考虑。

• learning_rate
  每个弱学习器的权重缩减系数ν，也称作步长。ν的取值范围为0<ν≤1。对于同样的训练集拟合效果，较小的ν意味着我们需要更多的弱学习器的迭代次数。通常我们用步长和迭代最大次数一起来决定算法的拟合效果。所以这两个参数n_estimators和learning_rate要一起调参。一般来说，可以从一个小一点的ν开始调参，默认是1。

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

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

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

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

2.GBDT类库弱学习器参数

• 划分时考虑的最大特征数max_features

• • 默认是"None",意味着划分时考虑所有的特征数；
• • "log2"意味着划分时最多考虑log2N个特征；
• • "sqrt"或者"auto"意味着划分时最多考虑√N个特征。
    如果是整数，代表考虑的特征绝对数。如果是浮点数，代表考虑特征百分比，即考虑（百分比xN）取整后的特征数。其中N为样本总特征数。一般来说，如果样本特征数不多，比如小于50，用默认的"None"就可以了，如果特征数非常多

• 决策树最大深度max_depth:
  默认可以不输入，如果不输入的话，默认值是3。一般来说，数据少或者特征少的时候可以不管这个值。如果模型样本量多，特征也多的情况下，推荐限制这个最大深度，具体的取值取决于数据的分布。常用的可以取值10-100之间。

• 内部节点再划分所需最小样本数min_samples_split
  这个值限制了子树继续划分的条件，如果某节点的样本数少于min_samples_split，则不会继续再尝试选择最优特征来进行划分。 默认是2.如果样本量不大，不需要管这个值。如果样本量数量级非常大，则推荐增大这个值。

• 叶子节点最少样本数min_samples_leaf
  这个值限制了叶子节点最少的样本数，如果某叶子节点数目小于样本数，则会和兄弟节点一起被剪枝。 默认是1,可以输入最少的样本数的整数，或者最少样本数占样本总数的百分比。如果样本量不大，不需要管这个值。如果样本量数量级非常大，则推荐增大这个值。

• 叶子节点最小的样本权重和min_weight_fraction_leaf
  这个值限制了叶子节点所有样本权重和的最小值，如果小于这个值，则会和兄弟节点一起被剪枝。 默认是0，就是不考虑权重问题。一般来说，如果我们有较多样本有缺失值，或者分类树样本的分布类别偏差很大，就会引入样本权重，这时我们就要注意这个值了。

• 最大叶子节点数max_leaf_nodes
  通过限制最大叶子节点数，可以防止过拟合，默认是"None”，即不限制最大的叶子节点数。如果加了限制，算法会建立在最大叶子节点数内最优的决策树。如果特征不多，可以不考虑这个值，但是如果特征分成多的话，可以加以限制，具体的值可以通过交叉验证得到。

• 节点划分最小不纯度min_impurity_split
  这个值限制了决策树的增长，如果某节点的不纯度(基于基尼系数，均方差)小于这个阈值，则该节点不再生成子节点。即为叶子节点 。一般不推荐改动默认值1e-7。

3.GridSearchCV参数

class sklearn.model_selection.GridSearchCV(estimator, param_grid, scoring=None, fit_params=None, n_jobs=1, iid=True, refit=True, cv=None, verbose=0, pre_dispatch=‘2*n_jobs’, error_score=’raise’, return_train_score=’warn’)

• estimator
  选择使用的分类器，并且传入除需要确定最佳的参数之外的其他参数。每一个分类器都需要一个scoring参数，或者score方法：estimator=RandomForestClassifier(min_samples_split=100,min_samples_leaf=20,max_depth=8,max_features=‘sqrt’,random_state=10),

• param_grid
  需要最优化的参数的取值，值为字典或者列表，例如：param_grid =param_test1，param_test1 = {‘n_estimators’:range(10,71,10)}。

• scoring=None
  模型评价标准，默认None,这时需要使用score函数；或者如scoring=‘roc_auc’，根据所选模型不同，评价准则不同。字符串（函数名），或是可调用对象，需要其函数签名形如：scorer(estimator, X, y)；如果是None，则使用estimator的误差估计函数。具体值的选取看本篇第三节内容。

• fit_params=None

• n_jobs=1
  n_jobs: 并行数，int：个数,-1：跟CPU核数一致, 1:默认值

• iid=True
  iid:默认True,为True时，默认为各个样本fold概率分布一致，误差估计为所有样本之和，而非各个fold的平均。

• refit=True
  默认为True,程序将会以交叉验证训练集得到的最佳参数，重新对所有可用的训练集与开发集进行，作为最终用于性能评估的最佳模型参数。即在搜索参数结束后，用最佳参数结果再次fit一遍全部数据集。

• cv=None
  交叉验证参数，默认None，使用三折交叉验证。指定fold数量，默认为3，也可以是yield训练/测试数据的生成器。

• verbose=0, scoring=None
  verbose：日志冗长度，int：冗长度，0：不输出训练过程，1：偶尔输出，>1：对每个子模型都输出。

• pre_dispatch=‘2*n_jobs’
  指定总共分发的并行任务数。当n_jobs大于1时，数据将在每个运行点进行复制，这可能导致OOM，而设置pre_dispatch参数，则可以预先划分总共的job数量，使数据最多被复制pre_dispatch次

• error_score=’raise’

• return_train_score=’warn’

如果“False”，cv_results_属性将不包括训练分数

回到sklearn里面的GridSearchCV，GridSearchCV用于系统地遍历多种参数组合，通过交叉验证确定最佳效果参数。

4.GBDT二元分类调参实例

使用的20000行数据下载地址：http://files.cnblogs.com/files/pinard/train_modified.zip

• 首先载入需要的库：

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

• 然后加载数据：

train=pd.read_csv("train_modified.csv")
target="Disbursed"               # Disbursed的值就是二元分类的输出
IDcol="ID"
print(train["Disbursed"].value_counts())     #查看各类别的样本数

类别输出如下，类别为0的样本占大多数：

• 数据集中Disbursed列是分类输出，其他所有列（不考虑ID列）均为样本的特征。

x_columns=[x for x in train.columns if x not in [target,IDcol]]
X=train[x_columns]
y=train['Disbursed']

• 所有参数均使用默认值来拟合

gbm0=GradientBoostingClassifier(random_state=10)
gbm0.fit(X,y)
y_pred=gbm0.predict(X)
y_predprob=gbm0.predict_proba(X)[:,1]            #样本预测为类别1的概率（默认使用正样本标签计算AUC）
print("Accuracy:%.4f"%metrics.accuracy_score(y,y_pred))
print("AUC Score(Train):%f"%metrics.roc_auc_score(y,y_predprob))

输出结果：

• • 说明

（1）predict_prob用法
predict_proba返回的是一个 n 行 k 列的数组， 第 i 行 第 j 列上的数值是模型预测 第 i 个预测样本为第 j 个标签的概率，并且每一行的概率和为1。
详见：https://blog.csdn.net/m0_37870649/article/details/79549142
（2）roc_auc_score
ROC（Receiver Operating Characteristic）曲线和AUC常被用来评价一个二值分类器（binary classifier）的优劣。

AUC（Area Under Curve）被定义为ROC曲线下的面积，显然这个面积的数值不会大于1。又由于ROC曲线一般都处于y=x这条直线的上方，所以AUC的取值范围在0.5和1之间。使用AUC值作为评价标准是因为很多时候ROC曲线并不能清晰的说明哪个分类器的效果更好，而作为一个数值，对应AUC更大的分类器效果更好。

sklearn.metrics.roc_curve(y_true, y_score, pos_label=None, sample_weight=None, drop_intermediate=True)

其中y_true为真实标签，y_score为预测概率，或称为置信度。pos_label为正类样本标签，一般为1。
精确率，召回率，ROC，PR详见 https://www.cnblogs.com/pinard/p/5993450.html

4.1 迭代次数（n_estimator）

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

param_test1={'n_estimators':range(20,81,10)}
grid_search1=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
)
grid_result1=grid_search1.fit(X,y)
##打印结果
print("Best: %f using %s" % (grid_result1.best_score_,grid_result1.best_params_))
means = grid_result1.cv_results_['mean_test_score']
params = grid_result1.cv_results_['params']
for mean,param in zip(means,params):
    print("mean:  %f  , params:  %r" % (mean,param))         ##%r是万能格式符，会将后面参数原样打印出来

输出如下，可见最优n_estimator=60。

4.2 决策树最大深度（max_depth）& 内部节点划分所需最小样本数（min_samples_split）

param_test2={'max_depth':range(3,14,2),'min_samples_split':range(100,801,200)}
grid_search2=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
)
grid_result2=grid_search2.fit(X,y)
##打印结果
print("Best: %f using %s" % (grid_result2.best_score_,grid_result2.best_params_))
means = grid_result2.cv_results_['mean_test_score']
params = grid_result2.cv_results_['params']
for mean,param in zip(means,params):
    print("mean:  %f  , params:  %r" % (mean,param))

输出如下，可见最优max_depth=7,min_samples_split=300

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

4.3 内部节点再划分所需最小样本数（min_samples_split）& 叶子节点最少样本数（min_samples_leaf）

param_test3={'min_samples_split':range(800,1900,200), 'min_samples_leaf':range(40,81,10)}
grid_search3=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
)
grid_result3=grid_search3.fit(X,y)
##打印结果
print("Best: %f using %s" % (grid_result3.best_score_,grid_result3.best_params_))
means = grid_result3.cv_results_['mean_test_score']
params = grid_result3.cv_results_['params']
for mean,param in zip(means,params):
    print("mean:  %f  , params:  %r" % (mean,param))

输出如下，可见最优min_samples_split=1200，min_samples_leaf=60

• 用新参数拟合数据

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]            #样本预测为类别1的概率（默认使用正样本标签计算AUC）
print("Accuracy:%.4f"%metrics.accuracy_score(y,y_pred))
print("AUC Score(Train):%f"%metrics.roc_auc_score(y,y_predprob))

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

4.4 最大特征数（max_features）

param_test4={'max_features':range(7,20,2)}
grid_search4=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
)
grid_result4=grid_search4.fit(X,y)
##打印结果
print("Best: %f using %s" % (grid_result4.best_score_,grid_result4.best_params_))
means = grid_result4.cv_results_['mean_test_score']
params = grid_result4.cv_results_['params']
for mean,param in zip(means,params):
    print("mean:  %f  , params:  %r" % (mean,param))

输出如下，可见最优max_features=9

4.5 自采样比例（subsample）

param_test5={'subsample':[0.6,0.7,0.75,0.8,0.85,0.9]}
grid_search5=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
)
grid_result5=grid_search5.fit(X,y)
##打印结果
print("Best: %f using %s" % (grid_result5.best_score_,grid_result5.best_params_))
means = grid_result5.cv_results_['mean_test_score']
params = grid_result5.cv_results_['params']
for mean,param in zip(means,params):
    print("mean:  %f  , params:  %r" % (mean,param))

输出如下，可见最优subsample=0.7

4.6 增加模型泛化能力

通过减小步长，最大迭代次数增加相应倍数来增加模型的泛化能力

• learning_rate=0.05，n_estimators=120

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]            #样本预测为类别1的概率（默认使用正样本标签计算AUC）
print("Accuracy:%.4f"%metrics.accuracy_score(y,y_pred))
print("AUC Score(Train):%f"%metrics.roc_auc_score(y,y_predprob))

输出结果

• learning_rate=0.01，n_estimators=600

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]            #样本预测为类别1的概率（默认使用正样本标签计算AUC）
print("Accuracy:%.4f"%metrics.accuracy_score(y,y_pred))
print("AUC Score(Train):%f"%metrics.roc_auc_score(y,y_predprob))

输出如下，可见减小步长增加迭代次数可以在保证泛化能力的基础上增加一些拟合程度。

• learning_rate=0.005，n_estimators=1200

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]            #样本预测为类别1的概率（默认使用正样本标签计算AUC）
print("Accuracy:%.4f"%metrics.accuracy_score(y,y_pred))
print("AUC Score(Train):%f"%metrics.roc_auc_score(y,y_predprob))

输出如下，此时由于步长实在太小，导致拟合效果反而变差，也就是说，步长不能设置的过小。

参考：
https://www.cnblogs.com/pinard/p/6143927.html
https://blog.csdn.net/weixin_41988628/article/details/83098130