提升机器算法LightGBM（图解+理论+增量训练python代码+lightGBM调参方法）

2019-08-03 21:38:43 阅读：2654 来源： 互联网

标签：std LightGBM python train params fraction lightGBM reg mean

原文链接：https://blog.csdn.net/huacha__/article/details/81057150

LightGBM是个快速的，分布式的，高性能的基于决策树算法的梯度提升框架。可用于排序，分类，回归以及很多其他的机器学习任务中。

在竞赛题中，我们知道XGBoost算法非常热门，它是一种优秀的拉动框架，但是在使用过程中，其训练耗时很长，内存占用比较大。在2017年年1月微软在GitHub的上开源了一个新的升压工具--LightGBM。在不降低准确率的前提下，速度提升了10倍左右，占用内存下降了3倍左右。因为他是基于决策树算法的，它采用最优的叶明智策略分裂叶子节点，然而其它的提升算法分裂树一般采用的是深度方向或者水平明智而不是叶，明智的。因此，在LightGBM算法中，当增长到相同的叶子节点，叶明智算法比水平-wise算法减少更多的损失。因此导致更高的精度，而其他的任何已存在的提升算法都不能够达。

2017年1月，微软发布首个稳定版LightGBM

在微软亚洲研究院AI头条分享中的「LightGBM简介」中，机器学习组的主管研究员王太峰提到：微软DMTK团队在github上开源了性能超越其它推动决策树工具LightGBM后，三天之内星了1000+次，叉了超过200次。知乎上有近千人关注“如何看待微软开源的LightGBM？”问题，被评价为“速度惊人”，“非常有启发”，“支持分布式” “代码清晰易懂”，“占用内存小”等。以下是微软官方提到的LightGBM的各种优点，以及该项目的开源地址。科普链接：如何玩转LightGBM https://v.qq.com/x/page/k0362z6lqix.html

下面这个表格给出了XGBoost和LightGBM之间更加细致的性能对比，包括了树的生长方式，LightGBM是直接去选择获得最大收益的结点来展开，而XGBoost是通过按层增长的方式来做，LightGBM能够在更小的计算代价上建立我们需要的决策树。当然在这样的算法中我们也需要控制树的深度和每个叶子结点的最小数据量，从而减少过拟合。

二、在不同数据集上的对比

higgs和expo都是分类数据，yahoo ltr和msltr都是排序数据，在这些数据中，LightGBM都有更好的准确率和更强的内存使用量。

计算速度的对比，完成相同的训练量XGBoost通常耗费的时间是LightGBM的数倍之上，在higgs数据集上，它们的差距更是达到了15倍以上。

三、LightGBM的细节技术

1、直方图优化

XGBoost中采用预排序的方法，计算过程当中是按照value的排序，逐个数据样本来计算划分收益，这样的算法能够精确的找到最佳划分值，但是代价比较大同时也没有较好的推广性。

在LightGBM中没有使用传统的预排序的思路，而是将这些精确的连续的每一个value划分到一系列离散的域中，也就是筒子里。以浮点型数据来举例，一个区间的值会被作为一个筒，然后以这些筒为精度单位的直方图来做。这样一来，数据的表达变得更加简化，减少了内存的使用，而且直方图带来了一定的正则化的效果，能够使我们做出来的模型避免过拟合且具有更好的推广性。

看下直方图优化的细节处理

可以看到，这是按照bin来索引“直方图”，所以不用按照每个“特征”来排序，也不用一一去对比不同“特征”的值，大大的减少了运算量。

2、存储记忆优化

当我们用数据的bin描述数据特征的时候带来的变化：首先是不需要像预排序算法那样去存储每一个排序后数据的序列，也就是下图灰色的表，在LightGBM中，这部分的计算代价是0；第二个，一般bin会控制在一个比较小的范围，所以我们可以用更小的内存来存储

3、深度限制的节点展开方法

LightGBM使用了带有深度限制的节点展开方法（Leaf-wise）来提高模型精度，这是比XGBoost中Level-wise更高效的方法。它可以降低训练误差得到更好的精度。但是单纯的使用Leaf-wise可能会生长出比较深的树，在小数据集上可能会造成过拟合，因此在Leaf-wise之上多加一个深度限制

4、直方图做差优化

直方图做差优化可以达到两倍的加速，可以观察到一个叶子节点上的直方图，可以由它的父亲节点直方图减去它兄弟节点的直方图来得到。根据这一点我们可以构造出来数据量比较小的叶子节点上的直方图，然后用直方图做差来得到数据量比较大的叶子节点上的直方图，从而达到加速的效果。

5、顺序访问梯度

预排序算法中有两个频繁的操作会导致cache-miss，也就是缓存消失（对速度的影响很大，特别是数据量很大的时候，顺序访问比随机访问的速度快4倍以上）。

