XGBoost，RandomForest，LightGBM的模型参数解释与代码示例

通用参数：宏观函数控制。
Booster参数：控制每一步的booster(tree/regression)。booster参数一般可以调控模型的效果和计算代价。我们所说的调参，很这是大程度上都是在调整booster参数。
学习目标参数：控制训练目标的表现。我们对于问题的划分主要体现在学习目标参数上。比如我们要做分类还是回归，做二分类还是多分类，这都是目标参数所提供的。

Note: 下面介绍的参数都是个人觉得比较重要的。

1.通用参数

booster：我们有两种参数选择，gbtree和gblinear。gbtree是采用树的结构来运行数据，而gblinear是基于线性模型。
silent：静默模式，为1时模型运行不输出。
nthread: 使用线程数，一般我们设置成-1,使用所有线程。如果有需要，我们设置成多少就是用多少线程。

2.Booster参数

n_estimator: 也作num_boosting_rounds

这是生成的最大树的数目，也是最大的迭代次数。

learning_rate: 有时也叫作eta，系统默认值为0.3,。

每一步迭代的步长，很重要。太大了运行准确率不高，太小了运行速度慢。我们一般使用比默认值小一点，0.1左右就很好。

gamma：系统默认为0,我们也常用0。

在节点分裂时，只有分裂后损失函数的值下降了，才会分裂这个节点。gamma指定了节点分裂所需的最小损失函数下降值。这个参数的值越大，算法越保守。因为gamma值越大的时候，损失函数下降更多才可以分裂节点。所以树生成的时候更不容易分裂节点。范围: [0,∞]

subsample：系统默认为1。

这个参数控制对于每棵树，随机采样的比例。减小这个参数的值，算法会更加保守，避免过拟合。但是，如果这个值设置得过小，它可能会导致欠拟合。典型值：0.5-1，0.5代表平均采样，防止过拟合. 范围: (0,1]，注意不可取0

colsample_bytree：系统默认值为1。我们一般设置成0.8左右。

用来控制每棵随机采样的列数的占比(每一列是一个特征)。典型值：0.5-1范围: (0,1]

colsample_bylevel：默认为1,我们也设置为1.

这个就相比于前一个更加细致了，它指的是每棵树每次节点分裂的时候列采样的比例

max_depth：系统默认值为6

我们常用3-10之间的数字。这个值为树的最大深度。这个值是用来控制过拟合的。max_depth越大，模型学习的更加具体。设置为0代表没有限制，范围: [0,∞]

max_delta_step：默认0,我们常用0.

这个参数限制了每棵树权重改变的最大步长，如果这个参数的值为0,则意味着没有约束。如果他被赋予了某一个正值，则是这个算法更加保守。通常，这个参数我们不需要设置，但是当个类别的样本极不平衡的时候，这个参数对逻辑回归优化器是很有帮助的。

lambda:也称reg_lambda,默认值为0。

权重的L2正则化项。(和Ridge regression类似)。这个参数是用来控制XGBoost的正则化部分的。这个参数在减少过拟合上很有帮助。

alpha:也称reg_alpha默认为0,
权重的L1正则化项。(和Lasso regression类似)。可以应用在很高维度的情况下，使得算法的速度更快。
scale_pos_weight：默认为1
在各类别样本十分不平衡时，把这个参数设定为一个正值，可以使算法更快收敛。通常可以将其设置为负样本的数目与正样本数目的比值。

3.学习目标参数

objective [缺省值=reg:linear]

reg:linear– 线性回归
reg:logistic – 逻辑回归
binary:logistic – 二分类逻辑回归，输出为概率
binary:logitraw – 二分类逻辑回归，输出的结果为wTx
count:poisson – 计数问题的poisson回归，输出结果为poisson分布。在poisson回归中，max_delta_step的缺省值为0.7 (used to safeguard optimization)
multi:softmax – 设置 XGBoost 使用softmax目标函数做多分类，需要设置参数num_class（类别个数）
multi:softprob – 如同softmax，但是输出结果为ndata*nclass的向量，其中的值是每个数据分为每个类的概率。

eval_metric [缺省值=通过目标函数选择]

