文章/答案/技术大牛

发布

图解机器学习算法&实战 ◉ 从入门到精通

共 35 篇文章

图解机器学习 | 机器学习基础知识

图解机器学习 | LightGBM模型详解

图解机器学习 | 支持向量机模型详解

图解机器学习 | 聚类算法详解

图解机器学习 | 降维算法详解

机器学习实战 | Python机器学习算法应用实践

机器学习实战 | XGBoost建模应用详解

机器学习实战 | LightGBM建模应用详解

机器学习实战 | 综合项目-电商销量预估

机器学习实战 | 综合项目-电商销量预估进阶方案

机器学习实战 | 机器学习特征工程最全解读

机器学习实战 | 自动化特征工程工具Featuretools应用

机器学习实战 | AutoML自动化机器学习建模

20 行代码！带你快速构建基础文本搜索引擎 ⛵

员工离职困扰？来看AI如何解决，基于人力资源分析的 ML 模型构建全方案 ⛵

AI 音辨世界：艺术小白的我，靠这个AI模型，速识音乐流派选择音乐 ⛵

钻石价格预测的ML全流程！从模型构建调优道部署应用！⛵

二手车价格预测 | 构建AI模型并部署Web应用 ⛵

毫秒级！千万人脸库快速比对，上亿商品图片检索，背后的极速检索用了什么神器？ ⛵

客户流失？来看看大厂如何基于spark+机器学习构建千万数据规模上的用户留存模型 ⛵

机器学习模型太慢？来看看英特尔(R) 扩展加速 ⛵

全自动化机器学习建模！效果吊打初级炼丹师！ ⛵

机器学习建模高级用法！构建企业级AI建模流水线 ⛵

2022了你还不会『低代码』？数据科学也能玩转Low-Code啦！ ⛵

清单首页图解机器学习算法&实战 ◉ 从入门到精通文章详情

清单「图解机器学习算法&实战 ◉ 从入门到精通」 18/35

机器学习实战 | LightGBM建模应用详解

ShowMeAI

作者：韩信子@ShowMeAI

教程地址：http://www.showmeai.tech/tutorials/41

本文地址：http://www.showmeai.tech/article-detail/205

收藏ShowMeAI查看更多精彩内容

引言

LightGBM是微软开发的boosting集成模型，和XGBoost一样是对GBDT的优化和高效实现，原理有一些相似之处，但它很多方面比XGBoost有着更为优秀的表现。

本篇内容ShowMeAI展开给大家讲解LightGBM的工程应用方法，对于LightGBM原理知识感兴趣的同学，欢迎参考ShowMeAI的另外一篇文章 **图解机器学习 | LightGBM模型详解**。

1.LightGBM安装

LightGBM作为常见的强大Python机器学习工具库，安装也比较简单。

1.1 Python与IDE环境设置

python环境与IDE设置可以参考ShowMeAI文章 **图解python | 安装与环境设置** 进行设置。

1.2 工具库安装

(1) Linux/Mac等系统

这些系统下的XGBoost安装，大家只要基于pip就可以轻松完成了，在命令行端输入命令如下命令即可等待安装完成。

pip install lightgbm

大家也可以选择国内的pip源，以获得更好的安装速度：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple lightgbm

(2) Windows系统

对于windows系统而言，比较高效便捷的安装方式是：在网址http://www.lfd.uci.edu/~gohlke/pythonlibs/ 中去下载对应版本的的LightGBM安装包，再通过如下命令安装。

pip install lightgbm‑3.3.2‑cp310‑cp310‑win_amd64.whl

2.LightGBM参数手册

在ShowMeAI的前一篇内容 **XGBoost工具库建模应用详解** 中，我们讲解到了Xgboost的三类参数通用参数，学习目标参数，Booster参数。而LightGBM可调参数更加丰富，包含核心参数，学习控制参数，IO参数，目标参数，度量参数，网络参数，GPU参数，模型参数，这里我常修改的便是核心参数，学习控制参数，度量参数等。下面我们对这些模型参数做展开讲解，更多的细节可以参考LightGBM中文文档。

2.1 参数介绍

(1) 核心参数