对梯度的访问：在计算增益的时候需要利用梯度，对于不同的特征，访问梯度的顺序是不一样的，并且是随机的
对于索引表的访问：预排序算法使用了行号和叶子节点号的索引表，防止数据切分的时候对所有的特征进行切分。同访问梯度一样，所有的特征都要通过访问这个索引表来索引。
这两个操作都是随机的访问，会给系统性能带来非常大的下降。

LightGBM使用的直方图算法能很好的解决这类问题。首先。对梯度的访问，因为不用对特征进行排序，同时，所有的特征都用同样的方式来访问，所以只需要对梯度访问的顺序进行重新排序，所有的特征都能连续的访问梯度。并且直方图算法不需要把数据id到叶子节点号上（不需要这个索引表，没有这个缓存消失问题）

6、支持类别特征

传统的机器学习一般不能支持直接输入类别特征，需要先转化成多维的0-1特征，这样无论在空间上还是时间上效率都不高。LightGBM通过更改决策树算法的决策规则，直接原生支持类别特征，不需要转化，提高了近8倍的速度。

7、支持并行学习

LightGBM原生支持并行学习，目前支持特征并行(Featrue Parallelization)和数据并行(Data Parallelization)两种，还有一种是基于投票的数据并行(Voting Parallelization)

特征并行的主要思想是在不同机器、在不同的特征集合上分别寻找最优的分割点，然后在机器间同步最优的分割点。
数据并行则是让不同的机器先在本地构造直方图，然后进行全局的合并，最后在合并的直方图上面寻找最优分割点。
LightGBM针对这两种并行方法都做了优化。

特征并行算法中，通过在本地保存全部数据避免对数据切分结果的通信。
数据并行中使用分散规约 (Reduce scatter) 把直方图合并的任务分摊到不同的机器，降低通信和计算，并利用直方图做差，进一步减少了一半的通信量。
基于投票的数据并行(Voting Parallelization)则进一步优化数据并行中的通信代价，使通信代价变成常数级别。在数据量很大的时候，使用投票并行可以得到非常好的加速效果。
下图更好的说明了以上这三种并行学习的整体流程：

在直方图合并的时候，通信代价比较大，基于投票的数据并行能够很好的解决这一点。

增量训练python代码

这个我好像代码在另一个电脑上，待更吧。。。星期一把代码完善一下。。。先简单介绍一下什么叫增量训练，就是他一下子吃不了那么多数据，内存会爆掉，但是需要读怎么办，就有一个流式读取的方法，本质上是个迭代器。。。

每次读取文件的一部分，用于训练模型，并保存模型的训练结果；然后读取文件的另一部分，再对模型进行更新训练；迭代读取全部数据完毕，最终完成整个文件数据的训练过程。

1. 文件的流式读取

def iter_minibatches(minibatch_size=1000):
    '''
	迭代器
	给定文件流（比如一个大文件），每次输出minibatch_size行，默认选择1k行
	将输出转化成numpy输出，返回X, y
	'''
    X = []
    y = []
    cur_line_num = 0

    train_data, train_label, train_weight, test_data, test_label, test_file = load_data()
    train_data, train_label = shuffle(train_data, train_label, random_state=0)  # random_state=0用于记录打乱位置 保证每次打乱位置不变
    print(type(train_label), train_label)

    for data_x, label_y in zip(train_data, train_label):
        X.append(data_x)
        y.append(label_y)

        cur_line_num += 1
        if cur_line_num >= minibatch_size:
            X, y = np.array(X), np.array(y)  # 将数据转成numpy的array类型并返回
            yield X, y
            X, y = [], []
            cur_line_num = 0

2. lightgbm（LGB）增量训练过程

def lightgbmTest():
    import lightgbm as lgb
    # 第一步，初始化模型为None，设置模型参数
    gbm = None
    params = {
        'task': 'train',
        'application': 'regression',  # 目标函数
        'boosting_type': 'gbdt',  # 设置提升类型
        'learning_rate': 0.01,  # 学习速率
        'num_leaves': 50,  # 叶子节点数
        'tree_learner': 'serial',
        'min_data_in_leaf': 100,
        'metric': ['l1', 'l2', 'rmse'],  # l1:mae, l2:mse  # 评估函数
        'max_bin': 255,
        'num_trees': 300
    }

    # 第二步，流式读取数据(每次10万)
    minibatch_train_iterators = iter_minibatches(minibatch_size=10000)

    for i, (X_, y_) in enumerate(minibatch_train_iterators):
        # 创建lgb的数据集
        # y_ = list(map(float, y_))  # 将numpy.ndarray转变为list

        X_train, X_test, y_train, y_test = train_test_split(X_, y_, test_size=0.1, random_state=0)
        y_train = y_train.ravel()
        lgb_train = lgb.Dataset(X_train, y_train)
        lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)

        # 第三步：增量训练模型
        # 重点来了，通过 init_model 和 keep_training_booster 两个参数实现增量训练
        gbm = lgb.train(params,
                        lgb_train,
                        num_boost_round=1000,
                        valid_sets=lgb_eval,
                        init_model=gbm,  # 如果gbm不为None，那么就是在上次的基础上接着训练
                        # feature_name=x_cols,
                        early_stopping_rounds=10,
                        verbose_eval=False,
                        keep_training_booster=True)  # 增量训练

        print("{} time".format(i))  # 当前次数
        # 输出模型评估分数
        score_train = dict([(s[1], s[2]) for s in gbm.eval_train()])
        print('当前模型在训练集的得分是：mae=%.4f, mse=%.4f, rmse=%.4f'
              % (score_train['l1'], score_train['l2'], score_train['rmse']))

    return gbm