rmse: 均方根误差
mae: 平均绝对值误差
logloss: negative log-likelihood
error: 二分类错误率。其值通过错误分类数目与全部分类数目比值得到。对于预测，预测值大于0.5被认为是正类，其它归为负类。 error@t: 不同的划分阈值可以通过 ‘t’进行设置
merror: 多分类错误率，计算公式为(wrong cases)/(all cases)
mlogloss: 多分类log损失
auc: 曲线下的面积
ndcg: Normalized Discounted Cumulative Gain
map: 平均正确率

一般来说，我们都会使用xgboost.train(params, dtrain)函数来训练我们的模型。这里的params指的是booster参数。

二、XGBoost调参示例

import xgboost as xgb
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

train_data = pd.read_csv('train.csv')   # 读取数据
y = train_data.pop('30').values   # 用pop方式将训练数据中的标签值y取出来，作为训练目标，这里的‘30’是标签的列名
col = train_data.columns   
x = train_data[col].values  # 剩下的列作为训练数据
train_x, valid_x, train_y, valid_y = train_test_split(x, y, test_size=0.333, random_state=0)   # 分训练集和验证集
# 这里不需要Dmatrix

parameters = {
              'max_depth': [5, 10, 15, 20, 25],
              'learning_rate': [0.01, 0.02, 0.05, 0.1, 0.15],
              'n_estimators': [500, 1000, 2000, 3000, 5000],
              'min_child_weight': [0, 2, 5, 10, 20],
              'max_delta_step': [0, 0.2, 0.6, 1, 2],
              'subsample': [0.6, 0.7, 0.8, 0.85, 0.95],
              'colsample_bytree': [0.5, 0.6, 0.7, 0.8, 0.9],
              'reg_alpha': [0, 0.25, 0.5, 0.75, 1],
              'reg_lambda': [0.2, 0.4, 0.6, 0.8, 1],
              'scale_pos_weight': [0.2, 0.4, 0.6, 0.8, 1]

}

xlf = xgb.XGBClassifier(max_depth=10,
            learning_rate=0.01,
            n_estimators=2000,
            silent=True,
            objective='binary:logistic',
            nthread=-1,
            gamma=0,
            min_child_weight=1,
            max_delta_step=0,
            subsample=0.85,
            colsample_bytree=0.7,
            colsample_bylevel=1,
            reg_alpha=0,
            reg_lambda=1,
            scale_pos_weight=1,
            seed=1440,
            missing=None)
            
# 有了gridsearch我们便不需要fit函数
gsearch = GridSearchCV(xlf, param_grid=parameters, scoring='accuracy', cv=3)
gsearch.fit(train_x, train_y)

print("Best score: %0.3f" % gsearch.best_score_)
print("Best parameters set:")
best_parameters = gsearch.best_estimator_.get_params()
for param_name in sorted(parameters.keys()):
    print("\t%s: %r" % (param_name, best_parameters[param_name]))

三、LightGBM参数解释

