LightGBM参数

景令秋

2023-12-01

参考：https://www.freesion.com/article/76441004344/#LightGBM__sklearn__329
https://blog.csdn.net/qq_39777550/article/details/109277937

LightGBM的优点

lightgbm是xgboost的加强升级版.
LightGBM=XGBoost+Histogram+GOSS+EFB
其中，Histogram算法是直方图算法，作用:减少后选分类点的算法
GOSS是基于梯度的单边采样算法，作用减少样本数量
EFB算法是互斥特征捆绑算法，作用是减少特征数量
基于以上三个算法，LightGBM生产一片叶子需要的复杂度大大降低了，从而极大节约了计算时间。同时Histogram算法还将特征浮点数转换成0~255位的证书进行存储，从而集打节约了内存存储空间。
（1）基于leaf-wise的决策树的生长策略
对于大部分决策树算法使用的试level-wise生长策略，即同一层的叶子节点每次都一起分裂，但是实际上一些叶子节点的分裂增益较低，这样分裂会增加不小的开销。lightGBM使用的leaf-wise策略，每次在当前的叶子节点中，找出分裂增益最大的叶子节点进行分裂，而不是所有节点都进行分裂，这样可以提高精度。
（2）直方图算法
简答来说，就是先对特征值进行装箱处理，把连续的浮点特征值离散化成k个整数，形成一个一个的箱体，同时构造一个宽度为k的直方图，在遍历数据的时候，根据离散化后的值作为索引在直方图中累积统计值（因此这里试频数直方图），当遍历一次数据后，直方图累积了需要的统计量，然后根据直方图的离散值，遍历寻找最优的分割点。
对于连续的特征来说，装箱处理时特征工程中的离散化：如[0,10)区间的值都可以幅值为0，[10,20)区间的值都可以赋值为1等，这样就可以把众多的数据值划分为到有限的分箱中，在LightGBM中默认分箱数（bins）为256。对于分类的特征来说，则是每一种取值放入一个分箱中，且当取值的个数大于最大分箱数是，会忽略哪些很少出现的分类值。
（3）GOSS算法
单边梯度采样GOSS算法是通过对样本采样的方法来减少计算目标函数增益时候的复杂度。
在GOOS算法中，梯度更大的样本点在计算信息增益的时候占有更重要的作用，当我们对样本进行下采样的时候，保留这些体大较大的样本点，并随机取掉梯度小的样本。
首先把样本按照梯度排序，选出梯度最大的a%个样本，然后在剩下的小梯度样本数据中随机选取b%个样本，在计算信息增益的时候，将选出来的b%小梯度样本的信息增益扩大1-a/b的倍数。
（如果一个样本的梯度很小，证明该样本拟合较好，所以不需要再计算新的增益了。但是如果全部舍去梯度小的样本，那么精度就会下降，所以随机去掉梯度小的样本。）
（4）EFB算法：
互斥特征绑定算法，即将互斥特征绑定在一起以减少特征维度；EFB算法可以有效减少用于构建直方图的特征数量，从而降低计算复杂度，尤其是特征中包含大量稀疏特征的时候。LightGBM可以直接将每个类别取值和一个bin关联，从而自动处理它们，而无需预处理成onehot编码。
（5）并行学习
LightGBM支持特征并行和数据并行两种。传统的特征并行主要思想是在并行化决策树中寻找最佳切分点，在数据量大时难以加速，同时需要切分结果进行通信整合。LightGBM则是使用分散规则，它将直方图合并的任务分给不同的机器，降低通信和计算的开销，并利用直方图加速训练，进一步减少开销。
（6）支持类别特征
传统的机器学习一般不能支持直接输入类别特征，需要先转化成多维的0-1特征，这样无论在空间上还是时间上效率都不高。LightGBM通过更改决策树算法的决策规则，直接原生支持类别特征，不需要转化，提高了近8倍的速度。
（7）支持并行学习
LightGBM原生支持并行学习，目前支持特征并行(Featrue Parallelization)和数据并行(Data Parallelization)两种，还有一种是基于投票的数据并行(Voting Parallelization)
特征并行的主要思想是在不同机器、在不同的特征集合上分别寻找最优的分割点，然后在机器间同步最优的分割点。
数据并行则是让不同的机器先在本地构造直方图，然后进行全局的合并，最后在合并的直方图上面寻找最优分割点。
LightGBM针对这两种并行方法都做了优化。
（8）支持增量学习
每次读取文件的一部分，用于训练模型，并保存模型的训练结果；然后读取文件的另一部分，再对模型进行更新训练；迭代读取全部数据完毕，最终完成整个文件数据的训练过程。

