如何开发 LightGBM集成树算法模型_集成树lgbm模型

Light Gradient Boosted Machine，简称LightGBM，是一个开源库，提供了梯度提升算法的高效实现。

LightGBM 通过添加一种自动特征选择以及专注于具有更大梯度的提升示例来扩展梯度提升算法。这可以显着加快训练速度并提高预测性能。

因此，当使用表格数据进行回归和分类预测建模任务时，LightGBM 已成为机器学习竞赛的事实上的算法。因此，它应为梯度提升方法以及极限梯度提升 (XGBoost) 的普及和广泛采用负有一部分责任。

在本教程中，您将了解如何开发用于分类和回归的 Light Gradient Boosted Machine 集成。

完成本教程后，您将了解：

• Light Gradient Boosted Machine (LightGBM) 是随机梯度提升集成算法的高效开源实现。

• 如何使用 scikit-learn API 开发用于分类和回归的 LightGBM 集成。

• 如何探索 LightGBM 模型超参数对模型性能的影响。

使用我的新书Ensemble Learning Algorithms With Python开始您的项目，包括_分步教程_和所有示例的_Python 源代码_文件。

让我们开始吧。

教程概述

本教程分为三个部分；他们是：

1. Light梯度提升机算法

2. LightGBM Scikit-Learn API

3. 用于分类的 LightGBM 集成

4. 用于回归的 LightGBM 集成

5. LightGBM 超参数

6. 探索树的数量

7. 探索树深度

8. 探索学习率

9. 探索提升类型

Light梯度提升机算法

梯度提升是指一类可用于分类或回归预测建模问题的集成机器学习算法。

集成是从决策树模型构建的。一次将一棵树添加到集成中并进行拟合以纠正先前模型产生的预测错误。这是一种称为 boosting 的集成机器学习模型。

使用任何任意可微损失函数和梯度下降优化算法来拟合模型。这使该技术得名“梯度提升”，因为随着模型的拟合，损失梯度被最小化，很像神经网络。

有关梯度提升的更多信息，请参阅教程：

• 机器学习梯度提升算法的简单介绍

Light Gradient Boosted Machine，简称 LightGBM，是梯度提升的开源实现，旨在提高效率，并且可能比其他实现更有效。

因此，LightGBM指的是开源项目、软件库和机器学习算法。这样，它与Extreme Gradient Boosting 或 XGBoost 技术非常相似。

LightGBM 由郭林柯等人描述。在 2017 年题为“ LightGBM：一种高效的梯度提升决策树”的论文中。该实现引入了两个关键思想：GOSS 和 EFB。

基于梯度的单边采样，简称 GOSS，是对梯度提升方法的一种修改，将注意力集中在那些导致更大梯度的训练示例上，从而加快学习速度并降低方法的计算复杂度。

使用 GOSS，我们排除了很大一部分具有小梯度的数据实例，仅使用其余部分来估计信息增益。我们证明，由于具有较大梯度的数据实例在信息增益的计算中起着更重要的作用，因此 GOSS 可以以更小的数据量获得相当准确的信息增益估计。

— LightGBM：一种高效的梯度提升决策树，2017 年。

Exclusive Feature Bundling，简称 EFB，是一种捆绑稀疏（大部分为零）互斥特征的方法，例如已进行单热编码的分类变量输入。因此，它是一种自动特征选择。

……我们捆绑了互斥的特征（即，它们很少同时取非零值），以减少特征的数量。

— LightGBM：一种高效的梯度提升决策树，2017 年。

这两个变化一起可以将算法的训练时间加快多达 20 倍。因此，LightGBM 可以被视为添加 GOSS 和 EFB 的梯度提升决策树 (GBDT)。

我们将新的 GBDT 实现称为 GOSS 和 EFB LightGBM。我们在多个公共数据集上的实验表明，LightGBM 将传统 GBDT 的训练过程加快了 20 多倍，同时达到了几乎相同的精度

— LightGBM：一种高效的梯度提升决策树，2017 年。

---

LightGBM Scikit-Learn API

LightGBM 可以作为独立库安装，并且可以使用 scikit-learn API 开发 LightGBM 模型。