3. lightgbm（LGB）调用过程以及保存训练结果模型

    '''lightgbm增量训练'''
    print('lightgbm增量训练')
    train_data, train_label, train_weight, test_data, test_label, test_file = load_data()
    print(train_label.shape,train_data.shape)
    train_X, test_X, train_Y, test_Y = train_test_split(train_data, train_label, test_size=0.1, random_state=0)
    # train_X, train_Y = shuffle(train_data, train_label, random_state=0)  # random_state=0用于记录打乱位置 保证每次打乱位置不变

    gbm = lightgbmTest()
    pred_Y = gbm.predict(test_X)
    print('compute_loss:{}'.format(compute_loss(test_Y, pred_Y)))

    # gbm.save_model('lightgbmtest.model')
    # 模型存储
    joblib.dump(gbm, 'loan_model.pkl')
    # 模型加载
    gbm = joblib.load('loan_model.pkl')

lightGBM调参方法

其实，对于基于决策树的模型，调参的方法都是大同小异。一般都需要如下步骤：

首先选择较高的学习率，大概0.1附近，这样是为了加快收敛的速度。这对于调参是很有必要的。
对决策树基本参数调参
正则化参数调参
最后降低学习率，这里是为了最后提高准确率

所以，下面的调参例子是基于上述步骤来操作。数据集为一个(4400+, 1000+)的数据集，全是数值特征，metric采用均方根误差。

（PS：还是吐槽一下，lightgbm参数的同义词(alias)实在是太多了，有时候不同的参数但同一个意思的时候真的很困扰，下面同义的参数我都用/划开，方便查看。）

Step1. 学习率和估计器及其数目

不管怎么样，我们先把学习率先定一个较高的值，这里取 learning_rate = 0.1，其次确定估计器boosting/boost/boosting_type的类型，不过默认都会选gbdt。

为了确定估计器的数目，也就是boosting迭代的次数，也可以说是残差树的数目，参数名为n_estimators/num_iterations/num_round/num_boost_round。我们可以先将该参数设成一个较大的数，然后在cv结果中查看最优的迭代次数，具体如代码。

在这之前，我们必须给其他重要的参数一个初始值。初始值的意义不大，只是为了方便确定其他参数。下面先给定一下初始值：

以下参数根据具体项目要求定：

'boosting_type'/'boosting': 'gbdt''objective': 'regression''metric': 'rmse'

以下参数我选择的初始值，你可以根据自己的情况来选择：

'max_depth': 6     ###   根据问题来定咯，由于我的数据集不是很大，所以选择了一个适中的值，其实4-10都无所谓。'num_leaves': 50  ###   由于lightGBM是leaves_wise生长，官方说法是要小于2^max_depth'subsample'/'bagging_fraction':0.8           ###  数据采样'colsample_bytree'/'feature_fraction': 0.8  ###  特征采样

下面我是用LightGBM的cv函数进行演示：

params = {    'boosting_type': 'gbdt', 
    'objective': 'regression', 

    'learning_rate': 0.1, 
    'num_leaves': 50, 
    'max_depth': 6,    'subsample': 0.8, 
    'colsample_bytree': 0.8, 
    }

data_train = lgb.Dataset(df_train, y_train, silent=True)
cv_results = lgb.cv(
    params, data_train, num_boost_round=1000, nfold=5, stratified=False, shuffle=True, metrics='rmse',
    early_stopping_rounds=50, verbose_eval=50, show_stdv=True, seed=0)

print('best n_estimators:', len(cv_results['rmse-mean']))
print('best cv score:', cv_results['rmse-mean'][-1])

[50]    cv_agg's rmse: 1.38497 + 0.0202823best n_estimators: 43best cv score: 1.3838664241

由于我的数据集不是很大，所以在学习率为0.1时，最优的迭代次数只有43。那么现在，我们就代入(0.1, 43)进入其他参数的tuning。但是还是建议，在硬件条件允许的条件下，学习率还是越小越好。

Step2. max_depth 和 num_leaves

这是提高精确度的最重要的参数。

max_depth ：设置树深度，深度越大可能过拟合