LIGHTGBM 的 SKLEARN 风格接口

lightgbm.LGBMModel

class LGBMModel(_LGBMModelBase):
“”“Implementation of the scikit-learn API for LightGBM.”"" _def init(self, boosting_type=‘gbdt’, num_leaves=31, max_depth=-1,
learning_rate=0.1, n_estimators=100,
subsample_for_bin=200000, objective=None, class_weight=None,
min_split_gain=0., min_child_weight=1e-3, min_child_samples=20,
subsample=1., subsample_freq=0, colsample_bytree=1.,
reg_alpha=0., reg_lambda=0., random_state=None,
n_jobs=-1, silent=True, importance_type=‘split’, **kwargs):
Parameters

boosting_type (string, optional (default=‘gbdt’))

‘gbdt’, traditional Gradient Boosting Decision Tree.
‘dart’, Dropouts meet Multiple Additive Regression Trees.
‘goss’, Gradient-based One-Side Sampling.
‘rf’, Random Forest.

num_leaves (int, optional (default=31)，<=2^max_depth) – 每个基学习器的最大叶子节点.
max_depth (int, optional (default=-1)) – 每个基学习器的最大深度, -1 means no limit, 当模型过拟合，首先降低max_depth
learning_rate (float, optional (default=0.1)) – Boosting learning rate. You can use callbacks parameter of fit method to shrink/adapt learning rate in training using reset_parameter callback. Note, that this will ignore the learning_rate argument in training.
n_estimators (int, optional (default=100)) – 基学习器的训练数量.
max_bin (int, optional (default=255)) feature将存入的bin的最大数量，应该是直方图的k值
subsample_for_bin (int, optional (default=200000)) – Number of samples for constructing bins.
objective (string, callable or None, optional (default=None)) – Specify the learning task and the corresponding learning objective or a custom objective function to be used (see note below). Default: ‘regression’ for LGBMRegressor, ‘binary’ or ‘multiclass’ for LGBMClassifier, ‘lambdarank’ for LGBMRanker.
class_weight (dict, ‘balanced’ or None, optional (default=None)) – Weights associated with classes in the form {class_label: weight}. Use this parameter only for multi-class classification task; for binary classification task you may use is_unbalance or scale_pos_weight parameters. Note, that the usage of all these parameters will result in poor estimates of the individual class probabilities. You may want to consider performing probability calibration (https://scikit-learn.org/stable/modules/calibration.html) of your model. The ‘balanced’ mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as n_samples / (n_classes * np.bincount(y)). If None, all classes are supposed to have weight one. Note, that these weights will be multiplied with sample_weight (passed through the fit method) if sample_weight is specified.
min_split_gain (float, optional (default=0.)) – 树的叶子节点上进行进一步划分所需的最小损失减少.
min_child_weight (float, optional (default=1e-3)) – Minimum sum of instance weight (hessian) needed in a child (leaf).
min_child_samples (int, optional (default=20)) – 叶子节点具有的最小记录数.
subsample (float, optional (default=1.)) – 训练时采样一定比例的数据.
subsample_freq (int, optional (default=0)) – Frequency of subsample, <=0 means no enable.
colsample_bytree (float, optional (default=1.)) – Subsample ratio of columns when constructing each tree.
reg_alpha (float, optional (default=0.)) – L1 regularization term on weights.
reg_lambda (float, optional (default=0.)) – L2 regularization term on weights.
random_state (int, RandomState object or None, optional (default=None)) – Random number seed. If int, this number is used to seed the C++ code. If RandomState object (numpy), a random integer is picked based on its state to seed the C++ code. If None, default seeds in C++ code are used.
n_jobs (int, optional (default=-1)) – Number of parallel threads.
silent (bool, optional (default=True)) – Whether to print messages while running boosting.
importance_type (string, optional (default=‘split’)) – The type of feature importance to be filled into feature_importances_. If ‘split’, result contains numbers of times the feature is used in a model. If ‘gain’, result contains total gains of splits which use the feature.
**kwargs –

LGBMRegressor引入以及重要参数

from lightgbm import LGBMRegressor
from lightgbm import plot_importance
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_boston
from sklearn.metrics import mean_squared_error

# 导入数据集
boston = load_boston()
X ,y = boston.data,boston.target
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=0)