第一步是安装 LightGBM 库（如果尚未安装）。这可以在大多数平台上使用 pip python 包管理器来实现；例如：

然后，您可以确认 LightGBM 库已正确安装并且可以通过运行以下脚本来使用。

运行该脚本将打印您已安装的 LightGBM 库的版本。

您的版本应该相同或更高。如果没有，您必须升级 LightGBM 库的版本。

如果您需要针对您的开发环境的特定说明，请参阅教程：

• LightGBM 安装指南

LightGBM 库有自己的自定义 API，尽管我们将通过 scikit-learn 包装类使用该方法：LGBMRegressor和LGBMClassifier。这将使我们能够使用 scikit-learn 机器学习库中的全套工具来准备数据和评估模型。

两个模型以相同的方式运行，并采用相同的参数来影响决策树的创建和添加到集成的方式。

随机性用于构建模型。这意味着每次在相同的数据上运行算法时，都会产生一个略有不同的模型。

当使用具有随机学习算法的机器学习算法时，通过在多次运行或重复交叉验证中平均它们的性能来评估它们是一种很好的做法。在拟合最终模型时，可能需要增加树的数量直到模型的方差在重复评估中减少，或者拟合多个最终模型并平均它们的预测。

让我们来看看如何为分类和回归开发 LightGBM 集成。

用于分类的 LightGBM 集成

在本节中，我们将研究使用 LightGBM 解决分类问题。

首先，我们可以使用make_classification() 函数创建一个包含 1,000 个示例和 20 个输入特征的合成二元分类问题。

下面列出了完整的示例。

运行示例会创建数据集并总结输入和输出组件的形状。

接下来，我们可以在这个数据集上评估 LightGBM 算法。

我们将使用重复分层 k 折交叉验证来评估模型，其中包含 3 次重复和 10 次重复。我们将报告模型在所有重复和折叠中的准确性的平均值和标准偏差。

运行示例报告模型的均值和标准偏差准确度。

注意：您的结果可能会因算法或评估程序的随机性或数值精度的差异而有所不同。考虑多次运行该示例并比较平均结果。

在这种情况下，我们可以看到具有默认超参数的 LightGBM 集成在此测试数据集上实现了约 92.5% 的分类准确率。

我们还可以使用 LightGBM 模型作为最终模型并进行分类预测。

首先，LightGBM 集成适合所有可用数据，然后可以调用_predict()_函数对新数据进行预测。

下面的示例在我们的二进制分类数据集上演示了这一点。

运行示例在整个数据集上拟合 LightGBM 集成模型，然后用于对新数据行进行预测，就像我们在应用程序中使用模型时一样。

现在我们熟悉了使用 LightGBM 进行分类，让我们看一下用于回归的 API。

用于回归的 LightGBM 集成

在本节中，我们将研究使用 LightGBM 解决回归问题。

首先，我们可以使用make_regression() 函数创建一个包含 1,000 个示例和 20 个输入特征的综合回归问题。

下面列出了完整的示例。

运行示例会创建数据集并总结输入和输出组件的形状。

接下来，我们可以在这个数据集上评估 LightGBM 算法。

正如我们在上一节所做的那样，我们将使用重复的 k 折交叉验证来评估模型，重复 3 次和 10 次。我们将报告模型在所有重复和折叠中的平均绝对误差 (MAE)。scikit-learn 库使 MAE 为负值，使其最大化而不是最小化。这意味着负 MAE 越大越好，完美模型的 MAE 为 0。

下面列出了完整的示例。

运行示例报告模型的均值和标准偏差准确度。

注意：您的结果可能会因算法或评估程序的随机性或数值精度的差异而有所不同。考虑多次运行该示例并比较平均结果。

在这种情况下，我们可以看到具有默认超参数的 LightGBM 集成实现了大约 60 的 MAE。

我们还可以使用 LightGBM 模型作为最终模型并对回归进行预测。

首先，LightGBM 集成适合所有可用数据，然后可以调用_predict()_函数对新数据进行预测。

下面的示例在我们的回归数据集上演示了这一点。

运行示例在整个数据集上拟合 LightGBM 集成模型，然后用于对新数据行进行预测，就像我们在应用程序中使用模型时一样。