num_leaves：因为 LightGBM 使用的是 leaf-wise 的算法，因此在调节树的复杂程度时，使用的是 num_leaves 而不是 max_depth。大致换算关系：num_leaves = 2^(max_depth)，但是它的值的设置应该小于 2^(max_depth)，否则可能会导致过拟合。

我们也可以同时调节这两个参数，对于这两个参数调优，我们先粗调，再细调：

这里我们引入sklearn里的GridSearchCV()函数进行搜索。不知道怎的，这个函数特别耗内存，特别耗时间，特别耗精力。

from sklearn.model_selection import GridSearchCV### 我们可以创建lgb的sklearn模型，使用上面选择的(学习率，评估器数目)model_lgb = lgb.LGBMRegressor(objective='regression',num_leaves=50,
                              learning_rate=0.1, n_estimators=43, max_depth=6,
                              metric='rmse', bagging_fraction = 0.8,feature_fraction = 0.8)

params_test1={    'max_depth': range(3,8,2),    'num_leaves':range(50, 170, 30)
}
gsearch1 = GridSearchCV(estimator=model_lgb, param_grid=params_test1, scoring='neg_mean_squared_error', cv=5, verbose=1, n_jobs=4)

gsearch1.fit(df_train, y_train)
gsearch1.grid_scores_, gsearch1.best_params_, gsearch1.best_score_

Fitting 5 folds for each of 12 candidates, totalling 60 fits


[Parallel(n_jobs=4)]: Done  42 tasks      | elapsed:  2.0min
[Parallel(n_jobs=4)]: Done  60 out of  60 | elapsed:  3.1min finished


([mean: -1.88629, std: 0.13750, params: {'max_depth': 3, 'num_leaves': 50},  mean: -1.88629, std: 0.13750, params: {'max_depth': 3, 'num_leaves': 80},  mean: -1.88629, std: 0.13750, params: {'max_depth': 3, 'num_leaves': 110},  mean: -1.88629, std: 0.13750, params: {'max_depth': 3, 'num_leaves': 140},  mean: -1.86917, std: 0.12590, params: {'max_depth': 5, 'num_leaves': 50},  mean: -1.86917, std: 0.12590, params: {'max_depth': 5, 'num_leaves': 80},  mean: -1.86917, std: 0.12590, params: {'max_depth': 5, 'num_leaves': 110},  mean: -1.86917, std: 0.12590, params: {'max_depth': 5, 'num_leaves': 140},  mean: -1.89254, std: 0.10904, params: {'max_depth': 7, 'num_leaves': 50},  mean: -1.86024, std: 0.11364, params: {'max_depth': 7, 'num_leaves': 80},  mean: -1.86024, std: 0.11364, params: {'max_depth': 7, 'num_leaves': 110},  mean: -1.86024, std: 0.11364, params: {'max_depth': 7, 'num_leaves': 140}],
 {'max_depth': 7, 'num_leaves': 80}, -1.8602436718814157)

这里，我们运行了12个参数组合，得到的最优解是在max_depth为7，num_leaves为80的情况下，分数为-1.860。

这里必须说一下，sklearn模型评估里的scoring参数都是采用的higher return values are better than lower return values（较高的返回值优于较低的返回值）。

但是，我采用的metric策略采用的是均方误差(rmse)，越低越好，所以sklearn就提供了neg_mean_squared_erro参数，也就是返回metric的负数，所以就均方差来说，也就变成负数越大越好了。

所以，可以看到，最优解的分数为-1.860，转化为均方差为np.sqrt(-(-1.860)) = 1.3639，明显比step1的分数要好很多。

至此，我们将我们这步得到的最优解代入第三步。其实，我这里只进行了粗调，如果要得到更好的效果，可以将max_depth在7附近多取几个值，num_leaves在80附近多取几个值。千万不要怕麻烦，虽然这确实很麻烦。

params_test2={    'max_depth': [6,7,8],    'num_leaves':[68,74,80,86,92]
}

gsearch2 = GridSearchCV(estimator=model_lgb, param_grid=params_test2, scoring='neg_mean_squared_error', cv=5, verbose=1, n_jobs=4)
gsearch2.fit(df_train, y_train)
gsearch2.grid_scores_, gsearch2.best_params_, gsearch2.best_score_

Fitting 5 folds for each of 15 candidates, totalling 75 fits


[Parallel(n_jobs=4)]: Done  42 tasks      | elapsed:  2.8min
[Parallel(n_jobs=4)]: Done  75 out of  75 | elapsed:  5.1min finished