config或者config\_file：一个字符串，给出了配置文件的路径。默认为空字符串。
task：一个字符串，给出了要执行的任务。可以为：
train或者training：表示是训练任务。默认为train。
predict或者prediction或者test：表示是预测任务。
convert\_model：表示是模型转换任务。将模型文件转换成if-else格式。
application或者objective或者app：一个字符串，表示问题类型。可以为：
regression 或 regression\_l2 或 mean\_squared\_error 或 mse或l2\_root 或 root\_mean\_squred\_error 或 rmse：表示回归任务，但是使用L2损失函数。默认为regression。
regression\_l1或者mae或者mean\_absolute\_error：表示回归任务，但是使用L1损失函数。
huber：表示回归任务，但是使用huber损失函数。
fair：表示回归任务，但是使用fair损失函数。
poisson：表示Poisson回归任务。
quantile：表示quantile回归任务。
quantile\_l2：表示quantile回归任务，但是使用了L2损失函数。
mape或者mean\_absolute\_precentage\_error：表示回归任务，但是使用MAPE损失函数
gamma：表示gamma回归任务。
tweedie：表示tweedie回归任务。
binary：表示二分类任务，使用对数损失函数作为目标函数。
multiclass：表示多分类任务，使用softmax函数作为目标函数。必须设置num\_class参数
multiclassova或者multiclass\_ova或者ova或者ovr：表示多分类任务，使用one-vs-all的二分类目标函数。必须设置num\_class参数。
xentropy或者cross\_entropy：目标函数为交叉熵(同时具有可选择的线性权重)。要求标签是0,1之间的数值。
xentlambda或者cross\_entropy\_lambda：替代了参数化的cross\_entropy。要求标签是0,1之间的数值。
lambdarank：表示排序任务。在lambdarank任务中，标签应该为整数类型，数值越大表示相关性越高。label\_gain参数可以用于设置整数标签的增益(权重)。
boosting或者boost或者boosting\_type：一个字符串，给出了基学习器模型算法。可以为：
gbdt：表示传统的梯度提升决策树。默认值为gbdt。
rf：表示随机森林。
dart：表示带dropout的gbdt。
goss：表示Gradient-based One-Side Sampling 的gbdt。
data或者train或者train\_data：一个字符串，给出了训练数据所在的文件的文件名。默认为空字符串。LightGBM将使用它来训练模型。
valid或者test或者valid\_data或者test\_data：一个字符串，表示验证集所在的文件的文件名。默认为空字符串。LightGBM将输出该数据集的度量。如果有多个验证集，则用逗号分隔。
num\_iterations或者num\_iteration或者num\_tree或者num\_trees或者num\_round或者num\_rounds或者num\_boost\_round一个整数，给出了boosting的迭代次数。默认为100。
对于Python/R包，该参数是被忽略的。对于Python，使用train()/cv()的输入参数num\_boost\_round来代替。
在内部，LightGBM对于multiclass问题设置了num\_class\*num\_iterations棵树。
learning\_rate或者shrinkage\_rate：个浮点数，给出了学习率。默认为1。在dart中，它还会影响dropped trees的归一化权重。
num\_leaves或者num\_leaf：一个整数，给出了一棵树上的叶子数。默认为31。
tree\_learner或者tree：一个字符串，给出了tree learner，主要用于并行学习。默认为serial。可以为：
serial：单台机器的tree learne
feature：特征并行的tree learne
data：数据并行的tree learne
voting：投票并行的tree learne
num\_threads或者num\_thread或者nthread：一个整数，给出了LightGBM的线程数。默认为OpenMP\_default。
为了更快的速度，应该将它设置为真正的CPU内核数，而不是线程的数量(大多数CPU使用超线程来使每个CPU内核生成2个线程)。
当数据集较小的时候，不要将它设置的过大。
对于并行学习，不应该使用全部的CPU核心，因为这会使得网络性能不佳。
device：一个字符串，指定计算设备。默认为cpu。可以为gpu、cpu。
建议使用较小的max\_bin来获得更快的计算速度。
为了加快学习速度，GPU默认使用32位浮点数来求和。你可以设置gpu\_use\_dp=True来启动64位浮点数，但是它会使得训练速度降低。

(2) 学习控制参数

max\_depth：一个整数，限制了树模型的最大深度，默认值为-1。如果小于0，则表示没有限制。
min\_data\_in\_leaf或者min\_data\_per\_leaf或者min\_data或者min\_child\_samples：一个整数，表示一个叶子节点上包含的最少样本数量。默认值为20。
min\_sum\_hessian\_in\_leaf或者min\_sum\_hessian\_per\_leaf或者min\_sum\_hessian或者min\_hessian或者min\_child\_weight：一个浮点数，表示一个叶子节点上的最小hessian之和。(也就是叶节点样本权重之和的最小值)默认为1e-3。
feature\_fraction或者sub\_feature或者colsample\_bytree：一个浮点数，取值范围为0.0,1.0，默认值为0。如果小于1.0，则LightGBM会在每次迭代中随机选择部分特征。如0.8表示：在每棵树训练之前选择80%的特征来训练。
feature\_fraction\_seed：一个整数，表示feature\_fraction的随机数种子，默认为2。
bagging\_fraction或者sub\_row或者subsample：一个浮点数，取值范围为0.0,1.0，默认值为0。如果小于1.0，则LightGBM会在每次迭代中随机选择部分样本来训练(非重复采样)。如0.8表示：在每棵树训练之前选择80%的样本(非重复采样)来训练。
bagging\_freq或者subsample\_freq：一个整数，表示每bagging\_freq次执行bagging。如果该参数为0，表示禁用bagging。
bagging\_seed或者bagging\_fraction\_seed：一个整数，表示bagging的随机数种子，默认为3。
early\_stopping\_round或者early\_stopping\_rounds或者early\_stopping：一个整数，默认为0。如果一个验证集的度量在early\_stopping\_round循环中没有提升，则停止训练。如果为0则表示不开启早停。
lambda\_l1或者reg\_alpha：一个浮点数，表示L1正则化系数。默认为0。
lambda\_l2或者reg\_lambda：一个浮点数，表示L2正则化系数。默认为0。
min\_split\_gain或者min\_gain\_to\_split：一个浮点数，表示执行切分的最小增益，默认为0。
drop\_rate：一个浮点数，取值范围为0.0,1.0，表示dropout的比例，默认为1。该参数仅在dart中使用。
skip\_drop：一个浮点数，取值范围为0.0,1.0，表示跳过dropout的概率，默认为5。该参数仅在dart中使用。
max\_drop：一个整数，表示一次迭代中删除树的最大数量，默认为50。如果小于等于0，则表示没有限制。该参数仅在dart中使用。
uniform\_drop：一个布尔值，表示是否想要均匀的删除树，默认值为False。该参数仅在dart中使用。
xgboost\_dart\_mode：一个布尔值，表示是否使用xgboost dart模式，默认值为False。该参数仅在dart中使用。
drop\_seed：一个整数，表示dropout的随机数种子，默认值为4。该参数仅在dart中使用。
top\_rate：一个浮点数，取值范围为0.0,1.0，表示在goss中，大梯度数据的保留比例，默认值为2。该参数仅在goss中使用。
other\_rate：一个浮点数，取值范围为0.0,1.0，表示在goss中，小梯度数据的保留比例，默认值为1。该参数仅在goss中使用。
min\_data\_per\_group：一个整数，表示每个分类组的最小数据量，默认值为100。用于排序任务
max\_cat\_threshold：一个整数，表示category特征的取值集合的最大大小。默认为32。
cat\_smooth：一个浮点数，用于category特征的概率平滑。默认值为10。它可以降低噪声在category特征中的影响，尤其是对于数据很少的类。
cat\_l2：一个浮点数，用于category切分中的L2正则化系数。默认为10。
top\_k或者topk：一个整数，用于投票并行中。默认为20。将它设置为更大的值可以获得更精确的结果，但是会降低训练速度。