model = LGBMRegressor(
    boosting_type='gbdt', num_leaves=31, max_depth=-1,
    learning_rate=0.1, n_estimators=100,
    objective='regression', # 默认是二分类
    min_split_gain=0.0, min_child_samples=20,
    subsample=1.0, subsample_freq=0,
    colsample_bytree=1.0, reg_alpha=0.0, reg_lambda=0.0,
    random_state=None, silent=True
)

model.fit(X_train,y_train, eval_set=[(X_train, y_train), (X_test, y_test)], 
          verbose=100, early_stopping_rounds=50)

# 对测试集进行预测
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test,y_pred)
print('mse', mse)

# 显示重要特征
plot_importance(model)
plt.show()

LGBMClassifier的引入以及重要参数

from lightgbm import LGBMClassifier
from sklearn.datasets import load_iris
from lightgbm import plot_importance
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 加载样本数据集
iris = load_iris()
X,y = iris.data,iris.target
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=12343)

model = LGBMClassifier(
    max_depth=3,
    learning_rate=0.1,
    n_estimators=200, # 使用多少个弱分类器
    objective='multiclass',
    num_class=3,
    booster='gbtree',
    min_child_weight=2,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0,
    reg_lambda=1,
    seed=0 # 随机数种子
)
model.fit(X_train,y_train, eval_set=[(X_train, y_train), (X_test, y_test)], 
          verbose=100, early_stopping_rounds=50)

# 对测试集进行预测
y_pred = model.predict(X_test)
model.predict_proba
#计算准确率
accuracy = accuracy_score(y_test,y_pred)
print('accuracy:%3.f%%'%(accuracy*100))

# 显示重要特征
plot_importance(model)
plt.show()

LIGHTGBM 原生接口

重要参数

**boosting / boost **/ boosting_type
用于指定弱学习器的类型，默认值为 ‘gbdt’，表示使用基于树的模型进行计算。还可以选择为 ‘gblinear’ 表示使用线性模型作为弱学习器。
可选的参数值有：

‘gbdt’，使用梯度提升树
‘rf’，使用随机森林
‘dart’，不太了解，官方解释为 Dropouts meet Multiple Additive Regression Trees
‘goss’，使用单边梯度抽样算法，速度很快，但是可能欠拟合。

推荐设置为 'gbdt’
objective / application
用于指定学习任务及相应的学习目标，常用的可选参数值如下：

“regression”，使用L2正则项的回归模型（默认值）。
“regression_l1”，使用L1正则项的回归模型。
“mape”，平均绝对百分比误差。
“binary”，二分类。
“multiclass”，多分类。

