轻量级梯度提升机，简称 LightGBM，是一个开源库，提供了一种高效且有效的梯度提升算法实现。
LightGBM 通过添加一种自动特征选择以及专注于提升具有更大梯度的样本来扩展梯度提升算法。这可以显著加快训练速度并提高预测性能。
因此，LightGBM 已成为处理表格数据的回归和分类预测建模任务时，机器学习竞赛的实际算法。正因为如此，它与极限梯度提升（XGBoost）一起，在梯度提升方法日益普及和广泛应用方面，也有一部分功劳。
在本教程中，您将学习如何开发用于分类和回归的轻量级梯度提升机集成模型。
完成本教程后，您将了解：
- 轻量级梯度提升机（LightGBM）是随机梯度提升集成算法的高效开源实现。
- 如何使用 scikit-learn API 开发用于分类和回归的 LightGBM 集成模型。
- 如何探索 LightGBM 模型超参数对模型性能的影响。
通过我的新书《使用 Python 的集成学习算法》启动您的项目，其中包括所有示例的分步教程和Python 源代码文件。
让我们开始吧。
如何开发轻量级梯度提升机（LightGBM）集成
图片由 GPA Photo Archive 提供，保留部分权利。
教程概述
本教程分为三个部分；它们是：
- 轻量级梯度提升机算法
- LightGBM Scikit-Learn API
- 用于分类的 LightGBM 集成
- 用于回归的 LightGBM 集成
- LightGBM 超参数
- 探索树的数量
- 探索树深度
- 探索学习率
- 探索提升类型
轻量级梯度提升机算法
梯度提升是指一类集成机器学习算法，可用于分类或回归预测建模问题。
集成模型由决策树模型构建。树被一个接一个地添加到集成中，并进行拟合以纠正先前模型所做的预测错误。这是一种被称为“提升”的集成机器学习模型。
模型使用任何任意可微损失函数和梯度下降优化算法进行拟合。这赋予了该技术“梯度提升”的名称，因为在模型拟合时，损失梯度被最小化，很像神经网络。
有关梯度提升的更多信息，请参阅本教程。
轻量级梯度提升机，简称 LightGBM，是梯度提升的开源实现，旨在比其他实现更高效，或许也更有效。
因此，LightGBM 指的是开源项目、软件库和机器学习算法。在这方面，它与极限梯度提升或 XGBoost 技术非常相似。
LightGBM 由 Guolin Ke 等人在 2017 年的论文“LightGBM：一种高效的梯度提升决策树”中进行了描述。该实现引入了两个关键思想：GOSS 和 EFB。
基于梯度的单边采样，简称 GOSS，是对梯度提升方法的一种修改，它将注意力集中在那些导致更大梯度的训练样本上，从而加快学习速度并降低方法的计算复杂度。
通过GOSS，我们排除了大部分具有小梯度的数据实例，而只使用其余的数据来估计信息增益。我们证明，由于具有较大梯度的数据实例在信息增益的计算中扮演更重要的角色，GOSS可以以小得多的数据量获得相当准确的信息增益估计。
— LightGBM：一种高效的梯度提升决策树，2017。
独占特征捆绑，简称 EFB，是一种用于捆绑稀疏（大部分为零）互斥特征的方法，例如已进行独热编码的分类变量输入。因此，它是一种自动特征选择。
... 我们将互斥特征（即它们很少同时取非零值）捆绑起来，以减少特征数量。
— LightGBM：一种高效的梯度提升决策树，2017。
这两种改变加在一起可以将算法的训练时间加快达 20 倍。因此，LightGBM 可以被认为是增加了 GOSS 和 EFB 的梯度提升决策树（GBDT）。
我们将我们新的、带有 GOSS 和 EFB 的 GBDT 实现称为 LightGBM。我们在多个公共数据集上的实验表明，LightGBM 将传统 GBDT 的训练过程加速了 20 倍以上，同时实现了几乎相同的精度。
— LightGBM：一种高效的梯度提升决策树，2017。
想开始学习集成学习吗？
立即参加我为期7天的免费电子邮件速成课程（附示例代码）。
点击注册，同时获得该课程的免费PDF电子书版本。
LightGBM Scikit-Learn API
LightGBM 可以作为独立库安装，并且 LightGBM 模型可以使用 scikit-learn API 进行开发。
第一步是安装 LightGBM 库（如果尚未安装）。这可以通过大多数平台上的 pip python 包管理器实现；例如
|
1 |
sudo pip install lightgbm |
然后，您可以通过运行以下脚本来确认 LightGBM 库是否已正确安装并可以使用。
|
1 2 3 |
# 检查 LightGBM 版本 import lightgbm print(lightgbm.__version__) |
运行脚本将打印您已安装的 LightGBM 库的版本。
您的版本应相同或更高。如果不是，您必须升级您的 LightGBM 库版本。
|
1 |
2.3.1 |
如果您需要特定于您的开发环境的说明，请参阅教程：
LightGBM 库有其自己的自定义 API，尽管我们将通过 scikit-learn 包装器类：LGBMRegressor 和 LGBMClassifier 来使用该方法。这将允许我们使用 scikit-learn 机器学习库的完整工具套件来准备数据和评估模型。
这两个模型的运行方式相同，并接受相同的参数，这些参数影响决策树的创建和添加到集成中的方式。
模型构建中使用了随机性。这意味着每次在相同数据上运行算法时，它都会生成一个略有不同的模型。
当使用具有随机学习算法的机器学习算法时，通过对多次运行或交叉验证重复的性能进行平均来评估它们是一种好做法。在拟合最终模型时，可能需要增加树的数量，直到模型在重复评估中的方差减小，或者拟合多个最终模型并对其预测进行平均。
让我们看看如何开发用于分类和回归的 LightGBM 集成模型。
用于分类的 LightGBM 集成
在本节中，我们将介绍 LightGBM 在分类问题中的应用。
首先，我们可以使用 make_classification() 函数 创建一个包含 1,000 个示例和 20 个输入特征的合成二元分类问题。
完整的示例如下所示。
|
1 2 3 4 5 6 |
# 测试分类数据集 from sklearn.datasets import make_classification # 定义数据集 X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7) # 汇总数据集 print(X.shape, y.shape) |
运行示例会创建数据集并总结输入和输出组件的形状。
|
1 |
(1000, 20) (1000,) |
接下来，我们可以在这个数据集上评估 LightGBM 算法。
我们将使用重复分层 k 折交叉验证来评估模型，重复三次，折数为 10。我们将报告模型在所有重复和折中的平均准确率和标准差。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# 评估用于分类的 LightGBM 算法 from numpy import mean from numpy import std from sklearn.datasets import make_classification from sklearn.model_selection import cross_val_score from sklearn.model_selection import RepeatedStratifiedKFold from lightgbm import LGBMClassifier # 定义数据集 X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7) # 定义模型 model = LGBMClassifier() # 评估模型 cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) # 报告表现 print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores))) |
运行示例报告了模型的平均准确度和标准差。
注意：考虑到算法或评估过程的随机性以及数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
在这种情况下，我们可以看到默认超参数的 LightGBM 集成在这个测试数据集上达到了大约 92.5% 的分类准确率。
|
1 |
准确率：0.925 (0.031) |
我们还可以使用 LightGBM 模型作为最终模型，并进行分类预测。
首先，LightGBM 集成在所有可用数据上进行拟合，然后可以调用 predict() 函数对新数据进行预测。
以下示例在我们的二元分类数据集上演示了这一点。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
# 使用LightGBM进行分类预测 from sklearn.datasets import make_classification from lightgbm import LGBMClassifier # 定义数据集 X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7) # 定义模型 model = LGBMClassifier() # 在整个数据集上拟合模型 model.fit(X, y) # 进行单次预测 row = [0.2929949,-4.21223056,-1.288332,-2.17849815,-0.64527665,2.58097719,0.28422388,-7.1827928,-1.91211104,2.73729512,0.81395695,3.96973717,-2.66939799,3.34692332,4.19791821,0.99990998,-0.30201875,-4.43170633,-2.82646737,0.44916808] yhat = model.predict([row]) print('Predicted Class: %d' % yhat[0]) |
运行示例将LightGBM集成模型拟合到整个数据集上，然后用于对新数据行进行预测，就像我们在应用程序中使用模型时一样。
|
1 |
预测类别：1 |
既然我们熟悉了使用 LightGBM 进行分类，下面我们来看看回归的 API。
用于回归的 LightGBM 集成
在本节中，我们将介绍 LightGBM 在回归问题中的应用。
首先，我们可以使用 make_regression() 函数 创建一个包含 1,000 个示例和 20 个输入特征的合成回归问题。
完整的示例如下所示。
|
1 2 3 4 5 6 |
# 测试回归数据集 from sklearn.datasets import make_regression # 定义数据集 X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=7) # 汇总数据集 print(X.shape, y.shape) |
运行示例会创建数据集并总结输入和输出组件的形状。
|
1 |
(1000, 20) (1000,) |
接下来，我们可以在这个数据集上评估 LightGBM 算法。
像上一节一样，我们将使用重复 k 折交叉验证来评估模型，进行三次重复和 10 折。我们将报告模型在所有重复和折叠中的平均绝对误差 (MAE)。scikit-learn 库将 MAE 设为负值，使其最大化而不是最小化。这意味着负值越大越好，完美模型的 MAE 为 0。
完整的示例如下所示。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# 评估用于回归的 LightGBM 集成 from numpy import mean from numpy import std from sklearn.datasets import make_regression from sklearn.model_selection import cross_val_score from sklearn.model_selection import RepeatedKFold from lightgbm import LGBMRegressor # 定义数据集 X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=7) # 定义模型 model = LGBMRegressor() # 评估模型 cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1) n_scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise') # 报告表现 print('MAE: %.3f (%.3f)' % (mean(n_scores), std(n_scores))) |
运行示例报告了模型的平均准确度和标准差。
注意：考虑到算法或评估过程的随机性以及数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
在这种情况下，我们可以看到默认超参数的 LightGBM 集成实现了大约 60 的 MAE。
|
1 |
MAE：-60.004 (2.887) |
我们还可以使用 LightGBM 模型作为最终模型，并进行回归预测。
首先，LightGBM 集成在所有可用数据上进行拟合，然后可以调用 predict() 函数对新数据进行预测。
以下示例在我们的回归数据集上演示了这一点。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
# 用于回归预测的 LightGBM 梯度模型 from sklearn.datasets import make_regression from lightgbm import LGBMRegressor # 定义数据集 X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=7) # 定义模型 model = LGBMRegressor() # 在整个数据集上拟合模型 model.fit(X, y) # 进行单次预测 row = [0.20543991,-0.97049844,-0.81403429,-0.23842689,-0.60704084,-0.48541492,0.53113006,2.01834338,-0.90745243,-1.85859731,-1.02334791,-0.6877744,0.60984819,-0.70630121,-1.29161497,1.32385441,1.42150747,1.26567231,2.56569098,-0.11154792] yhat = model.predict([row]) print('Prediction: %d' % yhat[0]) |
运行示例将LightGBM集成模型拟合到整个数据集上，然后用于对新数据行进行预测，就像我们在应用程序中使用模型时一样。
|
1 |
预测：52 |
现在我们已经熟悉了使用 scikit-learn API 评估和使用 LightGBM 集成模型，接下来让我们看看如何配置模型。
LightGBM 超参数
在本节中，我们将仔细研究您应该考虑调整的一些 LightGBM 集成超参数及其对模型性能的影响。
LightGBM 有许多超参数我们可以研究，但在此我们主要关注集成中使用的决策树数量和树深度、学习率以及提升类型。
有关调整 LightGBM 超参数的良好通用建议，请参阅文档
探索树的数量
LightGBM 集成算法的一个重要超参数是集成中使用的决策树的数量。
回想一下，决策树是按顺序添加到模型中的，以努力纠正和改进先前树所做的预测。因此，更多的树通常会更好。
树的数量可以通过“n_estimators”参数设置，默认为 100。
下面的示例探讨了树的数量在 10 到 5,000 之间对性能的影响。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
# 探索 LightGBM 树的数量对性能的影响 from numpy import mean from numpy import std from sklearn.datasets import make_classification from sklearn.model_selection import cross_val_score from sklearn.model_selection import RepeatedStratifiedKFold from lightgbm import LGBMClassifier from matplotlib import pyplot # 获取数据集 定义 获取_数据集(): X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7) 返回 X, y # 获取要评估的模型列表 定义 获取_模型(): models = dict() trees = [10, 50, 100, 500, 1000, 5000] for n in trees: models[str(n)] = LGBMClassifier(n_estimators=n) 返回 模型 # 使用交叉验证评估给定模型 def evaluate_model(model): cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) 返回 分数 # 定义数据集 X, y = get_dataset() # 获取要评估的模型 模型 = 获取_模型() # 评估模型并存储结果 results, names = list(), list() for name, model in models.items(): scores = evaluate_model(model) results.append(scores) names.append(name) print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores))) # 绘制模型性能以供比较 pyplot.boxplot(results, labels=names, showmeans=True) pyplot.show() |
运行示例首先报告每个配置的决策树数量的平均准确率。
注意：考虑到算法或评估过程的随机性以及数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
在这种情况下，我们可以看到在这个数据集上，性能提高到大约 500 棵树，之后性能似乎趋于平稳。
|
1 2 3 4 5 6 |
>10 0.857 (0.033) >50 0.916 (0.032) >100 0.925 (0.031) >500 0.938 (0.026) >1000 0.938 (0.028) >5000 0.937 (0.028) |
为每个配置的树数量创建了准确率分数的箱线图。
我们可以看到模型性能和集成规模增加的总体趋势。
LightGBM 集成大小与分类准确率的箱线图
探索树深度
改变集成中每棵树的深度是梯度提升的另一个重要超参数。
树的深度控制了每棵树对训练数据集的专业程度：它可能有多通用或过拟合。我们倾向于选择深度适中、既不过于浅而通用（如 AdaBoost）也不过于深而专业（如自助聚合）的树。
梯度提升通常在具有适中深度的树上表现良好，在技能和通用性之间找到了平衡。
树的深度通过“max_depth”参数控制，默认为未指定值，因为控制树复杂度的默认机制是使用叶节点数量。
控制树复杂度有两种主要方法：树的最大深度和树中的最大终端节点（叶子）数量。在这种情况下，我们正在探索叶子数量，因此我们需要通过设置“num_leaves”参数来增加叶子数量以支持更深的树。
下面的示例探讨了 1 到 10 之间的树深度以及对模型性能的影响。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
# 探索LightGBM树深度对性能的影响 from numpy import mean from numpy import std from sklearn.datasets import make_classification from sklearn.model_selection import cross_val_score from sklearn.model_selection import RepeatedStratifiedKFold from lightgbm import LGBMClassifier from matplotlib import pyplot # 获取数据集 定义 获取_数据集(): X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7) 返回 X, y # 获取要评估的模型列表 定义 获取_模型(): models = dict() for i in range(1,11): models[str(i)] = LGBMClassifier(max_depth=i, num_leaves=2**i) 返回 模型 # 使用交叉验证评估给定模型 def evaluate_model(model): cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) 返回 分数 # 定义数据集 X, y = get_dataset() # 获取要评估的模型 模型 = 获取_模型() # 评估模型并存储结果 results, names = list(), list() for name, model in models.items(): scores = evaluate_model(model) results.append(scores) names.append(name) print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores))) # 绘制模型性能以供比较 pyplot.boxplot(results, labels=names, showmeans=True) pyplot.show() |
运行示例首先报告每个配置的树深度的平均准确率。
注意：考虑到算法或评估过程的随机性以及数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
在这种情况下，我们可以看到性能随着树的深度增加而提高，甚至可能达到 10 层。探索更深的树可能会很有趣。
|
1 2 3 4 5 6 7 8 9 10 |
>1 0.833 (0.028) >2 0.870 (0.033) >3 0.899 (0.032) >4 0.912 (0.026) >5 0.925 (0.031) >6 0.924 (0.029) >7 0.922 (0.027) >8 0.926 (0.027) >9 0.925 (0.028) >10 0.928 (0.029) |
为每个配置的树深度的准确率分布创建了一个箱线图。
我们可以看到模型性能随着树的深度增加而普遍提升，直到达到五层深度，之后性能开始趋于平稳。
LightGBM 集成树深度与分类准确率的箱线图
探索学习率
学习率控制每个模型对集成预测的贡献量。
较小的学习率可能需要集成中更多的决策树。
学习率可以通过“learning_rate”参数控制，默认为 0.1。
下面的示例探讨了学习率，并比较了 0.0001 和 1.0 之间值的影响。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
# 探索LightGBM学习率对性能的影响 from numpy import mean from numpy import std from sklearn.datasets import make_classification from sklearn.model_selection import cross_val_score from sklearn.model_selection import RepeatedStratifiedKFold from lightgbm import LGBMClassifier from matplotlib import pyplot # 获取数据集 定义 获取_数据集(): X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7) 返回 X, y # 获取要评估的模型列表 定义 获取_模型(): models = dict() rates = [0.0001, 0.001, 0.01, 0.1, 1.0] for r in rates: key = '%.4f' % r models[key] = LGBMClassifier(learning_rate=r) 返回 模型 # 使用交叉验证评估给定模型 def evaluate_model(model): cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) 返回 分数 # 定义数据集 X, y = get_dataset() # 获取要评估的模型 模型 = 获取_模型() # 评估模型并存储结果 results, names = list(), list() for name, model in models.items(): scores = evaluate_model(model) results.append(scores) names.append(name) print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores))) # 绘制模型性能以供比较 pyplot.boxplot(results, labels=names, showmeans=True) pyplot.show() |
运行示例首先报告每个配置的学习率的平均准确率。
注意：考虑到算法或评估过程的随机性以及数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
在这种情况下，我们可以看到更大的学习率在此数据集上获得了更好的性能。我们期望对于较小的学习率，向集成中添加更多树会进一步提高性能。
|
1 2 3 4 5 |
>0.0001 0.800 (0.038) >0.0010 0.811 (0.035) >0.0100 0.859 (0.035) >0.1000 0.925 (0.031) >1.0000 0.928 (0.025) |
为每个配置的学习率的准确度分数分布创建了一个箱线图。
我们可以看到模型性能随着学习率的增加而普遍提高，一直到 1.0 的较大值。
LightGBM 学习率与分类准确率的箱线图
探索提升类型
LightGBM 的一个特点是它支持多种不同的提升算法，被称为提升类型。
可以通过“boosting_type”参数指定boosting类型，该参数接受一个字符串来指定类型。选项包括
- “gbdt”：梯度提升决策树（GDBT）。
- “dart”：Dropouts meet Multiple Additive Regression Trees (DART)。
- “goss”：基于梯度的单边采样（GOSS）。
默认是GDBT，这是经典的梯度提升算法。
DART在2015年发表的题为“DART: Dropouts meet Multiple Additive Regression Trees”的论文中有所描述，顾名思义，它将深度学习中的dropout概念添加到了梯度提升决策树的前身——Multiple Additive Regression Trees (MART)算法中。
这种算法有许多名称，包括Gradient TreeBoost、boosted trees和Multiple Additive Regression Trees (MART)。我们用后者来指代这种算法。
— DART: Dropouts meet Multiple Additive Regression Trees, 2015。
GOSS是随LightGBM论文和库一起引入的。该方法旨在仅使用产生大误差梯度的实例来更新模型，并丢弃其余实例。
…我们排除了很大一部分梯度较小的数据实例，只用其余的来估计信息增益。
— LightGBM：一种高效的梯度提升决策树，2017。
下面的示例比较了LightGBM在合成分类数据集上使用三种主要提升技术的效果。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
# 探索lightgbm提升类型对性能的影响 from numpy import arange from numpy import mean from numpy import std from sklearn.datasets import make_classification from sklearn.model_selection import cross_val_score from sklearn.model_selection import RepeatedStratifiedKFold from lightgbm import LGBMClassifier from matplotlib import pyplot # 获取数据集 定义 获取_数据集(): X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7) 返回 X, y # 获取要评估的模型列表 定义 获取_模型(): models = dict() types = ['gbdt', 'dart', 'goss'] for t in types: models[t] = LGBMClassifier(boosting_type=t) 返回 模型 # 使用交叉验证评估给定模型 def evaluate_model(model): cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1) scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1) 返回 分数 # 定义数据集 X, y = get_dataset() # 获取要评估的模型 模型 = 获取_模型() # 评估模型并存储结果 results, names = list(), list() for name, model in models.items(): scores = evaluate_model(model) results.append(scores) names.append(name) print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores))) # 绘制模型性能以供比较 pyplot.boxplot(results, labels=names, showmeans=True) pyplot.show() |
运行示例首先报告每种配置的提升类型的平均准确率。
注意：考虑到算法或评估过程的随机性以及数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
在这种情况下，我们可以看到默认的提升方法优于评估的其他两种技术。
|
1 2 3 |
>gbdt 0.925 (0.031) >dart 0.912 (0.028) >goss 0.918 (0.027) |
为每种配置的提升方法的准确率分数分布创建了箱线图，可以直接比较这些技术。
LightGBM提升类型与分类准确率的箱线图
进一步阅读
如果您想深入了解，本节提供了更多关于该主题的资源。
相关教程
论文
API
- LightGBM项目，GitHub
- LightGBM文档.
- LightGBM 安装指南
- LightGBM 参数调整.
- lightgbm.LGBMClassifier API.
- lightgbm.LGBMRegressor API.
文章
总结
在本教程中，您学习了如何开发用于分类和回归的Light Gradient Boosted Machine集成模型。
具体来说，你学到了：
- Light Gradient Boosted Machine (LightGBM) 是随机梯度提升集成算法的高效开源实现。
- 如何使用 scikit-learn API 开发用于分类和回归的 LightGBM 集成模型。
- 如何探索 LightGBM 模型超参数对模型性能的影响。
你有什么问题吗？
在下面的评论中提出你的问题，我会尽力回答。
掌握现代集成学习！
在几分钟内改进您的预测
...只需几行python代码
在我的新电子书中探索如何实现
使用 Python 实现集成学习算法
它提供**自学教程**，并附有关于以下内容的**完整工作代码**：
堆叠、投票、提升、装袋、混合、超级学习器等等……
嗨，Jason，
谢谢这篇精彩的论文。
关于max_depth与num_leaves的一个问题
MaxDepth = [2,3,4,5,6,7,8,9,10]
NumLeaves = [2 ** i for i in MaxDepth]
NumLeaves = [4, 8, 16, 32, 64, 128, 256, 512, 1024]
num_leaves值过高可能会导致过拟合对吗？
同时收到警告
No further splits with positive gain, best gain: -inf
请问如何为小型和大型数据集优化设置num_leaves？
谢谢
或许可以将其保留为默认值31。
嗨，Jason，一如既往的精彩文章！
有没有关于catboost的文章？
似乎找不到。
谢谢。
我这里有一个关于catboost的简短例子。
https://machinelearning.org.cn/gradient-boosting-with-scikit-learn-xgboost-lightgbm-and-catboost/
嗨，亲爱的……我想知道我们使用上述算法获得了准确率……但我们如何使用混淆矩阵获得值……
我不知道该怎么做。
如果我使用了模型名称，例如上述情况中的lightgbm等，则为Model.fit(X)。
之后
Ypred = model.predict (X)
Confusionmatrix (y, Pred)
它给我提供了全部结果，例如值中没有错误。
所以请告诉我如何使用交叉验证技术而不是测试训练分割来构建混淆矩阵，并且只使用X（自变量）和y（结果变量）等。
这将帮助您计算混淆矩阵。
https://machinelearning.org.cn/confusion-matrix-machine-learning/
嗨，Jason，
感谢您的帖子。我好奇的是，有没有关于“Light Gradient”术语的资源，特别是来自微软的？
抱歉，我不明白。您说的“Light Gradient term”是什么意思？
嗨，Jason，很棒的文档。
你能告诉我max_depth为正或为负的区别吗？
默认值为-1
我相信-1意味着没有限制——当数据用完时停止。
先生，我想知道Light GBM和带有LightGBM的直方图梯度提升之间的区别，因为我在许多地方读到Light GBM使用基于直方图的方法。所以我很困惑，如果Light GBM在其训练过程中自动使用分箱的概念，那么基于直方图的Light GBM有什么区别？
Light GBM是实现GBM算法的一种方式。
您可以在上述教程的“Light Gradient Boosted Machine算法”部分阅读具体的区别。
你好，
感谢这篇文章，但我有些不明白，您已经解释了LGBM的不同提升类型，并说“默认是GDBT，这是经典的梯度提升算法。”
那么，使用LGBM的“gbdt”与使用sklearn的“Gradient Boosting”类是相同的吗？或者比较它们的结果是否有趣？（因为我想同时实现LGBM和GBM，但我不太确定如果我只保留LGBM的默认参数这是否是个好主意）
此外，LGBM的强大之处与GOSS和EFB有关，但由于这些在默认参数中未使用，那么我们是不是并没有真正使用LGBM呢？
它可能是相同的“算法”，尽管是另一种可能更高效和/或更有效的实现。
先生您好，感谢您对Light GBM各方面的精彩解释。在解释GOSS时，您提到排除了梯度较小的样本，因为它们导致的信息增益较小。您能否用一些例子向我解释梯度小和梯度大的含义。用更通俗易懂的语言会更容易理解。
梯度是斜率的另一个名称。您用它来衡量如果您改变输入，目标函数可以改变多少。大梯度意味着目标函数变化很大，或者您的输入可以极大地驱动函数。相反，小梯度的输入可能对函数没有任何影响。因此，如果每件事都有代价，我们希望专注于那些具有大梯度的，因为它最具成本效益。
嗨，Jason，非常感谢这篇文章。你能解释一下LightGBM和predict_proba之间的关系吗？我的理解（如果错了请纠正我）是，LightGBM只会返回原始分数，而不是像GBM或XGBoost那样返回概率。如果真是这样，如何将这些分数转换为概率呢？