(3) IO参数

max\_bin：一个整数，表示最大的桶的数量。默认值为255。LightGBM会根据它来自动压缩内存。如max\_bin=255时，则LightGBM将使用uint8来表示特征的每一个值。
min\_data\_in\_bin：一个整数，表示每个桶的最小样本数。默认为3。该方法可以避免出现一个桶只有一个样本的情况。
data\_random\_seed：一个整数，表示并行学习数据分隔中的随机数种子。默认为1它不包括特征并行。
output\_model或者model\_output或者model\_out：一个字符串，表示训练中输出的模型被保存的文件的文件名。默认txt。
input\_model或者model\_input或者model\_in：一个字符串，表示输入模型的文件的文件名。默认空字符串。对于prediction任务，该模型将用于预测数据，对于train任务，训练将从该模型继续
output\_result或者predict\_result或者prediction\_result：一个字符串，给出了prediction结果存放的文件名。默认为txt。
pre\_partition或者is\_pre\_partition：一个布尔值，指示数据是否已经被划分。默认值为False。如果为true，则不同的机器使用不同的partition来训练。它用于并行学习(不包括特征并行)
is\_sparse或者is\_enable\_sparse或者enable\_sparse：一个布尔值，表示是否开启稀疏优化，默认为True。如果为True则启用稀疏优化。
two\_round或者two\_round\_loading或者use\_two\_round\_loading：一个布尔值，指示是否启动两次加载。默认值为False，表示只需要进行一次加载。默认情况下，LightGBM会将数据文件映射到内存，然后从内存加载特征，这将提供更快的数据加载速度。但是当数据文件很大时，内存可能会被耗尽。如果数据文件太大，则将它设置为True
save\_binary或者is\_save\_binary或者is\_save\_binary\_file：一个布尔值，表示是否将数据集(包括验证集)保存到二进制文件中。默认值为False。如果为True，则可以加快数据的加载速度。
verbosity或者verbose：一个整数，表示是否输出中间信息。默认值为1。如果小于0，则仅仅输出critical信息；如果等于0，则还会输出error,warning信息；如果大于0，则还会输出info信息。
header或者has\_header：一个布尔值，表示输入数据是否有头部。默认为False。
label或者label\_column：一个字符串，表示标签列。默认为空字符串。你也可以指定一个整数，如label=0表示第0列是标签列。你也可以为列名添加前缀，如label=prefix:label\_name。
weight或者weight\_column：一个字符串，表示样本权重列。默认为空字符串。你也可以指定一个整数，如weight=0表示第0列是权重列。注意：它是剔除了标签列之后的索引。假如标签列为0，权重列为1，则这里weight=0。你也可以为列名添加前缀，如weight=prefix:weight\_name。
query或者query\_column或者gourp或者group\_column：一个字符串，query/groupID列。默认为空字符串。你也可以指定一个整数，如query=0表示第0列是query列。注意：它是剔除了标签列之后的索引。假如标签列为0，query列为1，则这里query=0。你也可以为列名添加前缀，如query=prefix:query\_name。
ignore\_column或者ignore\_feature或者blacklist：一个字符串，表示训练中忽略的一些列，默认为空字符串。可以用数字做索引，如ignore\_column=0,1,2表示第0,1,2列将被忽略。注意：它是剔除了标签列之后的索引。
你也可以为列名添加前缀，如ignore\_column=prefix:ign\_name1,ign\_name2。
categorical\_feature或者categorical\_column或者cat\_feature或者cat\_column：一个字符串，指定category特征的列。默认为空字符串。可以用数字做索引，如categorical\_feature=0,1,2表示第0,1,2列将作为category特征。注意：它是剔除了标签列之后的索引。你也可以为列名添加前缀，如categorical\_feature=prefix:cat\_name1,cat\_name2在categorycal特征中，负的取值被视作缺失值。
predict\_raw\_score或者raw\_score或者is\_predict\_raw\_score：一个布尔值，表示是否预测原始得分。默认为False。如果为True则仅预测原始得分。该参数只用于prediction任务。
predict\_leaf\_index或者leaf\_index或者is\_predict\_leaf\_index：一个布尔值，表示是否预测每个样本在每棵树上的叶节点编号。默认为False。在预测时，每个样本都会被分配到每棵树的某个叶子节点上。该参数就是要输出这些叶子节点的编号。该参数只用于prediction任务。
predict\_contrib或者contrib或者is\_predict\_contrib：一个布尔值，表示是否输出每个特征对于每个样本的预测的贡献。默认为False。输出的结果形状为nsamples,nfeatures+1，之所以+1是考虑到bais的贡献。所有的贡献加起来就是该样本的预测结果。该参数只用于prediction任务。
bin\_construct\_sample\_cnt或者subsample\_for\_bin：一个整数，表示用来构建直方图的样本的数量。默认为200000。如果数据非常稀疏，则可以设置为一个更大的值，如果设置更大的值，则会提供更好的训练效果，但是会增加数据加载时间。
num\_iteration\_predict：一个整数，表示在预测中使用多少棵子树。默认为-1。小于等于0表示使用模型的所有子树。该参数只用于prediction任务。
pred\_early\_stop：一个布尔值，表示是否使用早停来加速预测。默认为False。如果为True，则可能影响精度。
pred\_early\_stop\_freq：一个整数，表示检查早停的频率。默认为10
pred\_early\_stop\_margin：一个浮点数，表示早停的边际阈值。默认为0
use\_missing：一个布尔值，表示是否使用缺失值功能。默认为True如果为False则禁用缺失值功能。
zero\_as\_missing：一个布尔值，表示是否将所有的零(包括在libsvm/sparse矩阵中未显示的值)都视为缺失值。默认为False。如果为False，则将nan视作缺失值。如果为True，则np.nan和零都将视作缺失值。
init\_score\_file：一个字符串，表示训练时的初始化分数文件的路径。默认为空字符串，表示train_data_file+”.init”(如果存在)
valid\_init\_score\_file：一个字符串，表示验证时的初始化分数文件的路径。默认为空字符串，表示valid_data_file+”.init”(如果存在)。如果有多个(对应于多个验证集)，则可以用逗号,来分隔。