([mean: -1.87506, std: 0.11369, params: {'max_depth': 6, 'num_leaves': 68},  mean: -1.87506, std: 0.11369, params: {'max_depth': 6, 'num_leaves': 74},  mean: -1.87506, std: 0.11369, params: {'max_depth': 6, 'num_leaves': 80},  mean: -1.87506, std: 0.11369, params: {'max_depth': 6, 'num_leaves': 86},  mean: -1.87506, std: 0.11369, params: {'max_depth': 6, 'num_leaves': 92},  mean: -1.86024, std: 0.11364, params: {'max_depth': 7, 'num_leaves': 68},  mean: -1.86024, std: 0.11364, params: {'max_depth': 7, 'num_leaves': 74},  mean: -1.86024, std: 0.11364, params: {'max_depth': 7, 'num_leaves': 80},  mean: -1.86024, std: 0.11364, params: {'max_depth': 7, 'num_leaves': 86},  mean: -1.86024, std: 0.11364, params: {'max_depth': 7, 'num_leaves': 92},  mean: -1.88197, std: 0.11295, params: {'max_depth': 8, 'num_leaves': 68},  mean: -1.89117, std: 0.12686, params: {'max_depth': 8, 'num_leaves': 74},  mean: -1.86390, std: 0.12259, params: {'max_depth': 8, 'num_leaves': 80},  mean: -1.86733, std: 0.12159, params: {'max_depth': 8, 'num_leaves': 86},  mean: -1.86665, std: 0.12174, params: {'max_depth': 8, 'num_leaves': 92}],
 {'max_depth': 7, 'num_leaves': 68}, -1.8602436718814157)

可见最大深度7是没问题的，但是看细节的话，发现在最大深度为7的情况下，叶结点的数量对分数并没有影响。

Step3: min_data_in_leaf 和 min_sum_hessian_in_leaf

说到这里，就该降低过拟合了。

min_data_in_leaf 是一个很重要的参数, 也叫min_child_samples，它的值取决于训练数据的样本个树和num_leaves. 将其设置的较大可以避免生成一个过深的树, 但有可能导致欠拟合。

min_sum_hessian_in_leaf：也叫min_child_weight，使一个结点分裂的最小海森值之和，真拗口（Minimum sum of hessians in one leaf to allow a split. Higher values potentially decrease overfitting）

我们采用跟上面相同的方法进行：

params_test3={    'min_child_samples': [18, 19, 20, 21, 22],    'min_child_weight':[0.001, 0.002]
}
model_lgb = lgb.LGBMRegressor(objective='regression',num_leaves=80,
                              learning_rate=0.1, n_estimators=43, max_depth=7, 
                              metric='rmse', bagging_fraction = 0.8, feature_fraction = 0.8)
gsearch3 = GridSearchCV(estimator=model_lgb, param_grid=params_test3, scoring='neg_mean_squared_error', cv=5, verbose=1, n_jobs=4)
gsearch3.fit(df_train, y_train)
gsearch3.grid_scores_, gsearch3.best_params_, gsearch3.best_score_

Fitting 5 folds for each of 10 candidates, totalling 50 fits


[Parallel(n_jobs=4)]: Done  42 tasks      | elapsed:  2.9min
[Parallel(n_jobs=4)]: Done  50 out of  50 | elapsed:  3.3min finished


([mean: -1.88057, std: 0.13948, params: {'min_child_samples': 18, 'min_child_weight': 0.001},  mean: -1.88057, std: 0.13948, params: {'min_child_samples': 18, 'min_child_weight': 0.002},  mean: -1.88365, std: 0.13650, params: {'min_child_samples': 19, 'min_child_weight': 0.001},  mean: -1.88365, std: 0.13650, params: {'min_child_samples': 19, 'min_child_weight': 0.002},  mean: -1.86024, std: 0.11364, params: {'min_child_samples': 20, 'min_child_weight': 0.001},  mean: -1.86024, std: 0.11364, params: {'min_child_samples': 20, 'min_child_weight': 0.002},  mean: -1.86980, std: 0.14251, params: {'min_child_samples': 21, 'min_child_weight': 0.001},  mean: -1.86980, std: 0.14251, params: {'min_child_samples': 21, 'min_child_weight': 0.002},  mean: -1.86750, std: 0.13898, params: {'min_child_samples': 22, 'min_child_weight': 0.001},  mean: -1.86750, std: 0.13898, params: {'min_child_samples': 22, 'min_child_weight': 0.002}],
 {'min_child_samples': 20, 'min_child_weight': 0.001}, -1.8602436718814157)

这是我经过粗调后细调的结果，可以看到，min_data_in_leaf的最优值为20，而min_sum_hessian_in_leaf对最后的值几乎没有影响。且这里调参之后，最后的值没有进行优化，说明之前的默认值即为20，0.001。

Step4: feature_fraction 和 bagging_fraction

这两个参数都是为了降低过拟合的。

feature_fraction参数来进行特征的子抽样。这个参数可以用来防止过拟合及提高训练速度。

bagging_fraction+bagging_freq参数必须同时设置，bagging_fraction相当于subsample样本采样，可以使bagging更快的运行，同时也可以降拟合。bagging_freq默认0，表示bagging的频率，0意味着没有使用bagging，k意味着每k轮迭代进行一次bagging。

不同的参数，同样的方法。