num_class 用于设置多分类问题的类别个数。
min_child_samples 叶节点样本的最少数量，默认值20，用于防止过拟合。
learning_rate / eta
LightGBM 不完全信任每个弱学习器学到的残差值，为此需要给每个弱学习器拟合的残差值都乘上取值范围在(0, 1] 的 eta，设置较小的 eta 就可以多学习几个弱学习器来弥补不足的残差。
推荐的候选值为：[0.01, 0.015, 0.025, 0.05, 0.1]
max_depth
指定树的最大深度，默认值为-1，表示不做限制，合理的设置可以防止过拟合。
推荐的数值为：[3, 5, 6, 7, 9, 12, 15, 17, 25]。
num_leaves
指定叶子的个数，默认值为31，此参数的数值应该小于 2^{max_depth}2max_depth。
feature_fraction / colsample_bytree
构建弱学习器时，对特征随机采样的比例，默认值为1。
推荐的候选值为：[0.6, 0.7, 0.8, 0.9, 1]
bagging_fraction / subsample
默认值1，指定采样出 subsample * n_samples 个样本用于训练弱学习器。注意这里的子采样和随机森林不一样，随机森林使用的是放回抽样，而这里是不放回抽样。取值在(0, 1)之间，设置为1表示使用所有数据训练弱学习器。如果取值小于1，则只有一部分样本会去做GBDT的决策树拟合。选择小于1的比例可以减少方差，即防止过拟合，但是会增加样本拟合的偏差，因此取值不能太低。

注意： bagging_freq 设置为非0值时才生效。

推荐的候选值为：[0.6, 0.7, 0.8, 0.9, 1]
bagging_freq / subsample_freq
数值型，默认值0，表示禁用样本采样。如果设置为整数 z ，则每迭代 k 次执行一次采样。
**lambda_l1 **L1正则化权重项，增加此值将使模型更加保守。
推荐的候选值为：[0, 0.01~0.1, 1]
lambda_l2 L2正则化权重项，增加此值将使模型更加保守。
推荐的候选值为：[0, 0.1, 0.5, 1]
min_gain_to_split / min_split_gain
指定叶节点进行分支所需的损失减少的最小值，默认值为0。设置的值越大，模型就越保守。
**推荐的候选值为：[0, 0.05 ~ 0.1, 0.3, 0.5, 0.7, 0.9, 1] **
min_sum_hessian_in_leaf / min_child_weight
指定孩子节点中最小的样本权重和，如果一个叶子节点的样本权重和小于min_child_weight则拆分过程结束，默认值为1。
推荐的候选值为：[1, 3, 5, 7]
metric
用于指定评估指标，可以传递各种评估方法组成的list。常用的评估指标如下：

‘mae’，用于回归任务，效果与 ‘mean_absolute_error’， ‘l1’ 相同。
‘mse’，用于回归任务，效果与 ‘mean_squared_error’， ‘l2’ 相同。
‘rmse’，用于回归任务，效果与 ‘root_mean_squared_error’， ‘l2_root’ 相同。
‘auc’，用于二分类任务。
‘binary’，用于二分类任务。
‘binary_logloss’，用于二分类任务。
‘binary_error’，用于二分类任务。
‘multiclass’，用于多分类。
‘multi_logloss’，用于多分类。
‘multi_error’，用于多分类。

训练参数

以lightgbm.train为主，参数及默认值如下：

lightgbm.train(params, train_set, num_boost_round=100, valid_sets=None, valid_names=None, fobj=None, feval=None, init_model=None, feature_name='auto', categorical_feature='auto', early_stopping_rounds=None, evals_result=None, verbose_eval=True, learning_rates=None, keep_training_booster=False, callbacks=None)

1，params
字典类型，用于指定各种参数，例如：{‘booster’:‘gbtree’,‘eta’:0.1}
2，train_set
用于训练的数据，通过给下面的方法传递数据和标签来构造：

train_data = lgb.Dataset(train_x, train_y)

3，num_boost_round
指定最大迭代次数，默认值为10
4，valid_sets
列表类型，用于指定训练过程中用于评估的数据及数据的名称。例如：[train_data, valid_data]

train_data = lgb.Dataset(train_x, train_y)
valid_data = lgb.Dataset(valid_x, valid_y, reference=train)