(4) 目标参数

sigmoid：一个浮点数，用sigmoid函数的参数，默认为0。它用于二分类任务和lambdarank任务。
alpha：一个浮点数，用于Huber损失函数和Quantileregression，默认值为0。它用于huber回归任务和Quantile回归任务。
fair\_c：一个浮点数，用于Fair损失函数，默认值为0。它用于fair回归任务。
gaussian\_eta：一个浮点数，用于控制高斯函数的宽度，默认值为0。它用于regression_l1回归任务和huber回归任务。
posson\_max\_delta\_step：一个浮点数，用于Poisson regression的参数，默认值为7。它用于poisson回归任务。
scale\_pos\_weight：一个浮点数，用于调整正样本的权重，默认值为0它用于二分类任务。
boost\_from\_average：一个布尔值，指示是否将初始得分调整为平均值(它可以使得收敛速度更快)。默认为True。它用于回归任务。
is\_unbalance或者unbalanced\_set：一个布尔值，指示训练数据是否均衡的。默认为True。它用于二分类任务。
max\_position：一个整数，指示将在这个NDCG位置优化。默认为20。它用于lambdarank任务。
label\_gain：一个浮点数序列，给出了每个标签的增益。默认值为0,1,3,7,15,….它用于lambdarank任务。
num\_class或者num\_classes：一个整数，指示了多分类任务中的类别数量。默认为1它用于多分类任务。
reg\_sqrt：一个布尔值，默认为False。如果为True，则拟合的结果为：\sqrt{label}。同时预测的结果被自动转换为：{pred}^2。它用于回归任务。

(5) 度量参数

