scikit-learn提升决策树参数调节
scikit-learn 提升决策树参数调节
本⽂我们对scikit-learn⾥GBDT的类库使⽤⽅法作⼀个总结，主要会关注调参中的⼀些要点。
1. scikit-learn GBDT类库概述
迷你摄像机 在sacikit-learn中，GradientBoostingClassifier为GBDT的分类类，⽽GradientBoostingRegressor为GBDT的回归类。两者的参数类型完全相同，当然有些参数⽐如损失函数loss的可选择项并不相同。这些参数中，类似于Adaboost，我们把重要参数分为两类，第⼀类是Boosting框架的重要参数，第⼆类是弱学习器即CART回归树的重要参数。
下⾯我们就从这两个⽅⾯来介绍这些参数的使⽤。
2. GBDT类库boosting框架参数
⾸先，我们来看boosting框架相关的重要参数。由于GradientBoostingClassifier和GradientBoostingRegressor的参数绝⼤部分相同，我们下⾯会⼀起来讲，不同点会单独指出。
1) n_estimators: 也就是弱学习器的最⼤迭代次数，或者说最⼤的弱学习器的个数。⼀般来说n_estimators太⼩，容易⽋拟
合，n_estimators太⼤，⼜容易过拟合，⼀般选择⼀个适中的数值。默认是100。在实际调参的过程中，我们常常将n_estimators和下⾯介绍的参数learning_rate⼀起考虑。
2) learning_rate: 即每个弱学习器的权重缩减系数νν，也称作步长，在原理篇的正则化章节我们也讲到了，加上了正则化项，我们的强学习器的迭代公式为fk(x)=fk−1(x)+νhk(x)fk(x)=fk−1(x)+νhk(x)。νν的取值范围为0<ν≤10<ν≤1。对于同样的训练集拟合效果，较⼩的νν意味着我们需要更多的弱学习器的迭代次数。通常我们⽤步长和迭代最⼤次数⼀起来决定算法的拟合效果。所以这两个参数n_estimators和learning_rate要⼀起调参。⼀般来说，可以从⼀个⼩⼀点的νν开始调参，默认是1。
3) subsample: 即我们在原理篇的正则化章节讲到的⼦采样，取值为(0,1]。注意这⾥的⼦采样和随机森林不⼀样，随机森林使⽤的是放回抽样，⽽这⾥是不放回抽样。如果取值为1，则全部样本都使⽤，等于没有使⽤⼦采样。如果取值⼩于1，则只有⼀部分样本会去做GBDT的决策树拟合。选择⼩于1的⽐例可以减少⽅差，即防⽌过拟合，但是会增加样本拟合的偏差，因此取值不能太低。推荐在[0.5, 0.8]之间，默认是1.0，即不使⽤⼦采样。
4) init: 即我们的初始化的时候的弱学习器，拟合对应原理篇⾥⾯的f0(x)f0(x)，如果不输⼊，则⽤训
练集样本来做样本集的初始化分类回归预测。否则⽤init参数提供的学习器做初始化分类回归预测。⼀般⽤在我们对数据有先验知识，或者之前做过⼀些拟合的时候，如果没有的话就不⽤管这个参数了。
5) loss: 即我们GBDT算法中的损失函数。分类模型和回归模型的损失函数是不⼀样的。
对于分类模型，有对数似然损失函数"deviance"和指数损失函数"exponential"两者输⼊选择。默认是对数似然损失函数"deviance"。在原理篇中对这些分类损失函数有详细的介绍。⼀般来说，推荐使⽤默认的"deviance"。它对⼆元分离和多元分类各⾃都有⽐较好的优化。⽽指数损失函数等于把我们带到了Adaboost算法。
对于回归模型，有均⽅差"ls", 绝对损失"lad", Huber损失"huber"和分位数损失“quantile”。默认是均⽅差"ls"。⼀般来说，如果数据的噪⾳点不多，⽤默认的均⽅差"ls"⽐较好。如果是噪⾳点较多，则推荐⽤抗噪⾳的损失函数"huber"。⽽如果我们需要对训练集进⾏分段预测的时候，则采⽤“quantile”。
6) alpha：这个参数只有GradientBoostingRegressor有，当我们使⽤Huber损失"huber"和分位数损失“quantile”时，需要指定分位数的值。默认是0.9，如果噪⾳点较多，可以适当降低这个分位数的值。
3. GBDT类库弱学习器参数
这⾥我们再对GBDT的类库弱学习器的重要参数做⼀个总结。由于GBDT使⽤了CART回归决策树，因此它的参数基本来源于决策树类，也就是说，和DecisionTreeClassifier和DecisionTreeRegressor的参数基本类似。如果你已经很熟悉决策树算法的调参，那么这⼀节基本可以跳过。不熟悉的朋友可以继续看下去。
1) 划分时考虑的最⼤特征数max_features: 可以使⽤很多种类型的值，默认是"None"，意味着划分时考虑所有的特征数；如果是"log2"意味着划分时最多考虑log2Nlog2N个特征；如果是"sqrt"或者"auto"意味着划分时最多考虑N−−√N个特征。如果是整数，代表考虑的特征绝对数。如果是浮点数，代表考虑特征百分⽐，即考虑（百分⽐xN）取整后的特征数。其中N为样本总特征数。⼀般来说，如果样本特征数不多，⽐如⼩于50，我们⽤默认的"None"就可以了，如果特征数⾮常多，我们可以灵活使⽤刚才描述的其他取值来控制划分时考虑的最⼤特征数，以控制决策树的⽣成时间。
2) 决策树最⼤深度max_depth: 默认可以不输⼊，如果不输⼊的话，决策树在建⽴⼦树的时候不会限制⼦树的深度。⼀般来说，数据少或者特征少的时候可以不管这个值。如果模型样本量多，特征也多的情况下，推荐限制这个最⼤深度，具体的取值取决于数据的分布。常⽤的可以取值10-100之间。
3) 内部节点再划分所需最⼩样本数min_samples_split: 这个值限制了⼦树继续划分的条件，如果某节点的样本数少于
min_samples_split，则不会继续再尝试选择最优特征来进⾏划分。默认是2.如果样本量不⼤，不需要管这个值。如果样本量数量级⾮常
⼤，则推荐增⼤这个值。
4) 叶⼦节点最少样本数min_samples_leaf: 这个值限制了叶⼦节点最少的样本数，如果某叶⼦节点数⽬⼩于样本数，则会和兄弟节点⼀起被剪枝。默认是1，可以输⼊最少的样本数的整数，或者最少样本数占样本总数的百分⽐。如果样本量不⼤，不需要管这个值。如果样本量数量级⾮常⼤，则推荐增⼤这个值。
5）叶⼦节点最⼩的样本权重和min_weight_fraction_leaf：这个值限制了叶⼦节点所有样本权重和的最⼩值，如果⼩于这个值，则会和兄弟节点⼀起被剪枝。默认是0，就是不考虑权重问题。⼀般来说，如果我们有较多样本有缺失值，或者分类树样本的分布类别偏差很⼤，就会引⼊样本权重，这时我们就要注意这个值了。
6) 最⼤叶⼦节点数max_leaf_nodes: 通过限制最⼤叶⼦节点数，可以防⽌过拟合，默认是"None”，即不限制最⼤的叶⼦节点数。如果加了限制，算法会建⽴在最⼤叶⼦节点数内最优的决策树。如果特征不多，可以不考虑这个值，但是如果特征分成多的话，可以加以限制，具体的值可以通过交叉验证得到。
7) 节点划分最⼩不纯度min_impurity_split: 这个值限制了决策树的增长，如果某节点的不纯度(基于基尼系数，均⽅差)⼩于这个阈值，则该节点不再⽣成⼦节点。即为叶⼦节点。⼀般不推荐改动默认值1e-7。
4. GBDT调参实例
这⾥我们⽤⼀个⼆元分类的例⼦来讲解下GBDT的调参。这部分参考了这个Github上的数据调参过程。这个例⼦的数据有87000多⾏，单机跑会⽐较慢，下⾯的例⼦我只选择了它的前⾯20000⾏，我将其打包后，。
⾸先，我们载⼊需要的类库：
import pandas as pd
import numpy as np
ble import GradientBoostingClassifier
from sklearn import cross_validation, metrics
id_arch import GridSearchCV
import matplotlib.pylab as plt
春节团拜会%matplotlib inline
接着，我们把解压的数据⽤下⾯的代码载⼊，顺便看看数据的类别分布。
train = pd.read_csv('train_modified.csv')
target='Disburd' # Disburd的值就是⼆元分类的输出
IDcol = 'ID'
train['Disburd'].value_counts()
可以看到类别输出如下，也就是类别0的占⼤多数。
0 19680
1 320
Name: Disburd, dtype: int64
现在我们得到我们的训练集。最后⼀列Disburd是分类输出。前⾯的所有列（不考虑ID列）都是样本特征。
x_columns = [x for x lumns if x not in [target, IDcol]]
X = train[x_columns]
y = train['Disburd']
不管任何参数，都⽤默认的，我们拟合下数据看看：
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)
print "AUC Score (Train): %f" % _auc_score(y, y_predprob)
输出如下，可见拟合还可以，我们下⾯看看怎么通过调参提⾼模型的泛化能⼒。
Accuracy : 0.9852
AUC Score (Train): 0.900531
⾸先我们从步长(learning rate)和迭代次数(n_estimators)⼊⼿。⼀般来说，开始选择⼀个较⼩的步长来⽹格搜索最好的迭代次数。这⾥，我们将步长初始值设置为0.1。对于迭代次数进⾏⽹格搜索如下：
param_test1 = {'n_estimators':range(20,81,10)}
garch1 = 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=Fal,cv=5)
garch1.fit(X,y)
输出如下，可见最好的迭代次数是60。
我情我色([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.81751, std: 0.01736, params: {'n_estimators': 60},
mean: 0.81547, std: 0.01900, params: {'n_estimators': 70},
mean: 0.81299, std: 0.01860, params: {'n_estimators': 80}],
{'n_estimators': 60},
0.8175146087398375)
找到了⼀个合适的迭代次数，现在我们开始对决策树进⾏调参。⾸先我们对决策树最⼤深度max_depth和内部节点再划分所需最⼩样本数min_samples_split进⾏⽹格搜索。
param_test2 = {'max_depth':range(3,14,2), 'min_samples_split':range(100,801,200)}
garch2 = 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=Fal, cv=5)
garch2.fit(X,y)
输出如下，可见最好的最⼤树深度是7，内部节点再划分所需最⼩样本数是300。
([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.81807, std: 0.02004, 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.81107, std: 0.02178, params: {'min_samples_split': 100, 'max_depth': 9},
mean: 0.80944, std: 0.02612, 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.81091, std: 0.02227, params: {'min_samples_split': 100, 'max_depth': 11},
mean: 0.81309, std: 0.02696, params: {'min_samples_split': 300, 'max_depth': 11},
mean: 0.81713, std: 0.02379, params: {'min_samples_split': 500, 'max_depth': 11},
mean: 0.81347, std: 0.02702, params: {'min_samples_split': 700, 'max_depth': 11},
mean: 0.81444, std: 0.01813, params: {'min_samples_split': 100, 'max_depth': 13},
mean: 0.80825, std: 0.02291, params: {'min_samples_split': 300, 'max_depth': 13},
mean: 0.81923, std: 0.01693, params: {'min_samples_split': 500, 'max_depth': 13},
mean: 0.81382, std: 0.02258, params: {'min_samples_split': 700, 'max_depth': 13}],
{'max_depth': 7, 'min_samples_split': 300},
0.8213724275914632)
ysl是什么
由于决策树深度7是⼀个⽐较合理的值，我们把它定下来，对于内部节点再划分所需最⼩样本数min_samples_split，我们暂时不能⼀起定下来，因为这个还和决策树其他的参数存在关联。下⾯我们再对内部节点再划分所需最⼩样本数min_samples_split和叶⼦节点最少样本数min_samples_leaf⼀起调参。
param_test3 = {'min_samples_split':range(800,1900,200), 'min_samples_leaf':range(60,101,10)}
garch3 = 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=Fal, cv=5)
garch3.fit(X,y)
输出结果如下，可见这个min_samples_split在边界值，还有进⼀步调试⼩于边界60的必要。由于这⾥只是例⼦，所以⼤家可以⾃⼰下来⽤包含⼩于60的⽹格搜索来寻找合适的值。
([mean: 0.81828, std: 0.02251, params: {'min_samples_split': 800, 'min_samples_leaf': 60},
mean: 0.81731, std: 0.02344, params: {'min_samples_split': 1000, 'min_samples_leaf': 60},
mean: 0.82220, std: 0.02250, params: {'min_samples_split': 1200, 'min_samples_leaf': 60},
mean: 0.81447, std: 0.02125, params: {'min_samples_split': 1400, 'min_samples_leaf': 60},
mean: 0.81495, std: 0.01626, params: {'min_samples_split': 1600, 'min_samples_leaf': 60},
mean: 0.81528, std: 0.02140, params: {'min_samples_split': 1800, 'min_samples_leaf': 60},
mean: 0.81590, std: 0.02517, params: {'min_samples_split': 800, 'min_samples_leaf': 70},
mean: 0.81573, std: 0.02207, params: {'min_samples_split': 1000, 'min_samples_leaf': 70},
mean: 0.82021, std: 0.02521, params: {'min_samples_split': 1200, 'min_samples_leaf': 70},
mean: 0.81512, std: 0.01995, params: {'min_samples_split': 1400, 'min_samples_leaf': 70},
饺子的传说
mean: 0.81395, std: 0.02081, params: {'min_samples_split': 1600, 'min_samples_leaf': 70},
mean: 0.81587, std: 0.02082, params: {'min_samples_split': 1800, 'min_samples_leaf': 70},
mean: 0.82064, std: 0.02698, params: {'min_samples_split': 800, 'min_samples_leaf': 80},
mean: 0.81490, std: 0.02475, params: {'min_samples_split': 1000, 'min_samples_leaf': 80},
mean: 0.82009, std: 0.02568, params: {'min_samples_split': 1200, 'min_samples_leaf': 80},
mean: 0.81850, std: 0.02226, params: {'min_samples_split': 1400, 'min_samples_leaf': 80},
漂亮的花图片mean: 0.81855, std: 0.02099, params: {'min_samples_split': 1600, 'min_samples_leaf': 80},
mean: 0.81666, std: 0.02249, params: {'min_samples_split': 1800, 'min_samples_leaf': 80},
mean: 0.81960, std: 0.02437, params: {'min_samples_split': 800, 'min_samples_leaf': 90},
mean: 0.81560, std: 0.02235, params: {'min_samples_split': 1000, 'min_samples_leaf': 90},
mean: 0.81936, std: 0.02542, params: {'min_samples_split': 1200, 'min_samples_leaf': 90},
mean: 0.81362, std: 0.02254, params: {'min_samples_split': 1400, 'min_samples_leaf': 90},
mean: 0.81429, std: 0.02417, params: {'min_samples_split': 1600, 'min_samples_leaf': 90},
mean: 0.81299, std: 0.02262, params: {'min_samples_split': 1800, 'min_samples_leaf': 90},
mean: 0.82000, std: 0.02511, params: {'min_samples_split': 800, 'min_samples_leaf': 100},
mean: 0.82209, std: 0.01816, params: {'min_samples_split': 1000, 'min_samples_leaf': 100},
mean: 0.81821, std: 0.02337, params: {'min_samples_split': 1200, 'min_samples_leaf': 100},
mean: 0.81922, std: 0.02377, params: {'min_samples_split': 1400, 'min_samples_leaf': 100},
mean: 0.81545, std: 0.02221, params: {'min_samples_split': 1600, 'min_samples_leaf': 100},
mean: 0.81704, std: 0.02509, params: {'min_samples_split': 1800, 'min_samples_leaf': 100}],
{'min_samples_leaf': 60, 'min_samples_split': 1200},
0.8222032996697154)
我们调了这么多参数了，终于可以都放到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]
print "Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred)
print "AUC Score (Train): %f" % _auc_score(y, y_predprob)
输出如下：
Accuracy : 0.984
AUC Score (Train): 0.908099
对⽐我们最开始完全不调参的拟合效果，可见精确度稍有下降，主要原理是我们使⽤了0.8的⼦采样，20%的数据没有参与拟合。
现在我们再对最⼤特征数max_features进⾏⽹格搜索。
param_test4 = {'max_features':range(7,20,2)}
garch4 = 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=Fal, cv=5)
garch4.fit(X,y)
输出如下：
([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)
自制南瓜饼 现在我们再对⼦采样的⽐例进⾏⽹格搜索：
param_test5 = {'subsample':[0.6,0.7,0.75,0.8,0.85,0.9]}
garch5 = 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=Fal, cv=5)
garch5.fit(X,y)
输出如下：
([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)
现在我们基本已经得到我们所有调优的参数结果了。这时我们可以减半步长，最⼤迭代次数加倍来增加我们模型的泛化能⼒。再次拟合我们的模型：
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]
print "Accuracy : %.4g" % metrics.accuracy_score(y.values, y_pred)
print "AUC Score (Train): %f" % _auc_score(y, y_predprob)
输出如下：初中日记300字
Accuracy : 0.984
AUC Score (Train): 0.905324
可以看到AUC分数⽐起之前的版本稍有下降，这个原因是我们为了增加模型泛化能⼒，为防⽌过拟合⽽减半步长，最⼤迭代次数加倍，同时减⼩了⼦采样的⽐例，从⽽减少了训练集的拟合程度。
下⾯我们继续将步长缩⼩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)
print "AUC Score (Train): %f" % _auc_score(y, y_predprob)
输出如下，可见减⼩步长增加迭代次数可以在保证泛化能⼒的基础上增加⼀些拟合程度。
Accuracy : 0.984
AUC Score (Train): 0.908581
最后我们继续步长缩⼩⼀半，最⼤迭代次数增加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)
print "AUC Score (Train): %f" % _auc_score(y, y_predprob)
输出如下，此时由于步长实在太⼩，导致拟合效果反⽽变差，也就是说，步长不能设置的过⼩。
Accuracy : 0.984
AUC Score (Train): 0.908232
以上就是GBDT调参的⼀个总结，希望可以帮到朋友们