我们都知道，XGBoost 一共有三类参数通用参数，学习目标参数，Booster参数，那么对于LightGBM，我们有核心参数，学习控制参数，IO参数，目标参数，度量参数，网络参数，GPU参数，模型参数，这里我常修改的便是核心参数，学习控制参数，度量参数等。更详细的请看LightGBM中文文档(https://lightgbm.apachecn.org/#/docs/6)

关键参数一览表

1.核心参数

boosting：也称boost，boosting_type.默认是gbdt。

LGB里面的boosting参数要比xgb多不少，我们有传统的gbdt，也有rf，dart，doss，最后两种不太深入理解，但是试过，还是gbdt的效果比较经典稳定

- gbdt, 传统的梯度提升决策树
- rf, Random Forest (随机森林)
- dart, Dropouts meet Multiple Additive Regression Trees
- goss, Gradient-based One-Side Sampling (基于梯度的单侧采样)
num_thread:也称作num_thread,nthread.指定线程的个数。

这里官方文档提到，数字设置成cpu内核数比线程数训练效更快(考虑到现在cpu大多超线程)。并行学习不应该设置成全部线程，这反而使得训练速度不佳。

application：默认为regression。，也称objective， app这里指的是任务目标
- regression
  - regression_l2, L2 loss, alias=regression, mean_squared_error, mse
  - regression_l1, L1 loss, alias=mean_absolute_error, mae
  - huber, Huber loss
  - fair, Fair loss
  - poisson, Poisson regression
  - quantile, Quantile regression
  - quantile_l2, 类似于 quantile, 但是使用了 L2 loss
- binary, binary log loss classification application
- multi-class classification
  - multiclass, softmax 目标函数, 应该设置好 num_class
  - multiclassova, One-vs-All 二分类目标函数, 应该设置好 num_class
- cross-entropy application
  - xentropy, 目标函数为 cross-entropy (同时有可选择的线性权重), alias=cross_entropy
  - xentlambda, 替代参数化的 cross-entropy, alias=cross_entropy_lambda
  - 标签是 [0, 1] 间隔内的任意值
- lambdarank, lambdarank application
  - 在 lambdarank 任务中标签应该为 int type, 数值越大代表相关性越高 (e.g. 0:bad, 1:fair, 2:good, 3:perfect)
  - label_gain 可以被用来设置 int 标签的增益 (权重)
valid:验证集选用，也称test，valid_data, test_data.支持多验证集，以,分割
learning_rate:也称shrinkage_rate,梯度下降的步长。默认设置成0.1,我们一般设置成0.05-0.2之间
num_leaves:也称num_leaf,新版lgb将这个默认值改成31,这代表的是一棵树上的叶子数，一般这个值小于2^max_depth
num_iterations：也称num_iteration, num_tree, num_trees, num_round, num_rounds,num_boost_round。迭代次数
device：default=cpu, options=cpu, gpu
- 为树学习选择设备, 你可以使用 GPU 来获得更快的学习速度
- Note: 建议使用较小的 max_bin (e.g. 63) 来获得更快的速度
- Note: 为了加快学习速度, GPU 默认使用32位浮点数来求和. 你可以设置 gpu_use_dp=true 来启用64位浮点数, 但是它会使训练速度降低
- Note: 请参考安装指南来构建 GPU 版本

2.学习控制参数

max_depth

default=-1, type=int限制树模型的最大深度. 这可以在 #data 小的情况下防止过拟合. 树仍然可以通过 leaf-wise 生长.
< 0 意味着没有限制.

feature_fraction：default=1.0, type=double, 0.0 < feature_fraction < 1.0, 也称sub_feature, colsample_bytree
- 如果 feature_fraction 小于 1.0, LightGBM 将会在每次迭代中随机选择部分特征. 例如, 如果设置为 0.8, 将会在每棵树训练之前选择 80% 的特征
- 可以用来加速训练
- 可以用来处理过拟合
bagging_fraction：default=1.0, type=double, 0.0 < bagging_fraction < 1.0, 也称sub_row, subsample
- 类似于 feature_fraction, 但是它将在不进行重采样的情况下随机选择部分数据
- 可以用来加速训练
- 可以用来处理过拟合
- Note: 为了启用 bagging, bagging_freq 应该设置为非零值
bagging_freq： default=0, type=int, 也称subsample_freq
- bagging 的频率, 0 意味着禁用 bagging. k 意味着每 k 次迭代执行bagging
- Note: 为了启用 bagging, bagging_fraction 设置适当
lambda_l1:默认为0,也称reg_alpha，表示的是L1正则化,double类型
lambda_l2:默认为0,也称reg_lambda，表示的是L2正则化，double类型
cat_smooth： default=10, type=double
- 用于分类特征
- 这可以降低噪声在分类特征中的影响, 尤其是对数据很少的类别
min_data_in_leaf , 默认为20。也称min_data_per_leaf , min_data, min_child_samples。
一个叶子上数据的最小数量。可以用来处理过拟合。
min_sum_hessian_in_leaf, default=1e-3, 也称min_sum_hessian_per_leaf, min_sum_hessian, min_hessian, min_child_weight。
- 一个叶子上的最小 hessian 和. 类似于 min_data_in_leaf, 可以用来处理过拟合.
- 子节点所需的样本权重和(hessian)的最小阈值，若是基学习器切分后得到的叶节点中样本权重和低于该阈值则不会进一步切分，在线性模型中该值就对应每个节点的最小样本数，该值越大模型的学习约保守，同样用于防止模型过拟合
early_stopping_round, 默认为0, type=int, 也称early_stopping_rounds, early_stopping。
如果一个验证集的度量在 early_stopping_round 循环中没有提升, 将停止训练、
min_split_gain, 默认为0, type=double, 也称min_gain_to_split`。执行切分的最小增益。
max_bin：最大直方图数目，默认为255，工具箱的最大数特征值决定了容量工具箱的最小数特征值可能会降低训练的准确性, 但是可能会增加一些一般的影响（处理过拟合，越大越容易过拟合）。
- 针对直方图算法tree_method=hist时，用来控制将连续值特征离散化为多个直方图的直方图数目。
- LightGBM 将根据 max_bin 自动压缩内存。例如, 如果 maxbin=255, 那么 LightGBM 将使用 uint8t 的特性值。
  12.subsample_for_bin
  bin_construct_sample_cnt, 默认为200000, 也称subsample_for_bin。用来构建直方图的数据的数量。

3.度量函数

metric： default={l2 for regression}, {binary_logloss for binary classification}, {ndcg for lambdarank}, type=multi-enum, options=l1, l2, ndcg, auc, binary_logloss, binary_error …
- l1, absolute loss, alias=mean_absolute_error, mae
- l2, square loss, alias=mean_squared_error, mse
- l2_root, root square loss, alias=root_mean_squared_error, rmse
- quantile, Quantile regression
- huber, Huber loss
- fair, Fair loss
- poisson, Poisson regression
- ndcg, NDCG
- map, MAP
- auc, AUC
- binary_logloss, log loss
- binary_error, 样本: 0 的正确分类, 1 错误分类
- multi_logloss, mulit-class 损失日志分类
- multi_error, error rate for mulit-class 出错率分类
- xentropy, cross-entropy (与可选的线性权重), alias=cross_entropy
- xentlambda, “intensity-weighted” 交叉熵, alias=cross_entropy_lambda
- kldiv, Kullback-Leibler divergence, alias=kullback_leibler
- 支持多指标, 使用 , 分隔

总的来说，我还是觉得LightGBM比XGBoost用法上差距不大。参数也有很多重叠的地方。

很多XGBoost的核心原理放在LightGBM上同样适用。同样的，Lgb也是有train()函数和LGBClassifier()与LGBRegressor()函数。后两个主要是为了更加贴合sklearn的用法，这一点和XGBoost一样。

四、LightGBM调参示例

import pandas as pd
import lightgbm as lgb
from sklearn.grid_search import GridSearchCV  # Perforing grid search
from sklearn.model_selection import train_test_split

train_data = pd.read_csv('train.csv')   # 读取数据
y = train_data.pop('30').values   # 用pop方式将训练数据中的标签值y取出来，作为训练目标，这里的‘30’是标签的列名
col = train_data.columns   
x = train_data[col].values  # 剩下的列作为训练数据
train_x, valid_x, train_y, valid_y = train_test_split(x, y, test_size=0.333, random_state=0)   # 分训练集和验证集
train = lgb.Dataset(train_x, train_y)
valid = lgb.Dataset(valid_x, valid_y, reference=train)


parameters = {
              'max_depth': [15, 20, 25, 30, 35],
              'learning_rate': [0.01, 0.02, 0.05, 0.1, 0.15],
              'feature_fraction': [0.6, 0.7, 0.8, 0.9, 0.95],
              'bagging_fraction': [0.6, 0.7, 0.8, 0.9, 0.95],
              'bagging_freq': [2, 4, 5, 6, 8],
              'lambda_l1': [0, 0.1, 0.4, 0.5, 0.6],
              'lambda_l2': [0, 10, 15, 35, 40],
              'cat_smooth': [1, 10, 15, 20, 35]
}
gbm = lgb.LGBMClassifier(boosting_type='gbdt',
                         objective = 'binary',
                         metric = 'auc',
                         verbose = 0,
                         learning_rate = 0.01,
                         num_leaves = 35,
                         feature_fraction=0.8,
                         bagging_fraction= 0.9,
                         bagging_freq= 8,
                         lambda_l1= 0.6,
                         lambda_l2= 0)
# 有了gridsearch我们便不需要fit函数
gsearch = GridSearchCV(gbm, param_grid=parameters, scoring='accuracy', cv=3)
gsearch.fit(train_x, train_y)

print("Best score: %0.3f" % gsearch.best_score_)
print("Best parameters set:")
best_parameters = gsearch.best_estimator_.get_params()
for param_name in sorted(parameters.keys()):
    print("\t%s: %r" % (param_name, best_parameters[param_name]))

五、XGBoost和LightGBM调参核心

调参1：提高准确率"：num_leaves, max_depth, learning_rate
调参2：降低过拟合 max_bin min_data_in_leaf
调参3：降低过拟合正则化L1, L2
调参4：降低过拟合数据抽样列抽样

调参方向：处理过拟合（过拟合和准确率往往相反）

使用较小的 max_bin
使用较小的 num_leaves
使用 min_data_in_leaf 和 min_sum_hessian_in_leaf
通过设置 bagging_fraction 和 bagging_freq 来使用 bagging
通过设置 feature_fraction <1来使用特征抽样
使用更大的训练数据
使用 lambda_l1, lambda_l2 和 min_gain_to_split 来使用正则
尝试 max_depth 来避免生成过深的树

调参范围

	XGBoost	LightGBM	范围
叶子数	num_leaves，默认为	num_leaves	range(35,65,5)
树深	max_depth，默认为6	max_depth	range(3,10,2)
样本抽样	subsample	bagging_fraction，subsample	[i/10.0 for i in range(6,10)]
特征抽样	colsample_bytree	feature_fraction，colsample_bytree	[i/10.0 for i in range(6,10)]
L1正则化	alpha，reg_alpha	lambda_l2，reg_alpha	[1e-5, 1e-2, 0.1, 1, 2,2.5,3]
L2正则化	lambda，reg_lambda	lambda_l1，reg_lambda	[1e-5, 1e-2, 0.1, 1, 2,2.5,3]

参考：https://www.jianshu.com/p/1100e333fcab

六、RandomForest参数解释

1.框架参数

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

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

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

重要参数情况一览表

参考：https://www.cnblogs.com/yujingwei/p/11074613.html

2.决策树参数

1. max_features: RF划分时考虑的最大特征数。可以使用很多种类型的值，默认是"auto",意味着划分时最多考虑N−−√N个特征；如果是"log2"意味着划分时最多考虑log2Nlog2N个特征；如果是"sqrt"或者"auto"意味着划分时最多考虑N−−√N个特征。如果是整数，代表考虑的特征绝对数。如果是浮点数，代表考虑特征百分比，即考虑（百分比xN）取整后的特征数。其中N为样本总特征数。一般我们用默认的"auto"就可以了，如果特征数非常多，我们可以灵活使用刚才描述的其他取值来控制划分时考虑的最大特征数，以控制决策树的生成时间。

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。

    上面决策树参数中最重要的包括最大特征数max_features， 最大深度max_depth， 内部节点再划分所需最小样本数min_samples_split和叶子节点最少样本数min_samples_leaf。

七、RandomForest调参示例

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.grid_search import GridSearchCV
from sklearn import cross_validation, metrics

import matplotlib.pylab as plt
#导入数据
train = pd.read_csv('train_modified.csv')
target='Disbursed' # Disbursed的值就是二元分类的输出
IDcol = 'ID'
train['Disbursed'].value_counts() 

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

#默认模型参数的结果
rf0 = RandomForestClassifier(oob_score=True, random_state=10)
rf0.fit(X,y)
print rf0.oob_score_
y_predprob = rf0.predict_proba(X)[:,1]
print "AUC Score (Train): %f" % metrics.roc_auc_score(y, y_predprob)

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)
gsearch1.grid_scores_, gsearch1.best_params_, gsearch1.best_score_

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)
gsearch2.grid_scores_, gsearch2.best_params_, gsearch2.best_score_

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)
print rf1.oob_score_


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)
gsearch3.grid_scores_, gsearch3.best_params_, gsearch3.best_score_

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)
gsearch4.grid_scores_, gsearch4.best_params_, gsearch4.best_score_

# 看最终的模型拟合
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)
print rf2.oob_score_

参考：https://www.cnblogs.com/pinard/p/6160412.html