现在我们已经熟悉使用 scikit-learn API 来评估和使用 LightGBM 集成，让我们看一下配置模型。

LightGBM 超参数

在本节中，我们将仔细研究一些您应该考虑调整 LightGBM 集成的超参数及其对模型性能的影响。

我们可以查看 LightGBM 的许多超参数，尽管在这种情况下，我们将查看树的数量和树的深度、学习率和增强类型。

有关调整 LightGBM 超参数的一般建议，请参阅文档：

• LightGBM 参数调整。

探索树的数量

LightGBM 集成算法的一个重要超参数是集成中使用的决策树的数量。

回想一下，决策树按顺序添加到模型中，以纠正和改进先前树所做的预测。因此，更多的树通常更好。

树的数量可以通过“ n_estimators ”参数设置，默认为 100。

下面的示例探讨了值在 10 到 5,000 之间的树数量的影响。

# explore lightgbm number of trees effect on performance

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

# get the dataset

def get_dataset():

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

return X, y

# get a list of models to evaluate

def get_models():

models = dict()

trees = [10, 50, 100, 500, 1000, 5000]

for n in trees:

models[str(n)] = LGBMClassifier(n_estimators=n)

return models

# evaluate a give model using cross-validation

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)

return scores

# define dataset

X, y = get_dataset()

# get the models to evaluate

models = get_models()

# evaluate the models and store results

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)))

# plot model performance for comparison

pyplot.boxplot(results, labels=names, showmeans=True)

pyplot.show()
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

运行示例首先报告每个配置数量的决策树的平均准确度。

注意：您的结果可能会因算法或评估程序的随机性或数值精度的差异而有所不同。考虑多次运行该示例并比较平均结果。

在这种情况下，我们可以看到该数据集的性能有所提高，直到大约 500 棵树，之后性能似乎趋于平稳。

为每个配置数量的树的准确度分数分布创建了一个箱线图。

我们可以看到增加模型性能和集成大小的总体趋势。

LightGBM 集成大小与分类精度的箱线图

探索树深度

改变添加到集成中的每棵树的深度是梯度提升的另一个重要超参数。

树深度控制每棵树对训练数据集的专业化程度：它可能是通用的还是过度拟合的。树最好不要太浅和一般（如AdaBoost），也不要太深和专业（如引导程序聚合）。

梯度提升通常在深度适中的树上表现良好，在技巧和通用性之间找到平衡。

树深度是通过“ max_depth ”参数控制的，默认为一个未指定的值，因为控制树的复杂程度的默认机制是使用叶节点的数量。

控制树的复杂度主要有两种方法：树的最大深度和树中终端节点（叶子）的最大数量。在这种情况下，我们正在探索叶子的数量，因此我们需要通过设置“ num_leaves ”参数来增加叶子的数量以支持更深的树。

下面的示例探讨了 1 到 10 之间的树深度以及对模型性能的影响。

# explore lightgbm tree depth effect on performance

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

# get the dataset

def get_dataset():

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

return X, y

# get a list of models to evaluate

def get_models():

models = dict()

for i in range(1,11):

models[str(i)] = LGBMClassifier(max_depth=i, num_leaves=2**i)

return models

# evaluate a give model using cross-validation

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)

return scores

# define dataset

X, y = get_dataset()

# get the models to evaluate

models = get_models()

# evaluate the models and store results

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)))

# plot model performance for comparison

pyplot.boxplot(results, labels=names, showmeans=True)

pyplot.show()
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

运行示例首先报告每个配置的树深度的平均准确度。

注意：您的结果可能会因算法或评估程序的随机性或数值精度的差异而有所不同。考虑多次运行该示例并比较平均结果。

在这种情况下，我们可以看到性能随着树的深度而提高，可能一直到 10 个级别。探索更深的树可能会很有趣。

为每个配置的树深度的准确度分数分布创建了一个盒须图。

我们可以看到模型性能随着树深度增加到五个级别的深度而增加的总体趋势，之后性能开始变得相当平坦。

LightGBM 集成树深度与分类精度的箱线图

探索学习率

学习率控制每个模型对集成预测的贡献量。

较小的速率可能需要集成中更多的决策树。

学习率可以通过“ learning_rate ”参数控制，默认为0.1。