params_test4={    'feature_fraction': [0.5, 0.6, 0.7, 0.8, 0.9],    'bagging_fraction': [0.6, 0.7, 0.8, 0.9, 1.0]
}
model_lgb = lgb.LGBMRegressor(objective='regression',num_leaves=80,
                              learning_rate=0.1, n_estimators=43, max_depth=7, 
                              metric='rmse', bagging_freq = 5,  min_child_samples=20)
gsearch4 = GridSearchCV(estimator=model_lgb, param_grid=params_test4, scoring='neg_mean_squared_error', cv=5, verbose=1, n_jobs=4)
gsearch4.fit(df_train, y_train)
gsearch4.grid_scores_, gsearch4.best_params_, gsearch4.best_score_

Fitting 5 folds for each of 25 candidates, totalling 125 fits


[Parallel(n_jobs=4)]: Done  42 tasks      | elapsed:  2.6min
[Parallel(n_jobs=4)]: Done 125 out of 125 | elapsed:  7.1min finished


([mean: -1.90447, std: 0.15841, params: {'bagging_fraction': 0.6, 'feature_fraction': 0.5},  mean: -1.90846, std: 0.13925, params: {'bagging_fraction': 0.6, 'feature_fraction': 0.6},  mean: -1.91695, std: 0.14121, params: {'bagging_fraction': 0.6, 'feature_fraction': 0.7},  mean: -1.90115, std: 0.12625, params: {'bagging_fraction': 0.6, 'feature_fraction': 0.8},  mean: -1.92586, std: 0.15220, params: {'bagging_fraction': 0.6, 'feature_fraction': 0.9},  mean: -1.88031, std: 0.17157, params: {'bagging_fraction': 0.7, 'feature_fraction': 0.5},  mean: -1.89513, std: 0.13718, params: {'bagging_fraction': 0.7, 'feature_fraction': 0.6},  mean: -1.88845, std: 0.13864, params: {'bagging_fraction': 0.7, 'feature_fraction': 0.7},  mean: -1.89297, std: 0.12374, params: {'bagging_fraction': 0.7, 'feature_fraction': 0.8},  mean: -1.89432, std: 0.14353, params: {'bagging_fraction': 0.7, 'feature_fraction': 0.9},  mean: -1.88088, std: 0.14247, params: {'bagging_fraction': 0.8, 'feature_fraction': 0.5},  mean: -1.90080, std: 0.13174, params: {'bagging_fraction': 0.8, 'feature_fraction': 0.6},  mean: -1.88364, std: 0.14732, params: {'bagging_fraction': 0.8, 'feature_fraction': 0.7},  mean: -1.88987, std: 0.13344, params: {'bagging_fraction': 0.8, 'feature_fraction': 0.8},  mean: -1.87752, std: 0.14802, params: {'bagging_fraction': 0.8, 'feature_fraction': 0.9},  mean: -1.88348, std: 0.13925, params: {'bagging_fraction': 0.9, 'feature_fraction': 0.5},  mean: -1.87472, std: 0.13301, params: {'bagging_fraction': 0.9, 'feature_fraction': 0.6},  mean: -1.88656, std: 0.12241, params: {'bagging_fraction': 0.9, 'feature_fraction': 0.7},  mean: -1.89029, std: 0.10776, params: {'bagging_fraction': 0.9, 'feature_fraction': 0.8},  mean: -1.88719, std: 0.11915, params: {'bagging_fraction': 0.9, 'feature_fraction': 0.9},  mean: -1.86170, std: 0.12544, params: {'bagging_fraction': 1.0, 'feature_fraction': 0.5},  mean: -1.87334, std: 0.13099, params: {'bagging_fraction': 1.0, 'feature_fraction': 0.6},  mean: -1.85412, std: 0.12698, params: {'bagging_fraction': 1.0, 'feature_fraction': 0.7},  mean: -1.86024, std: 0.11364, params: {'bagging_fraction': 1.0, 'feature_fraction': 0.8},  mean: -1.87266, std: 0.12271, params: {'bagging_fraction': 1.0, 'feature_fraction': 0.9}],
 {'bagging_fraction': 1.0, 'feature_fraction': 0.7}, -1.8541224387666373)

从这里可以看出来，bagging_feaction和feature_fraction的理想值分别是1.0和0.7，一个很重要原因就是，我的样本数量比较小(4000+)，但是特征数量很多(1000+)。所以，这里我们取更小的步长，对feature_fraction进行更细致的取值。

params_test5={    'feature_fraction': [0.62, 0.65, 0.68, 0.7, 0.72, 0.75, 0.78 ]
}
model_lgb = lgb.LGBMRegressor(objective='regression',num_leaves=80,
                              learning_rate=0.1, n_estimators=43, max_depth=7, 
                              metric='rmse',  min_child_samples=20)