5，fobj
可以指定二阶可导的自定义目标函数。
6，feval
自定义评估函数。
7，categorical_feature
指定哪些是类别特征。
8，early_stopping_rounds
指定迭代多少次没有得到优化则停止训练，默认值为None，表示不提前停止训练。

注意：valid_sets 必须非空才能生效，如果有多个数据集，则以最后一个数据集为准。

9，verbose_eval
可以是bool类型，也可以是整数类型。如果设置为整数，则每间隔verbose_eval次迭代就输出一次信息。
10，init_model
加载之前训练好的 lgb 模型，用于增量训练。

代码举例

from sklearn.datasets import load_iris
import lightgbm as lgb
from lightgbm import plot_importance
import matplotlib.pyplot  as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 加载鸢尾花数据集
iris = load_iris()
X,y = iris.data,iris.target
# 数据集分割
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=123457)

# 参数
params = {
    'booster': 'gbtree',
    'objective': 'multiclass',
    'num_class': 3,
    'num_leaves': 31,
    'subsample': 0.8,
    'bagging_freq': 1,
    'feature_fraction ': 0.8,
    'slient': 1,
    'learning_rate ': 0.01,
    'seed': 0
}

# 构造训练集
dtrain = lgb.Dataset(X_train,y_train)
dtest = lgb.Dataset(X_test,y_test)
num_rounds = 500
# xgboost模型训练
model = lgb.train(params,dtrain, num_rounds, valid_sets=[dtrain, dtest], 
                  verbose_eval=100, early_stopping_rounds=100)

# 对测试集进行预测
y_pred = model.predict(X_test)
# 计算准确率
accuracy = accuracy_score(y_test, np.argmax(y_pred, axis=1))
print('accuarcy:%.2f%%'%(accuracy*100))

# 显示重要特征，max_num_features 指定显示多少个特征
plot_importance(lgb_model, max_num_features)
plt.show()

LIGHTGBM 调参思路

1）选择较高的学习率，例如0.1，这样可以减少迭代用时。
（2）然后对 max_depth, num_leaves, min_data_in_leaf, min_split_gain, subsample, colsample_bytree 这些参数进行调整。
其中，num_leaves < 2^{max_depth}2max_depth。而 min_data_in_leaf 是一个很重要的参数, 也叫min_child_samples，它的值取决于训练数据的样本个树和num_leaves. 将其设置的较大可以避免生成一个过深的树, 但有可能导致欠拟合。
其他参数的合适候选值为：

max_depth：[3, 5, 6, 7, 9, 12, 15, 17, 25]
min_split_gain：[0, 0.05 ~ 0.1, 0.3, 0.5, 0.7, 0.9, 1]
subsample：[0.6, 0.7, 0.8, 0.9, 1]
colsample_bytree：[0.6, 0.7, 0.8, 0.9, 1]

（3）调整正则化参数 reg_lambda , reg_alpha，这些参数的合适候选值为：

reg_alpha：[0, 0.01~0.1, 1]
reg_lambda ：[0, 0.1, 0.5, 1]

（4）降低学习率，继续调整参数，学习率合适候选值为：[0.01, 0.015, 0.025, 0.05, 0.1]

参数网格搜索

from sklearn.datasets import load_iris
import lightgbm as lgb
from sklearn.model_selection import GridSearchCV  # Perforing grid search
from sklearn.model_selection import train_test_split

# 加载样本数据集
iris = load_iris()
X,y = iris.data,iris.target
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=12343)
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 = LGBMClassifier(max_depth=3,
                    learning_rate=0.1,
                    n_estimators=200, # 使用多少个弱分类器
                    objective='multiclass',
                    num_class=3,
                    booster='gbtree',
                    min_child_weight=2,
                    subsample=0.8,
                    colsample_bytree=0.8,
                    reg_alpha=0,
                    reg_lambda=1,
                    seed=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]))