下面的示例探讨了学习率并比较了 0.0001 和 1.0 之间的值的影响。

# explore lightgbm learning rate effect on performance

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

# get the dataset

def get_dataset():

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

return X, y

# get a list of models to evaluate

def get_models():

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)

return models

# evaluate a give model using cross-validation

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)

return scores

# define dataset

X, y = get_dataset()

# get the models to evaluate

models = get_models()

# evaluate the models and store results

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)))

# plot model performance for comparison

pyplot.boxplot(results, labels=names, showmeans=True)

pyplot.show()
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

运行示例首先报告每个配置的学习率的平均准确度。

注意：您的结果可能会因算法或评估程序的随机性或数值精度的差异而有所不同。考虑多次运行该示例并比较平均结果。

在这种情况下，我们可以看到更大的学习率会在这个数据集上产生更好的性能。我们希望为较小的学习率在集成中添加更多的树将进一步提高性能。

为每个配置的学习率的准确度分数分布创建了一个盒须图。

我们可以看到模型性能随着学习率的增加一直增加到 1.0 的大值的总体趋势。

LightGBM 学习率与分类准确率的箱线图

探索提升类型

LightGBM 的一个特性是它支持许多不同的提升算法，称为提升类型。

boosting 类型可以通过“ boosting_type ”参数指定，并使用字符串来指定类型。选项包括：

• ’ gbdt '：梯度提升决策树（GDBT）。

• ’ dart '：Dropouts 满足多重加法回归树 (DART)。

• ’ goss '：基于梯度的单边采样 (GOSS)。

默认是GDBT，这是经典的梯度提升算法。

DART 在 2015 年题为“ DART：Dropouts meet Multiple Additive Regression Trees ”的论文中有所描述，顾名思义，将深度学习的dropout概念添加到了多重加法回归树 (MART) 算法中，这是梯度提升决策的前身树木。

这个算法有很多名字，包括梯度树增强、提升树和多重加性回归树 (MART)。我们用后者来指代这个算法。

— DART：Dropouts meet Multiple Additive Regression Trees，2015。

GOSS 是随 LightGBM 论文和图书馆一起引入的。该方法试图仅使用导致大误差梯度的实例来更新模型并丢弃其余实例。

……我们排除了很大一部分具有小梯度的数据实例，仅使用其余部分来估计信息增益。

— LightGBM：一种高效的梯度提升决策树，2017 年。

下面的示例将合成分类数据集上的 LightGBM 与三个关键的提升技术进行了比较。

# explore lightgbm boosting type effect on performance

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

# get the dataset

def get_dataset():

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

return X, y

# get a list of models to evaluate

def get_models():

models = dict()

types = ['gbdt', 'dart', 'goss']

for t in types:

models[t] = LGBMClassifier(boosting_type=t)

return models

# evaluate a give model using cross-validation

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)

return scores

# define dataset

X, y = get_dataset()

# get the models to evaluate

models = get_models()

# evaluate the models and store results

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)))

# plot model performance for comparison

pyplot.boxplot(results, labels=names, showmeans=True)

pyplot.show()
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

运行示例首先报告每个配置的提升类型的平均准确度。

注意：您的结果可能会因算法或评估程序的随机性或数值精度的差异而有所不同。考虑多次运行该示例并比较平均结果。

在这种情况下，我们可以看到默认的 boosting 方法比其他两种被评估的技术表现得更好。

为每个配置的提升方法的准确度分数分布创建了一个箱线图，允许直接比较这些技术。

LightGBM Boosting 类型与分类精度的箱线图

概括

在本教程中，您了解了如何开发用于分类和回归的 Light Gradient Boosted Machine 集成。

具体来说，你学到了：

• Light Gradient Boosted Machine (LightGBM) 是随机梯度提升集成算法的高效开源实现。

• 如何使用 scikit-learn API 开发用于分类和回归的 LightGBM 集成。

• 如何探索 LightGBM 模型超参数对模型性能的影响。

lightgbm知识就为大家介绍到这里了，欢迎各位同学报名<python风控建模实战lendingclub>,学习更多集成树算法相关知识 ：https://edu.csdn.net/course/detail/30742