gsearch5 = GridSearchCV(estimator=model_lgb, param_grid=params_test5, scoring='neg_mean_squared_error', cv=5, verbose=1, n_jobs=4)
gsearch5.fit(df_train, y_train)
gsearch5.grid_scores_, gsearch5.best_params_, gsearch5.best_score_

Fitting 5 folds for each of 7 candidates, totalling 35 fits


[Parallel(n_jobs=4)]: Done  35 out of  35 | elapsed:  2.3min finished


([mean: -1.86696, std: 0.12658, params: {'feature_fraction': 0.62},  mean: -1.88337, std: 0.13215, params: {'feature_fraction': 0.65},  mean: -1.87282, std: 0.13193, params: {'feature_fraction': 0.68},  mean: -1.85412, std: 0.12698, params: {'feature_fraction': 0.7},  mean: -1.88235, std: 0.12682, params: {'feature_fraction': 0.72},  mean: -1.86329, std: 0.12757, params: {'feature_fraction': 0.75},  mean: -1.87943, std: 0.12107, params: {'feature_fraction': 0.78}],
 {'feature_fraction': 0.7}, -1.8541224387666373)

好吧，feature_fraction就是0.7了

Step5: 正则化参数

正则化参数lambda_l1(reg_alpha), lambda_l2(reg_lambda)，毫无疑问，是降低过拟合的，两者分别对应l1正则化和l2正则化。我们也来尝试一下使用这两个参数。

params_test6={    'reg_alpha': [0, 0.001, 0.01, 0.03, 0.08, 0.3, 0.5],    'reg_lambda': [0, 0.001, 0.01, 0.03, 0.08, 0.3, 0.5]
}
model_lgb = lgb.LGBMRegressor(objective='regression',num_leaves=80,
                              learning_rate=0.b1, n_estimators=43, max_depth=7, 
                              metric='rmse',  min_child_samples=20, feature_fraction=0.7)
gsearch6 = GridSearchCV(estimator=model_lgb, param_grid=params_test6, scoring='neg_mean_squared_error', cv=5, verbose=1, n_jobs=4)
gsearch6.fit(df_train, y_train)
gsearch6.grid_scores_, gsearch6.best_params_, gsearch6.best_score_

Fitting 5 folds for each of 49 candidates, totalling 245 fits


[Parallel(n_jobs=4)]: Done  42 tasks      | elapsed:  2.8min
[Parallel(n_jobs=4)]: Done 192 tasks      | elapsed: 10.6min
[Parallel(n_jobs=4)]: Done 245 out of 245 | elapsed: 13.3min finished


