sklearn随机森林调参小结

最新推荐文章于 2023-12-19 18:05:55 发布

搏击俱乐部_

最新推荐文章于 2023-12-19 18:05:55 发布

阅读量1.5k

点赞数 1

原文链接

$\qquad$ 本文就从实践的角度对RF做一个总结。重点讲述scikit-learn中RF的调参注意事项，以及和GBDT调参的异同点。

1. sklearn随机森林类库概述

$\qquad$ 在sklearn中，RF的分类类是RandomForestClassifier，回归类是RandomForestRegressor。当然RF的变种Extra Trees也有，分类类ExtraTreesClassifier，回归类ExtraTreesRegressor。由于RF和Extra Trees的区别较小，调参方法基本相同，本文只关注于RF的调参。

$\qquad$ 和GBDT的调参类似，RF需要调参的参数也包括两部分，第一部分是Bagging框架的参数，第二部分是CART决策树的参数。下面我们就对这些参数做一个介绍。

2. RF框架参数

$\qquad$ 首先我们关注于RF的Bagging框架的参数。这里可以和GBDT对比来学习。在sklearn梯度提升树(GBDT)调参小结中我们对GBDT的框架参数做了介绍。GBDT的框架参数比较多，重要的有最大迭代器个数，步长和子采样比例，调参起来比较费力。但是RF则比较简单，这是因为bagging框架里的各个弱学习器之间是没有依赖关系的，这减小的调参的难度。换句话说，达到同样的调参效果，RF调参时间要比GBDT少一些。

$\qquad$ 下面我来看看RF重要的Bagging框架的参数，由于RandomForestClassifier和RandomForestRegressor参数绝大部分相同，这里会将它们一起讲，不同点会指出。

$\qquad$ 1) n_estimators: 也就是弱学习器的最大迭代次数，或者说最大的弱学习器的个数。一般来说n_estimators太小，容易欠拟合，n_estimators太大，计算量会太大，并且n_estimators到一定的数量后，再增大n_estimators获得的模型提升会很小，所以一般选择一个适中的数值。默认是100。

$\qquad$ 2) oob_score :即是否采用袋外样本来评估模型的好坏。默认识False。个人推荐设置为True，因为袋外分数反应了一个模型拟合后的泛化能力。

$\qquad$ 3) criterion: 即CART树做划分时对特征的评价标准。分类模型和回归模型的损失函数是不一样的。分类RF对应的CART分类树默认是基尼系数gini,另一个可选择的标准是信息增益。回归RF对应的CART回归树默认是均方差mse，另一个可以选择的标准是绝对值差mae。一般来说选择默认的标准就已经很好的。

$\qquad$ 从上面可以看出， RF重要的框架参数比较少，主要需要关注的是 n_estimators，即RF最大的决策树个数。

3. RF决策树参数

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

4.RF调参实例

$\qquad$ 样例数据下载

$\qquad$ 首先，我们载入需要的类库：

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

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

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

$\qquad$ 接着我们选择好样本特征和类别输出。

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

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