metric：一个字符串，指定了度量的指标，默认为：对于回归问题，使用l2；对于二分类问题，使用binary\_logloss；对于lambdarank问题，使用ndcg。如果有多个度量指标，则用逗号,分隔。
l1或者mean\_absolute\_error或者mae或者regression\_l1：表示绝对值损失。
l2或者mean\_squared\_error或者mse或者regression\_l2或者regression：表示平方损失。
l2\_root或者root\_mean\_squared\_error或者rmse：表示开方损失。
quantile：表示Quantile回归中的损失。
mape或者mean\_absolute\_percentage\_error：表示MAPE损失。
huber：表示huber损失。
fair：表示fair损失。
poisson：表示poisson回归的负对数似然。
gamma：表示gamma回归的负对数似然。
gamma\_deviance：表示gamma回归的残差的方差。
tweedie：表示Tweedie回归的负对数似然。
ndcg：表示NDCG。
map或者mean\_average\_precision：表示平均的精度。
auc：表示AUC。
binary\_logloss或者binary：表示二类分类中的对数损失函数。
binary\_error：表示二类分类中的分类错误率。
multi\_logloss或者multiclass或者softmax或者‘multiclassova或者multiclass_ova，或者ova或者ovr`：表示多类分类中的对数损失函数。
multi\_error：表示多分类中的分类错误率。
xentropy或者cross\_entropy：表示交叉熵。
xentlambda或者cross\_entropy\_lambda：表示intensity加权的交叉熵。
kldiv或者kullback\_leibler：表示KL散度。
metric\_freq或者output\_freq：一个正式，表示每隔多少次输出一次度量结果。默认为1。
train\_metric或者training\_metric或者is\_training\_metric：一个布尔值，默认为False。如果为True，则在训练时就输出度量结果。
ndcg\_at或者ndcg\_eval\_at或者eval\_at：一个整数列表，指定了NDCG评估点的位置。默认为1、2、3、4、5。

2.2 参数影响与调参建议

以下为总结的核心参数对模型的影响，及与之对应的调参建议。

(1) 对树生长控制

num\_leaves：叶节点的数目。它是控制树模型复杂度的主要参数。
如果是level-wise，则该参数为$2^{depth}$，其中depth为树的深度。但是当叶子数量相同时，leaf-wise的树要远远深过level-wise树，非常容易导致过拟合。因此应该让num_leaves小于$2^{depth}$。在leaf-wise树中，并不存在depth的概念。因为不存在一个从leaves到depth的合理映射。
min\_data\_in\_leaf：每个叶节点的最少样本数量。
它是处理leaf-wise树的过拟合的重要参数。将它设为较大的值，可以避免生成一个过深的树。但是也可能导致欠拟合。
max\_depth：树的最大深度。该参数可以显式的限制树的深度。

(2) 更快的训练速度

通过设置bagging\_fraction和bagging\_freq参数来使用bagging方法。
通过设置feature\_fraction参数来使用特征的子抽样。
使用较小的max\_bin。
使用save\_binary在未来的学习过程对数据加载进行加速。

(3) 更好的模型效果

使用较大的max\_bin(学习速度可能变慢)。
使用较小的learning\_rate和较大的num\_iterations。
使用较大的num\_leaves(可能导致过拟合)。
使用更大的训练数据。
尝试dart。

(4) 缓解过拟合问题

使用较小的max\_bin。
使用较小的num\_leaves。
使用min\_data\_in\_leaf和min\_sum\_hessian\_in\_leaf。
通过设置bagging\_fraction和bagging\_freq来使用bagging。
通过设置feature\_fraction来使用特征子抽样。
使用更大的训练数据。
使用lambda\_l1、lambda\_l2和min\_gain\_to\_split来使用正则。
尝试max\_depth来避免生成过深的树。

3.LightGBM内置建模方式

3.1 内置建模方式

LightGBM内置了建模方式，有如下的数据格式与核心训练方法：

基于lightgbm.Dataset格式的数据。
基于lightgbm.train接口训练。

下面是官方的一个简单示例，演示了读取libsvm格式数据(成Dataset格式)并指定参数建模的过程。

# coding: utf-8

import json

import lightgbm as lgb

import pandas as pd

from sklearn.metrics import mean\_squared\_erro





# 加载数据集合

print('加载数据...')

df\_train = pd.read\_csv('./data/regression.train.txt', header=None, sep='\t')

df\_test = pd.read\_csv('./data/regression.test.txt', header=None, sep='\t')



# 设定训练集和测试集

y\_train = df\_train[0].values

y\_test = df\_test[0].values

X\_train = df\_train.drop(0, axis=1).values

X\_test = df\_test.drop(0, axis=1).values



# 构建lgb中的Dataset格式

lgb\_train = lgb.Dataset(X\_train, y\_train)

lgb\_eval = lgb.Dataset(X\_test, y\_test, reference=lgb\_train)



# 敲定好一组参数

params = {

    'task': 'train',

    'boosting\_type': 'gbdt',

    'objective': 'regression',

    'metric': {'l2', 'auc'},

    'num\_leaves': 31,

    'learning\_rate': 0.05,

    'feature\_fraction': 0.9,

    'bagging\_fraction': 0.8,

    'bagging\_freq': 5,

    'verbose': 0

}



print('开始训练...')

# 训练

gbm = lgb.train(params,

                lgb\_train,

                num\_boost\_round=20,

                valid\_sets=lgb\_eval,

                early\_stopping\_rounds=5)



# 保存模型

print('保存模型...')

# 保存模型到文件中

gbm.save\_model('model.txt')



print('开始预测...')

# 预测

y\_pred = gbm.predict(X\_test, num\_iteration=gbm.best\_iteration)

# 评估

print('预估结果的rmse为:')

print(mean\_squared\_error(y\_test, y\_pred) \*\* 0.5)

加载数据...

开始训练...

[1]  valid\_0's l2: 0.24288   valid\_0's auc: 0.764496

Training until validation scores don't improve for 5 rounds.

[2]  valid\_0's l2: 0.239307  valid\_0's auc: 0.766173

[3]  valid\_0's l2: 0.235559  valid\_0's auc: 0.785547

[4]  valid\_0's l2: 0.230771  valid\_0's auc: 0.797786

[5]  valid\_0's l2: 0.226297  valid\_0's auc: 0.805155

[6]  valid\_0's l2: 0.223692  valid\_0's auc: 0.800979

[7]  valid\_0's l2: 0.220941  valid\_0's auc: 0.806566

[8]  valid\_0's l2: 0.217982  valid\_0's auc: 0.808566

[9]  valid\_0's l2: 0.215351  valid\_0's auc: 0.809041

[10] valid\_0's l2: 0.213064  valid\_0's auc: 0.805953

[11] valid\_0's l2: 0.211053  valid\_0's auc: 0.804631

[12] valid\_0's l2: 0.209336  valid\_0's auc: 0.802922

[13] valid\_0's l2: 0.207492  valid\_0's auc: 0.802011

[14] valid\_0's l2: 0.206016  valid\_0's auc: 0.80193

Early stopping, best iteration is:

[9]  valid\_0's l2: 0.215351  valid\_0's auc: 0.809041

保存模型...

开始预测...

预估结果的rmse为:

0.4640593794679212

3.2 设置样本权重

LightGBM的建模非常灵活，它可以支持我们对于每个样本设置不同的权重学习，设置的方式也非常简单，我们需要提供给模型一组权重数组数据，长度和样本数一致。

如下是一个典型的例子，其中binary.train和binary.test读取后加载为lightgbm.Dataset格式的输入，而在lightgbm.Dataset的构建参数中可以设置样本权重(这个例子中是numpy array的形态)。再基于lightgbm.train接口使用内置建模方式训练。

# coding: utf-8

import json

import lightgbm as lgb

import pandas as pd

import numpy as np

from sklearn.metrics import mean\_squared\_erro

import warnings

warnings.filterwarnings("ignore")



# 加载数据集

print('加载数据...')

df\_train = pd.read\_csv('./data/binary.train', header=None, sep='\t')

df\_test = pd.read\_csv('./data/binary.test', header=None, sep='\t')

W\_train = pd.read\_csv('./data/binary.train.weight', header=None)[0]

W\_test = pd.read\_csv('./data/binary.test.weight', header=None)[0]



y\_train = df\_train[0].values

y\_test = df\_test[0].values

X\_train = df\_train.drop(0, axis=1).values

X\_test = df\_test.drop(0, axis=1).values



num\_train, num\_feature = X\_train.shape



# 加载数据的同时加载权重

lgb\_train = lgb.Dataset(X\_train, y\_train,

                        weight=W\_train, free\_raw\_data=False)

lgb\_eval = lgb.Dataset(X\_test, y\_test, reference=lgb\_train,

                       weight=W\_test, free\_raw\_data=False)



# 设定参数

params = {

    'boosting\_type': 'gbdt',

    'objective': 'binary',

    'metric': 'binary\_logloss',

    'num\_leaves': 31,

    'learning\_rate': 0.05,

    'feature\_fraction': 0.9,

    'bagging\_fraction': 0.8,

    'bagging\_freq': 5,

    'verbose': 0

}



# 产出特征名称

feature\_name = ['feature\_' + str(col) for col in range(num\_feature)]



print('开始训练...')

gbm = lgb.train(params,

                lgb\_train,

                num\_boost\_round=10,

                valid\_sets=lgb\_train,  # 评估训练集

                feature\_name=feature\_name,

                categorical\_feature=[21])

加载数据...

开始训练...

[1]  training's binary\_logloss: 0.68205

[2]  training's binary\_logloss: 0.673618

[3]  training's binary\_logloss: 0.665891

[4]  training's binary\_logloss: 0.656874

[5]  training's binary\_logloss: 0.648523

[6]  training's binary\_logloss: 0.641874

[7]  training's binary\_logloss: 0.636029

[8]  training's binary\_logloss: 0.629427

[9]  training's binary\_logloss: 0.623354

[10] training's binary\_logloss: 0.617593

3.3 模型存储与加载

上述建模过程得到的模型对象，可以通过save_model成员函数进行保存。保存好的模型可以通过lgb.Booster加载回内存，并对测试集进行预测。

具体示例代码如下：

# 查看特征名称

print('完成10轮训练...')

print('第7个特征为:')

print(repr(lgb\_train.feature\_name[6]))



# 存储模型

gbm.save\_model('./model/lgb\_model.txt')



# 特征名称

print('特征名称:')

print(gbm.feature\_name())



# 特征重要度

print('特征重要度:')

print(list(gbm.feature\_importance()))



# 加载模型

print('加载模型用于预测')

bst = lgb.Booster(model\_file='./model/lgb\_model.txt')



# 预测

y\_pred = bst.predict(X\_test)



# 在测试集评估效果

print('在测试集上的rmse为:')

print(mean\_squared\_error(y\_test, y\_pred) \*\* 0.5)

完成10轮训练...

第7个特征为:

'feature\_6'

特征名称:

['feature\_0', 'feature\_1', 'feature\_2', 'feature\_3', 'feature\_4', 'feature\_5', 'feature\_6', 'feature\_7', 'feature\_8', 'feature\_9', 'feature\_10', 'feature\_11', 'feature\_12', 'feature\_13', 'feature\_14', 'feature\_15', 'feature\_16', 'feature\_17', 'feature\_18', 'feature\_19', 'feature\_20', 'feature\_21', 'feature\_22', 'feature\_23', 'feature\_24', 'feature\_25', 'feature\_26', 'feature\_27']

特征重要度:

[8, 5, 1, 19, 7, 33, 2, 0, 2, 10, 5, 2, 0, 9, 3, 3, 0, 2, 2, 5, 1, 0, 36, 3, 33, 45, 29, 35]

加载模型用于预测

在测试集上的rmse为:

0.4629245607636925

3.4 继续训练

LightGBM为boosting模型，每一轮训练会增加新的基学习器，LightGBM还支持基于现有模型和参数继续训练，无需每次从头训练。

如下是典型的示例，我们加载已经训练10轮(即10颗树集成)的lgb模型，在此基础上继续训练(在参数层面做了一些改变，调整了学习率，增加了一些bagging等缓解过拟合的处理方法)

# 继续训练

# 从./model/model.txt中加载模型初始化

gbm = lgb.train(params,

                lgb\_train,

                num\_boost\_round=10,

                init\_model='./model/lgb\_model.txt',

                valid\_sets=lgb\_eval)



print('以旧模型为初始化，完成第 10-20 轮训练...')



# 在训练的过程中调整超参数

# 比如这里调整的是学习率

gbm = lgb.train(params,

                lgb\_train,

                num\_boost\_round=10,

                init\_model=gbm,

                learning\_rates=lambda iter: 0.05 \* (0.99 \*\* iter),

                valid\_sets=lgb\_eval)



print('逐步调整学习率完成第 20-30 轮训练...')



# 调整其他超参数

gbm = lgb.train(params,

                lgb\_train,

                num\_boost\_round=10,

                init\_model=gbm,

                valid\_sets=lgb\_eval,

                callbacks=[lgb.reset\_parameter(bagging\_fraction=[0.7] \* 5 + [0.6] \* 5)])



print('逐步调整bagging比率完成第 30-40 轮训练...')

[11] valid\_0's binary\_logloss: 0.616177

[12] valid\_0's binary\_logloss: 0.611792

[13] valid\_0's binary\_logloss: 0.607043

[14] valid\_0's binary\_logloss: 0.602314

[15] valid\_0's binary\_logloss: 0.598433

[16] valid\_0's binary\_logloss: 0.595238

[17] valid\_0's binary\_logloss: 0.592047

[18] valid\_0's binary\_logloss: 0.588673

[19] valid\_0's binary\_logloss: 0.586084

[20] valid\_0's binary\_logloss: 0.584033

以旧模型为初始化，完成第 10-20 轮训练...

[21] valid\_0's binary\_logloss: 0.616177

[22] valid\_0's binary\_logloss: 0.611834

[23] valid\_0's binary\_logloss: 0.607177

[24] valid\_0's binary\_logloss: 0.602577

[25] valid\_0's binary\_logloss: 0.59831

[26] valid\_0's binary\_logloss: 0.595259

[27] valid\_0's binary\_logloss: 0.592201

[28] valid\_0's binary\_logloss: 0.589017

[29] valid\_0's binary\_logloss: 0.586597

[30] valid\_0's binary\_logloss: 0.584454

逐步调整学习率完成第 20-30 轮训练...

[31] valid\_0's binary\_logloss: 0.616053

[32] valid\_0's binary\_logloss: 0.612291

[33] valid\_0's binary\_logloss: 0.60856

[34] valid\_0's binary\_logloss: 0.605387

[35] valid\_0's binary\_logloss: 0.601744

[36] valid\_0's binary\_logloss: 0.598556

[37] valid\_0's binary\_logloss: 0.595585

[38] valid\_0's binary\_logloss: 0.593228

[39] valid\_0's binary\_logloss: 0.59018

[40] valid\_0's binary\_logloss: 0.588391

逐步调整bagging比率完成第 30-40 轮训练...

3.5 自定义损失函数

LightGBM支持在训练过程中，自定义损失函数和评估准则，其中损失函数的定义需要返回损失函数一阶和二阶导数的计算方法，评估准则部分需要对数据的label和预估值进行计算。其中损失函数用于训练过程中的树结构学习，而评估准则很多时候是用在验证集上进行效果评估。

# 自定义损失函数需要提供损失函数的一阶和二阶导数形式

def loglikelood(preds, train\_data):

    labels = train\_data.get\_label()

    preds = 1. / (1. + np.exp(-preds))

    grad = preds - labels

    hess = preds \* (1. - preds)

    return grad, hess





# 自定义评估函数

def binary\_error(preds, train\_data):

    labels = train\_data.get\_label()

    return 'error', np.mean(labels != (preds > 0.5)), False





gbm = lgb.train(params,

                lgb\_train,

                num\_boost\_round=10,

                init\_model=gbm,

                fobj=loglikelood,

                feval=binary\_error,

                valid\_sets=lgb\_eval)



print('用自定义的损失函数与评估标准完成第40-50轮...')

[41] valid\_0's binary\_logloss: 0.614429  valid\_0's error: 0.268

[42] valid\_0's binary\_logloss: 0.610689  valid\_0's error: 0.26

[43] valid\_0's binary\_logloss: 0.606267  valid\_0's error: 0.264

[44] valid\_0's binary\_logloss: 0.601949  valid\_0's error: 0.258

[45] valid\_0's binary\_logloss: 0.597271  valid\_0's error: 0.266

[46] valid\_0's binary\_logloss: 0.593971  valid\_0's error: 0.276

[47] valid\_0's binary\_logloss: 0.591427  valid\_0's error: 0.278

[48] valid\_0's binary\_logloss: 0.588301  valid\_0's error: 0.284

[49] valid\_0's binary\_logloss: 0.586562  valid\_0's error: 0.288

[50] valid\_0's binary\_logloss: 0.584056  valid\_0's error: 0.288

用自定义的损失函数与评估标准完成第40-50轮...

4.LightGBM预估器形态接口

4.1 SKLearn形态预估器接口

和XGBoost一样，LightGBM也支持用SKLearn中统一的预估器形态接口进行建模，如下为典型的参考案例，对于读取为Dataframe格式的训练集和测试集，可以直接使用LightGBM初始化LGBMRegressor进行fit拟合训练。使用方法与接口，和SKLearn中其他预估器一致。

# coding: utf-8

import lightgbm as lgb

import pandas as pd

from sklearn.metrics import mean\_squared\_erro

from sklearn.model\_selection import GridSearchCV



# 加载数据

print('加载数据...')

df\_train = pd.read\_csv('./data/regression.train.txt', header=None, sep='\t')

df\_test = pd.read\_csv('./data/regression.test.txt', header=None, sep='\t')



# 取出特征和标签

y\_train = df\_train[0].values

y\_test = df\_test[0].values

X\_train = df\_train.drop(0, axis=1).values

X\_test = df\_test.drop(0, axis=1).values



print('开始训练...')

# 初始化LGBMRegresso

gbm = lgb.LGBMRegressor(objective='regression',

                        num\_leaves=31,

                        learning\_rate=0.05,

                        n\_estimators=20)



# 使用fit函数拟合

gbm.fit(X\_train, y\_train,

        eval\_set=[(X\_test, y\_test)],

        eval\_metric='l1',

        early\_stopping\_rounds=5)



# 预测

print('开始预测...')

y\_pred = gbm.predict(X\_test, num\_iteration=gbm.best\_iteration\_)

# 评估预测结果

print('预测结果的rmse是:')

print(mean\_squared\_error(y\_test, y\_pred) \*\* 0.5)

加载数据...

开始训练...

[1]  valid\_0's l1: 0.491735

Training until validation scores don't improve for 5 rounds.

[2]  valid\_0's l1: 0.486563

[3]  valid\_0's l1: 0.481489

[4]  valid\_0's l1: 0.476848

[5]  valid\_0's l1: 0.47305

[6]  valid\_0's l1: 0.469049

[7]  valid\_0's l1: 0.465556

[8]  valid\_0's l1: 0.462208

[9]  valid\_0's l1: 0.458676

[10] valid\_0's l1: 0.454998

[11] valid\_0's l1: 0.452047

[12] valid\_0's l1: 0.449158

[13] valid\_0's l1: 0.44608

[14] valid\_0's l1: 0.443554

[15] valid\_0's l1: 0.440643

[16] valid\_0's l1: 0.437687

[17] valid\_0's l1: 0.435454

[18] valid\_0's l1: 0.433288

[19] valid\_0's l1: 0.431297

[20] valid\_0's l1: 0.428946

Did not meet early stopping. Best iteration is:

[20] valid\_0's l1: 0.428946

开始预测...

预测结果的rmse是:

0.4441153344254208

4.2 网格搜索调参

上面提到LightGBM的预估器接口，整体使用方法和SKLearn中其他预估器一致，所以我们也可以使用SKLearn中的超参数调优方法来进行模型调优。

如下是一个典型的网格搜索交法调优超参数的代码示例，我们会给出候选参数列表字典，通过GridSearchCV进行交叉验证实验评估，选出LightGBM在候选参数中最优的超参数。

# 配合scikit-learn的网格搜索交叉验证选择最优超参数

estimator = lgb.LGBMRegressor(num\_leaves=31)



param\_grid = {

    'learning\_rate': [0.01, 0.1, 1],

    'n\_estimators': [20, 40]

}



gbm = GridSearchCV(estimator, param\_grid)



gbm.fit(X\_train, y\_train)



print('用网格搜索找到的最优超参数为:')

print(gbm.best\_params\_)

用网格搜索找到的最优超参数为:

{'learning\_rate': 0.1, 'n\_estimators': 40}

4.3 绘图解释

LightGBM支持对模型训练进行可视化呈现与解释，包括对于训练过程中的损失函数取值与评估准则结果的可视化、训练完成后特征重要度的排序与可视化、基学习器(比如决策树)的可视化。

以下为参考代码：

# coding: utf-8

import lightgbm as lgb

import pandas as pd



try:

    import matplotlib.pyplot as plt

except ImportError:

    raise ImportError('You need to install matplotlib for plotting.')



# 加载数据集

print('加载数据...')

df\_train = pd.read\_csv('./data/regression.train.txt', header=None, sep='\t')

df\_test = pd.read\_csv('./data/regression.test.txt', header=None, sep='\t')



# 取出特征和标签

y\_train = df\_train[0].values

y\_test = df\_test[0].values

X\_train = df\_train.drop(0, axis=1).values

X\_test = df\_test.drop(0, axis=1).values



# 构建lgb中的Dataset数据格式

lgb\_train = lgb.Dataset(X\_train, y\_train)

lgb\_test = lgb.Dataset(X\_test, y\_test, reference=lgb\_train)



# 设定参数

params = {

    'num\_leaves': 5,

    'metric': ('l1', 'l2'),

    'verbose': 0

}



evals\_result = {}  # to record eval results for plotting



print('开始训练...')

# 训练

gbm = lgb.train(params,

                lgb\_train,

                num\_boost\_round=100,

                valid\_sets=[lgb\_train, lgb\_test],

                feature\_name=['f' + str(i + 1) for i in range(28)],

                categorical\_feature=[21],

                evals\_result=evals\_result,

                verbose\_eval=10)



print('在训练过程中绘图...')

ax = lgb.plot\_metric(evals\_result, metric='l1')

plt.show()



print('画出特征重要度...')

ax = lgb.plot\_importance(gbm, max\_num\_features=10)

plt.show()



print('画出第84颗树...')

ax = lgb.plot\_tree(gbm, tree\_index=83, figsize=(20, 8), show\_info=['split\_gain'])

plt.show()



#print('用graphviz画出第84颗树...')

#graph = lgb.create\_tree\_digraph(gbm, tree\_index=83, name='Tree84')

#graph.render(view=True)

加载数据...

开始训练...

[10] training's l2: 0.217995 training's l1: 0.457448 valid\_1's l2: 0.21641   valid\_1's l1: 0.456464

[20] training's l2: 0.205099 training's l1: 0.436869 valid\_1's l2: 0.201616  valid\_1's l1: 0.434057

[30] training's l2: 0.197421 training's l1: 0.421302 valid\_1's l2: 0.192514  valid\_1's l1: 0.417019

[40] training's l2: 0.192856 training's l1: 0.411107 valid\_1's l2: 0.187258  valid\_1's l1: 0.406303

[50] training's l2: 0.189593 training's l1: 0.403695 valid\_1's l2: 0.183688  valid\_1's l1: 0.398997

[60] training's l2: 0.187043 training's l1: 0.398704 valid\_1's l2: 0.181009  valid\_1's l1: 0.393977

[70] training's l2: 0.184982 training's l1: 0.394876 valid\_1's l2: 0.178803  valid\_1's l1: 0.389805

[80] training's l2: 0.1828   training's l1: 0.391147 valid\_1's l2: 0.176799  valid\_1's l1: 0.386476

[90] training's l2: 0.180817 training's l1: 0.388101 valid\_1's l2: 0.175775  valid\_1's l1: 0.384404

[100]   training's l2: 0.179171 training's l1: 0.385174 valid\_1's l2: 0.175321  valid\_1's l1: 0.382929

参考资料

ShowMeAI系列教程推荐

机器学习实战：手把手教你玩转机器学习系列

图解机器学习算法&实战 ◉ 从入门到精通

机器学习实战 | LightGBM建模应用详解

引言

1.LightGBM安装

1.1 Python与IDE环境设置

1.2 工具库安装

(1) Linux/Mac等系统

(2) Windows系统

2.LightGBM参数手册

2.1 参数介绍

(1) 核心参数

(2) 学习控制参数

(3) IO参数

(4) 目标参数

(5) 度量参数

2.2 参数影响与调参建议

(1) 对树生长控制

(2) 更快的训练速度

(3) 更好的模型效果

(4) 缓解过拟合问题

3.LightGBM内置建模方式

3.1 内置建模方式

3.2 设置样本权重

3.3 模型存储与加载

3.4 继续训练

3.5 自定义损失函数

4.LightGBM预估器形态接口

4.1 SKLearn形态预估器接口

4.2 网格搜索调参

4.3 绘图解释

参考资料

ShowMeAI系列教程推荐

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