([mean: -1.85412, std: 0.12698, params: {'reg_alpha': 0, 'reg_lambda': 0},  mean: -1.85990, std: 0.13296, params: {'reg_alpha': 0, 'reg_lambda': 0.001},  mean: -1.86367, std: 0.13634, params: {'reg_alpha': 0, 'reg_lambda': 0.01},  mean: -1.86787, std: 0.13881, params: {'reg_alpha': 0, 'reg_lambda': 0.03},  mean: -1.87099, std: 0.12476, params: {'reg_alpha': 0, 'reg_lambda': 0.08},  mean: -1.87670, std: 0.11849, params: {'reg_alpha': 0, 'reg_lambda': 0.3},  mean: -1.88278, std: 0.13064, params: {'reg_alpha': 0, 'reg_lambda': 0.5},  mean: -1.86190, std: 0.13613, params: {'reg_alpha': 0.001, 'reg_lambda': 0},  mean: -1.86190, std: 0.13613, params: {'reg_alpha': 0.001, 'reg_lambda': 0.001},  mean: -1.86515, std: 0.14116, params: {'reg_alpha': 0.001, 'reg_lambda': 0.01},  mean: -1.86908, std: 0.13668, params: {'reg_alpha': 0.001, 'reg_lambda': 0.03},  mean: -1.86852, std: 0.12289, params: {'reg_alpha': 0.001, 'reg_lambda': 0.08},  mean: -1.88076, std: 0.11710, params: {'reg_alpha': 0.001, 'reg_lambda': 0.3},  mean: -1.88278, std: 0.13064, params: {'reg_alpha': 0.001, 'reg_lambda': 0.5},  mean: -1.87480, std: 0.13889, params: {'reg_alpha': 0.01, 'reg_lambda': 0},  mean: -1.87284, std: 0.14138, params: {'reg_alpha': 0.01, 'reg_lambda': 0.001},  mean: -1.86030, std: 0.13332, params: {'reg_alpha': 0.01, 'reg_lambda': 0.01},  mean: -1.86695, std: 0.12587, params: {'reg_alpha': 0.01, 'reg_lambda': 0.03},  mean: -1.87415, std: 0.13100, params: {'reg_alpha': 0.01, 'reg_lambda': 0.08},  mean: -1.88543, std: 0.13195, params: {'reg_alpha': 0.01, 'reg_lambda': 0.3},  mean: -1.88076, std: 0.13502, params: {'reg_alpha': 0.01, 'reg_lambda': 0.5},  mean: -1.87729, std: 0.12533, params: {'reg_alpha': 0.03, 'reg_lambda': 0},  mean: -1.87435, std: 0.12034, params: {'reg_alpha': 0.03, 'reg_lambda': 0.001},  mean: -1.87513, std: 0.12579, params: {'reg_alpha': 0.03, 'reg_lambda': 0.01},  mean: -1.88116, std: 0.12218, params: {'reg_alpha': 0.03, 'reg_lambda': 0.03},  mean: -1.88052, std: 0.13585, params: {'reg_alpha': 0.03, 'reg_lambda': 0.08},  mean: -1.87565, std: 0.12200, params: {'reg_alpha': 0.03, 'reg_lambda': 0.3},  mean: -1.87935, std: 0.13817, params: {'reg_alpha': 0.03, 'reg_lambda': 0.5},  mean: -1.87774, std: 0.12477, params: {'reg_alpha': 0.08, 'reg_lambda': 0},  mean: -1.87774, std: 0.12477, params: {'reg_alpha': 0.08, 'reg_lambda': 0.001},  mean: -1.87911, std: 0.12027, params: {'reg_alpha': 0.08, 'reg_lambda': 0.01},  mean: -1.86978, std: 0.12478, params: {'reg_alpha': 0.08, 'reg_lambda': 0.03},  mean: -1.87217, std: 0.12159, params: {'reg_alpha': 0.08, 'reg_lambda': 0.08},  mean: -1.87573, std: 0.14137, params: {'reg_alpha': 0.08, 'reg_lambda': 0.3},  mean: -1.85969, std: 0.13109, params: {'reg_alpha': 0.08, 'reg_lambda': 0.5},  mean: -1.87632, std: 0.12398, params: {'reg_alpha': 0.3, 'reg_lambda': 0},  mean: -1.86995, std: 0.12651, params: {'reg_alpha': 0.3, 'reg_lambda': 0.001},  mean: -1.86380, std: 0.12793, params: {'reg_alpha': 0.3, 'reg_lambda': 0.01},  mean: -1.87577, std: 0.13002, params: {'reg_alpha': 0.3, 'reg_lambda': 0.03},  mean: -1.87402, std: 0.13496, params: {'reg_alpha': 0.3, 'reg_lambda': 0.08},  mean: -1.87032, std: 0.12504, params: {'reg_alpha': 0.3, 'reg_lambda': 0.3},  mean: -1.88329, std: 0.13237, params: {'reg_alpha': 0.3, 'reg_lambda': 0.5},  mean: -1.87196, std: 0.13099, params: {'reg_alpha': 0.5, 'reg_lambda': 0},  mean: -1.87196, std: 0.13099, params: {'reg_alpha': 0.5, 'reg_lambda': 0.001},  mean: -1.88222, std: 0.14735, params: {'reg_alpha': 0.5, 'reg_lambda': 0.01},  mean: -1.86618, std: 0.14006, params: {'reg_alpha': 0.5, 'reg_lambda': 0.03},  mean: -1.88579, std: 0.12398, params: {'reg_alpha': 0.5, 'reg_lambda': 0.08},  mean: -1.88297, std: 0.12307, params: {'reg_alpha': 0.5, 'reg_lambda': 0.3},  mean: -1.88148, std: 0.12622, params: {'reg_alpha': 0.5, 'reg_lambda': 0.5}],
 {'reg_alpha': 0, 'reg_lambda': 0}, -1.8541224387666373)

哈哈，看来我多此一举了。

step6: 降低learning_rate

之前使用较高的学习速率是因为可以让收敛更快，但是准确度肯定没有细水长流来的好。最后，我们使用较低的学习速率，以及使用更多的决策树n_estimators来训练数据，看能不能可以进一步的优化分数。

我们可以用回lightGBM的cv函数了，我们代入之前优化好的参数。

params = {    'boosting_type': 'gbdt', 
    'objective': 'regression', 

    'learning_rate': 0.005, 
    'num_leaves': 80, 
    'max_depth': 7,    'min_data_in_leaf': 20,    'subsample': 1, 
    'colsample_bytree': 0.7, 
    }

data_train = lgb.Dataset(df_train, y_train, silent=True)
cv_results = lgb.cv(
    params, data_train, num_boost_round=10000, nfold=5, stratified=False, shuffle=True, metrics='rmse',
    early_stopping_rounds=50, verbose_eval=100, show_stdv=True)

print('best n_estimators:', len(cv_results['rmse-mean']))
print('best cv score:', cv_results['rmse-mean'][-1])

这就是一个大概过程吧，其实也有更高级的方法，但是这种基本的对于GBM模型的调参方法也是需要了解的吧。如有问题，请多指教。

标签：std,LightGBM,python,train,params,fraction,lightGBM,reg,mean
来源： https://blog.csdn.net/lamusique/article/details/95631638

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9