rf0 = RandomForestClassifier(oob_score=True, random_state=10)
rf0.fit(X, y)
y_predprob = rf0.predict_proba(X)[:, 1]
print(rf0.oob_score_)  # 0.98005
print("AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob))  # AUC Score (Train): 0.999833

$\qquad$ 输出如下，可见袋外分数已经很高，而且AUC分数也很高。相对于GBDT的默认参数输出，RF的默认参数拟合效果对本例要好一些。
$\qquad$ 我们首先对n_estimators进行网格搜索：

param_test1 = {'n_estimators': range(10, 71, 10)}
gsearch1 = GridSearchCV(
    estimator=RandomForestClassifier(min_samples_split=100, min_samples_leaf=20, max_depth=8,
                                     max_features='sqrt', random_state=10),
    param_grid=param_test1, scoring='roc_auc', cv=5)
gsearch1.fit(X, y)
print(gsearch1.grid_scores_, gsearch1.best_params_, gsearch1.best_score_)
"""
[mean: 0.80681, std: 0.02236, params: {'n_estimators': 10}, 
mean: 0.81600, std: 0.03275, params: {'n_estimators': 20}, 
mean: 0.81818, std: 0.03136, params: {'n_estimators': 30},
mean: 0.81838, std: 0.03118, params: {'n_estimators': 40}, 
mean: 0.82034, std: 0.03001, params: {'n_estimators': 50}, 
mean: 0.82113, std: 0.02966, params: {'n_estimators': 60}, 
mean: 0.81992, std: 0.02836, params: {'n_estimators': 70}] 

{'n_estimators': 60} 

0.8211334476626017
"""

$\qquad$ 这样我们得到了最佳的弱学习器迭代次数，接着我们对决策树最大深度max_depth和内部节点再划分所需最小样本数min_samples_split进行网格搜索。

param_test2 = {'max_depth': range(3, 14, 2), 'min_samples_split': range(50, 201, 20)}
gsearch2 = GridSearchCV(
    estimator=RandomForestClassifier(n_estimators=60, min_samples_leaf=20, max_features='sqrt',
                                     oob_score=True, 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.79379, std: 0.02347, params: {'max_depth': 3, 'min_samples_split': 50}, 
mean: 0.79339, std: 0.02410, params: {'max_depth': 3, 'min_samples_split': 70}, 
mean: 0.79350, std: 0.02462, params: {'max_depth': 3, 'min_samples_split': 90}, 
mean: 0.79367, std: 0.02493, params: {'max_depth': 3, 'min_samples_split': 110}, 
mean: 0.79387, std: 0.02521, params: {'max_depth': 3, 'min_samples_split': 130}, 
mean: 0.79373, std: 0.02524, params: {'max_depth': 3, 'min_samples_split': 150}, 
mean: 0.79378, std: 0.02532, params: {'max_depth': 3, 'min_samples_split': 170}, 
mean: 0.79349, std: 0.02542, params: {'max_depth': 3, 'min_samples_split': 190}, 
mean: 0.80960, std: 0.02602, params: {'max_depth': 5, 'min_samples_split': 50}, 
mean: 0.80920, std: 0.02629, params: {'max_depth': 5, 'min_samples_split': 70}, 
mean: 0.80888, std: 0.02522, params: {'max_depth': 5, 'min_samples_split': 90}, 
mean: 0.80923, std: 0.02777, params: {'max_depth': 5, 'min_samples_split': 110}, 
mean: 0.80823, std: 0.02634, params: {'max_depth': 5, 'min_samples_split': 130}, 
mean: 0.80801, std: 0.02637, params: {'max_depth': 5, 'min_samples_split': 150}, 
mean: 0.80792, std: 0.02685, params: {'max_depth': 5, 'min_samples_split': 170}, 
mean: 0.80771, std: 0.02587, params: {'max_depth': 5, 'min_samples_split': 190}, 
mean: 0.81688, std: 0.02996, params: {'max_depth': 7, 'min_samples_split': 50}, 
mean: 0.81872, std: 0.02584, params: {'max_depth': 7, 'min_samples_split': 70}, 
mean: 0.81501, std: 0.02857, params: {'max_depth': 7, 'min_samples_split': 90}, 
mean: 0.81476, std: 0.02552, params: {'max_depth': 7, 'min_samples_split': 110}, 
mean: 0.81557, std: 0.02791, params: {'max_depth': 7, 'min_samples_split': 130}, 
mean: 0.81459, std: 0.02905, params: {'max_depth': 7, 'min_samples_split': 150}, 
mean: 0.81601, std: 0.02808, params: {'max_depth': 7, 'min_samples_split': 170}, 
mean: 0.81704, std: 0.02757, params: {'max_depth': 7, 'min_samples_split': 190}, 
mean: 0.82090, std: 0.02665, params: {'max_depth': 9, 'min_samples_split': 50}, 
mean: 0.81908, std: 0.02527, params: {'max_depth': 9, 'min_samples_split': 70}, 
mean: 0.82036, std: 0.02422, params: {'max_depth': 9, 'min_samples_split': 90}, 
mean: 0.81889, std: 0.02927, params: {'max_depth': 9, 'min_samples_split': 110}, 
mean: 0.81991, std: 0.02868, params: {'max_depth': 9, 'min_samples_split': 130}, 
mean: 0.81788, std: 0.02436, params: {'max_depth': 9, 'min_samples_split': 150}, 
mean: 0.81898, std: 0.02588, params: {'max_depth': 9, 'min_samples_split': 170}, 
mean: 0.81746, std: 0.02716, params: {'max_depth': 9, 'min_samples_split': 190}, 
mean: 0.82395, std: 0.02454, params: {'max_depth': 11, 'min_samples_split': 50}, 
mean: 0.82380, std: 0.02258, params: {'max_depth': 11, 'min_samples_split': 70}, 
mean: 0.81953, std: 0.02552, params: {'max_depth': 11, 'min_samples_split': 90}, 
mean: 0.82254, std: 0.02366, params: {'max_depth': 11, 'min_samples_split': 110}, 
mean: 0.81950, std: 0.02768, params: {'max_depth': 11, 'min_samples_split': 130}, 
mean: 0.81887, std: 0.02636, params: {'max_depth': 11, 'min_samples_split': 150}, 
mean: 0.81910, std: 0.02734, params: {'max_depth': 11, 'min_samples_split': 170}, 
mean: 0.81564, std: 0.02622, params: {'max_depth': 11, 'min_samples_split': 190}, 
mean: 0.82291, std: 0.02092, params: {'max_depth': 13, 'min_samples_split': 50}, 
mean: 0.82177, std: 0.02513, params: {'max_depth': 13, 'min_samples_split': 70}, 
mean: 0.82415, std: 0.02480, params: {'max_depth': 13, 'min_samples_split': 90}, 
mean: 0.82420, std: 0.02417, params: {'max_depth': 13, 'min_samples_split': 110}, 
mean: 0.82209, std: 0.02481, params: {'max_depth': 13, 'min_samples_split': 130}, 
mean: 0.81852, std: 0.02227, params: {'max_depth': 13, 'min_samples_split': 150}, 
mean: 0.81955, std: 0.02885, params: {'max_depth': 13, 'min_samples_split': 170}, 
mean: 0.82092, std: 0.02600, params: {'max_depth': 13, 'min_samples_split': 190}] 

{'max_depth': 13, 'min_samples_split': 110} 

0.8242016800050813
"""

$\qquad$ 我们看看我们现在模型的袋外分数：

rf1 = RandomForestClassifier(n_estimators=60, max_depth=13, min_samples_split=110,
                             min_samples_leaf=20, max_features='sqrt', oob_score=True, random_state=10)
rf1.fit(X, y)
y_predprob = rf0.predict_proba(X)[:, 1]
print(rf1.oob_score_)  # 0.984
print("AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob))  # AUC Score (Train): 0.999833

$\qquad$ 可见此时我们的袋外分数有一定的提高。也就是时候模型的泛化能力增强了。

$\qquad$ 对于内部节点再划分所需最小样本数min_samples_split，我们暂时不能一起定下来，因为这个还和决策树其他的参数存在关联。下面我们再对内部节点再划分所需最小样本数min_samples_split和叶子节点最少样本数min_samples_leaf一起调参。

param_test3 = {'min_samples_split': range(80, 150, 20), 'min_samples_leaf': range(10, 60, 10)}
gsearch3 = GridSearchCV(
    estimator=RandomForestClassifier(n_estimators=60, max_depth=13, max_features='sqrt', oob_score=True,
                                     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.82093, std: 0.02287, params: {'min_samples_split': 80, 'min_samples_leaf': 10}, 
 mean: 0.81913, std: 0.02141, params: {'min_samples_split': 100, 'min_samples_leaf': 10}, 
 mean: 0.82048, std: 0.02328, params: {'min_samples_split': 120, 'min_samples_leaf': 10},
 mean: 0.81798, std: 0.02099, params: {'min_samples_split': 140, 'min_samples_leaf': 10}, 
 mean: 0.82094, std: 0.02535, params: {'min_samples_split': 80, 'min_samples_leaf': 20}, 
 mean: 0.82097, std: 0.02327, params: {'min_samples_split': 100, 'min_samples_leaf': 20}, 
 mean: 0.82487, std: 0.02110, params: {'min_samples_split': 120, 'min_samples_leaf': 20}, 
 mean: 0.82169, std: 0.02406, params: {'min_samples_split': 140, 'min_samples_leaf': 20}, 
 mean: 0.82352, std: 0.02271, params: {'min_samples_split': 80, 'min_samples_leaf': 30}, 
 mean: 0.82164, std: 0.02381, params: {'min_samples_split': 100, 'min_samples_leaf': 30}, 
 mean: 0.82070, std: 0.02528, params: {'min_samples_split': 120, 'min_samples_leaf': 30}, 
 mean: 0.82141, std: 0.02508, params: {'min_samples_split': 140, 'min_samples_leaf': 30}, 
 mean: 0.82278, std: 0.02294, params: {'min_samples_split': 80, 'min_samples_leaf': 40}, 
 mean: 0.82141, std: 0.02547, params: {'min_samples_split': 100, 'min_samples_leaf': 40}, 
 mean: 0.82043, std: 0.02724, params: {'min_samples_split': 120, 'min_samples_leaf': 40}, 
 mean: 0.82162, std: 0.02348, params: {'min_samples_split': 140, 'min_samples_leaf': 40}, 
 mean: 0.82225, std: 0.02431, params: {'min_samples_split': 80, 'min_samples_leaf': 50}, 
 mean: 0.82225, std: 0.02431, params: {'min_samples_split': 100, 'min_samples_leaf': 50}, 
 mean: 0.81890, std: 0.02458, params: {'min_samples_split': 120, 'min_samples_leaf': 50}, 
 mean: 0.81917, std: 0.02528, params: {'min_samples_split': 140, 'min_samples_leaf': 50}] 
 
 {'min_samples_split': 120, 'min_samples_leaf': 20} 
 
 0.8248650279471544
"""

$\qquad$ 最后我们再对最大特征数max_features做调参:

param_test4 = {'max_features': range(3, 11, 2)}
gsearch4 = GridSearchCV(
    estimator=RandomForestClassifier(n_estimators=60, max_depth=13, min_samples_split=120, min_samples_leaf=20,
                                     oob_score=True, 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.81981, std: 0.02586, params: {'max_features': 3}, 
mean: 0.81639, std: 0.02533, params: {'max_features': 5}, 
mean: 0.82487, std: 0.02110, params: {'max_features': 7}, 
mean: 0.81704, std: 0.02209, params: {'max_features': 9}] 

{'max_features': 7} 

0.8248650279471544
"""

$\qquad$ 用我们搜索到的最佳参数，我们再看看最终的模型拟合：

rf2 = RandomForestClassifier(n_estimators=60, max_depth=13, min_samples_split=120,
                             min_samples_leaf=20, max_features=7, oob_score=True, random_state=10)
rf2.fit(X, y)
y_predprob = rf0.predict_proba(X)[:, 1]
print(rf1.oob_score_)  # 0.984
print("AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob))  # AUC Score (Train): 0.999833

$\qquad$ 可见此时模型的袋外分数基本没有提高，主要原因是0.984已经是一个很高的袋外分数了，如果想进一步需要提高模型的泛化能力，我们需要更多的数据。

搏击俱乐部_

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
sklearn随机森林调参小结

原文链接\qquad本文就从实践的角度对RF做一个总结。重点讲述scikit-learn中RF的调参注意事项，以及和GBDT调参的异同点。1. sklearn随机森林类库概述\qquad在sklearn中，RF的分类类是RandomForestClassifier，回归类是RandomForestRegressor。当然RF的变种Extra Trees也有，分类类ExtraTreesCla...
复制链接

扫一扫