Machine Learning Mastery 集成学习教程（三）
机器学习的纠错输出码（ECOC）
最后更新于 2021 年 4 月 27 日
机器学习算法，像逻辑回归和支持向量机，是为两类(二进制)分类问题设计的。
因此，这些算法要么必须针对多类(两个以上)分类问题进行修改，要么根本不使用。纠错输出码方法是一种允许将多类分类问题重新定义为多个二进制分类问题的技术，允许直接使用本地二进制分类模型。
与通过将多类分类问题划分为固定数量的二进制分类问题来提供类似解决方案的一对一和一对一方法不同，纠错输出码技术允许将每个类编码为任意数量的二进制分类问题。当使用超定表示时，它允许额外的模型充当“纠错”预测，从而可以产生更好的预测表现。
在本教程中，您将发现如何使用纠错输出代码进行分类。
完成本教程后，您将知道:
- 纠错输出码是一种在多类分类预测任务中使用二分类模型的技术。
- 如何拟合、评估和使用纠错输出码分类模型进行预测。
- 如何调整和评估纠错输出码使用的每类超参数位数的不同值。
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
机器学习的纠错输出代码(ECOC) 图片由 Fred Hsu 提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 纠错输出码
- 评估和使用 ECOC 分类器
- 调整每个类别的位数
纠错输出码
分类任务是标签对给定输入变量具有预测性的任务。
二分类任务是那些目标包含两个值的分类问题，而多类分类问题是那些具有两个以上目标类标签的分类问题。
已经开发了许多用于二进制分类的机器学习模型，尽管它们可能需要修改来处理多类分类问题。例如，逻辑回归和支持向量机是专门为二分类设计的。
一些机器学习算法，如 SVM，最初被设计成只解决二进制分类任务。
—第 133 页，使用集成方法的模式分类，2010。
另一种方法是将多类分类问题重构为多个二进制分类问题，而不是限制算法的选择或使算法适应多类问题。可以用来实现这一点的两种常见方法包括一对一(OvR)和一对一(OvO)技术。
- OvR :将多类问题拆分为每类一个二元问题。
- OvO :将多类问题拆分为每对类一个二元问题。
一旦分解为子任务，就可以在每个任务上拟合二分类模型，并将响应最大的模型作为预测。
OvR 和 OvO 都可以被认为是一种集成学习模型，假设多个单独的模型适合于一个预测建模任务，并且一起用于进行预测。在这两种情况下，对“集成成员”的预测都是简单的胜者全取法。
……将多类任务转换为二进制分类任务的集合，然后将其结果合并。
—第 134 页，使用集成方法的模式分类，2010。
有关一对一和一对一模式的更多信息，请参见教程:
一种相关的方法是准备一个二进制编码(例如一个位串)来表示问题中的每个类。字符串中的每一位都可以通过单独的二进制分类问题来预测。对于给定的多类分类问题，可以任意选择长度编码。
明确地说，每个模型接收完整的输入模式，并且只预测输出字符串中的一个位置。在训练过程中，可以训练每个模型为二进制分类任务产生正确的 0 或 1 输出。然后，通过使用每个模型对输入进行预测来创建二进制字符串，然后将二进制字符串与每个类的已知编码进行比较，可以对新示例进行预测。然后选择与预测距离最小的类编码作为输出。
长度为 l 的码字归属于每个类别。通常，码字的大小具有比所需更多的比特，以便唯一地表示每个类别。
—第 138 页，使用集成方法的模式分类，2010。
这是一种有趣的方法，与一次编码相比，它允许类表示比所需的更复杂(可能是过度确定的)，并在问题的表示和建模中引入冗余。这是有意为之的，因为表示中的额外比特像纠错码一样起作用来修正、纠正或改进预测。
……想法是冗余的“纠错”位允许一些不准确性，并且可以提高表现。
—第 606 页，统计学习的要素，2016。
这给这项技术起了个名字:纠错输出码，简称 ECOC。
纠错输出码(ECOC)是一种基于二进制分类器组合处理多类问题的简单而有效的方法。
—第 90 页，集合方法，2012。
可以注意确保每个编码的类都有非常不同的二进制字符串编码。已经探索了一套不同的编码方案以及构建编码的特定方法，以确保它们在编码空间中相距足够远。有趣的是，随机编码可能也同样有效。
…分析了 ECOC 方法，并表明随机码分配和最佳构造的纠错码一样有效
—第 606 页，统计学习的要素，2016。
关于将预测字符串映射到编码类的各种不同编码方案和方法的详细回顾，我推荐使用集成方法的模式分类一书的第六章纠错输出码。
评估和使用 ECOC 分类器
Sklearn 库通过输出编码分类器类提供了 ECOC 的实现。
该类将用于拟合每个二进制分类器的模型作为参数，并且可以使用任何机器学习模型。在这种情况下，我们将使用逻辑回归模型，用于二分类。
该类还提供“ code_size ”参数，该参数将类的编码大小指定为类数量的倍数，例如每个类标签的编码位数。
例如，如果我们想要长度为 6 位的位串编码，并且我们有三个类，那么我们可以将编码大小指定为 2:
- 编码长度=代码大小*数量类
- encoding_length = 2 * 3
- 编码长度= 6
下面的例子演示了如何定义一个每类 2 位的输出编码分类器的例子，并为编码中的每一位使用一个物流分类器模型。
...
# define the binary classification model
model = LogisticRegression()
# define the ecoc model
ecoc = OutputCodeClassifier(model, code_size=2, random_state=1)
虽然有许多复杂的方法来构造每个类的编码， OutputCodeClassifier 类为每个类选择一个随机的位串编码，至少在编写时是这样。
我们可以在一个综合的多类分类问题上探索输出编码分类器的使用。
我们可以使用 make_classification()函数定义一个包含 1000 个示例、20 个输入特征和三个类的多类分类问题。
下面的示例演示了如何创建数据集并汇总数据集中的行数、列数和类数。
# multi-class classification dataset
from collections import Counter
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1, n_classes=3)
# summarize the dataset
print(X.shape, y.shape)
# summarize the number of classes
print(Counter(y))
运行该示例将创建数据集并报告行数和列数，从而确认数据集已按预期创建。
然后报告每个类别中的示例数量，显示三个已配置类别中每个类别的案例数量几乎相等。
(1000, 20) (1000,)
Counter({2: 335, 1: 333, 0: 332})
接下来，我们可以在数据集上评估纠错输出代码模型。
我们将使用上面定义的每类 2 位的逻辑回归。然后将使用重复的分层 k-fold 交叉验证对模型进行评估，重复 3 次，重复 10 次。我们将使用所有重复和折叠的分类准确率的平均值和标准差来总结模型的表现。
...
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model and collect the scores
n_scores = cross_val_score(ecoc, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# summarize the performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
将这些联系在一起，完整的示例如下所示。
# evaluate error-correcting output codes for multi-class classification
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 sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OutputCodeClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1, n_classes=3)
# define the binary classification model
model = LogisticRegression()
# define the ecoc model
ecoc = OutputCodeClassifier(model, code_size=2, random_state=1)
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model and collect the scores
n_scores = cross_val_score(ecoc, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# summarize the performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例定义了模型，并使用定义的测试过程在我们的合成多类类别数据集上对其进行评估。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到该模型实现了大约 76.6%的平均分类准确率。
Accuracy: 0.766 (0.037)
我们可以选择用这个作为我们的最终模型。
这要求我们将模型拟合到所有可用的数据上，并使用它对新数据进行预测。
下面的示例提供了一个完整的示例，说明如何拟合并使用纠错输出模型作为最终模型。
# use error-correcting output codes model as a final model and make a prediction
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OutputCodeClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1, n_classes=3)
# define the binary classification model
model = LogisticRegression()
# define the ecoc model
ecoc = OutputCodeClassifier(model, code_size=2, random_state=1)
# fit the model on the whole dataset
ecoc.fit(X, y)
# make a single prediction
row = [[0.04339387, 2.75542632, -3.79522705, -0.71310994, -3.08888853, -1.2963487, -1.92065166, -3.15609907, 1.37532356, 3.61293237, 1.00353523, -3.77126962, 2.26638828, -10.22368666, -0.35137382, 1.84443763, 3.7040748, 2.50964286, 2.18839505, -2.31211692]]
yhat = ecoc.predict(row)
print('Predicted Class: %d' % yhat[0])
运行该示例使 ECOC 模型适用于整个数据集，并使用该模型预测单行数据的类标签。
在这种情况下，我们可以看到模型预测了类标签 0。
Predicted Class: 0
现在，我们已经熟悉了如何安装和使用 ECOC 模型，让我们仔细看看如何配置它。
调整每个类别的位数
ECOC 模型的关键超参数是类标签的编码。
这包括以下属性:
- 表示的选择(位、实数等))
- 每个类标签的编码(随机等。)
- 表示的长度(位数等)。)
- 预测如何映射到类(距离等)。)
OutputCodeClassifierSklearn 实现目前没有提供对这些元素的大量控制。
它控制的元素是用于编码每个类标签的位数。
在本节中，我们可以在每个类标签的不同位数上执行手动网格搜索，并比较结果。这提供了一个模板，您可以在自己的项目中修改和使用。
首先，我们可以定义一个函数来创建和返回数据集。
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1, n_classes=3)
return X, y
然后，我们可以定义一个函数，该函数将创建一组要评估的模型。
每个模型都将是输出编码分类器的一个例子，为每个二进制分类问题使用一个逻辑分类器。我们将配置每个型号的代码大小不同，数值范围从 1 到 20。
# get a list of models to evaluate
def get_models():
models = dict()
for i in range(1,21):
# create model
model = LogisticRegression()
# create error correcting output code classifier
models[str(i)] = OutputCodeClassifier(model, code_size=i, random_state=1)
return models
我们可以使用相关的 k-fold 交叉验证来评估每个模型，就像我们在上一节中所做的那样，以给出一个分类准确性分数的样本。
# 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
我们可以报告每种配置得分的平均值和标准偏差，并将分布绘制为并排的方框图和触须图，以便直观地比较结果。
...
# 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()
将所有这些联系在一起，下面列出了将 ECOC 分类与每个类的位数网格进行比较的完整示例。
# compare the number of bits per class for error-correcting output code classification
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 sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OutputCodeClassifier
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=1, n_classes=3)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
for i in range(1,21):
# create model
model = LogisticRegression()
# create error correcting output code classifier
models[str(i)] = OutputCodeClassifier(model, code_size=i, random_state=1)
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()
运行该示例首先评估每个模型配置，并报告准确度分数的平均值和标准偏差。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到，每个类可能有 5 或 6 个比特导致最佳表现，报告的平均准确度分数分别约为 78.2%和 78.0%。我们还看到每个类 9、13、17 和 20 位的良好结果，每个类 17 位可能给出大约 78.5%的最佳结果。
>1 0.545 (0.032)
>2 0.766 (0.037)
>3 0.776 (0.036)
>4 0.769 (0.035)
>5 0.782 (0.037)
>6 0.780 (0.037)
>7 0.776 (0.039)
>8 0.775 (0.036)
>9 0.782 (0.038)
>10 0.779 (0.036)
>11 0.770 (0.033)
>12 0.777 (0.037)
>13 0.781 (0.037)
>14 0.779 (0.039)
>15 0.771 (0.033)
>16 0.769 (0.035)
>17 0.785 (0.034)
>18 0.776 (0.038)
>19 0.776 (0.034)
>20 0.780 (0.038)
创建一个图形，显示每个模型配置的准确度分数的方框图和触须图。
我们可以看到，除了值 1 之外，每个类的位数在分布和平均准确度分数方面提供了相似的结果，聚类在 77%左右。这表明该方法在各种配置中相当稳定。
ECOC 每类比特的盒须图与分类准确率分布
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
相关教程
报纸
- 通过纠错输出码解决多类学习问题，1995。
书
- 集成方法，2012。
- 使用集成方法的模式分类，2010。
- 统计学习的要素，2016。
蜜蜂
摘要
在本教程中，您发现了如何使用纠错输出代码进行分类。
具体来说，您了解到:
- 纠错输出码是一种在多类分类预测任务中使用二分类模型的技术。
- 如何拟合、评估和使用纠错输出码分类模型进行预测。
- 如何调整和评估纠错输出码使用的每类超参数位数的不同值。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
机器学习提升集成的本质
Boosting 是一类强大而流行的集成学习技术。
从历史上看，增强算法的实现具有挑战性，直到 AdaBoost 演示了如何实现增强，该技术才得以有效使用。AdaBoost 和现代梯度提升通过顺序添加模型来校正模型的残余预测误差。因此，众所周知，增强方法是有效的，但构建模型可能会很慢，尤其是对于大型数据集。
最近，为提高计算效率而设计的扩展使得这些方法足够快，可以被更广泛地采用。开源实现，比如 XGBoost 和 LightGBM，意味着增强算法已经成为机器学习竞赛中对表格数据进行分类和回归的首选方法，并且通常表现最好。
在本教程中，您将发现增强机器学习集成的本质。
完成本教程后，您将知道:
- 用于机器学习的提升集成方法递增地添加在训练数据集的加权版本上训练的弱学习器。
- 所有增强算法的基本思想和每个增强算法中使用的关键方法。
- 如何在新的预测建模项目中探索提升背后的基本思想。
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
为机器学习提升集成的本质 阿明·科瓦尔斯基摄，版权所有。
教程概述
本教程分为四个部分；它们是:
- 提升集成
- 提升集成的本质
- 提升集成算法家族
- adaboost 在一起
- 经典梯度提升集成
- 现代梯度提升集成
- 定制提升集成
提升集成
Boosting 是一种强大的集成学习技术。
因此，增强是流行的，可能是写作时最广泛使用的集成技术。
提升是过去二十年中引入的最强有力的学习理念之一。
—第 337 页，统计学习的要素，2016。
作为一种集成技术，它可以比兄弟方法读起来更复杂，比如自举聚合(装袋)和堆叠泛化(堆叠)。实际上，实现可能非常复杂，但是提升集成背后的想法非常简单。
提振可以通过与装袋的对比来理解。
在 bagging 中，通过对同一训练数据集制作多个不同的样本，并在每个样本上拟合一个决策树，来创建一个集成。给定训练数据集的每个样本是不同的，每个决策树是不同的，从而产生稍微不同的预测和预测误差。对所有创建的决策树的预测被组合，导致比拟合单个树更低的误差。
提升的运作方式类似。多个树适合不同版本的训练数据集，并且使用简单的分类投票或回归平均来组合来自树的预测，以产生比适合单个决策树更好的预测。
…boosting【…】使用简单多数投票结合了一组弱分类器…
—第 13 页，集成机器学习，2012。
有一些重要的区别；它们是:
- 训练集中的实例根据难度分配权重。
- 学习算法必须注意实例权重。
- 集成成员按顺序添加。
第一个区别是使用相同的训练数据集来训练每个决策树。不执行训练数据集的采样。相反，训练数据集中的每个示例(每行数据)都根据集合发现该示例预测的难易程度来分配权重。
这个算法背后的主要思想是把更多的焦点放在更难分类的模式上。焦点的数量由分配给训练集中每个模式的权重来量化。
—第 28-29 页，使用集成方法的模式分类，2010。
这意味着使用集合容易预测的行权重较小，而难以正确预测的行权重较大。
增强的工作方式类似，只是树是按顺序生长的:每棵树都是利用以前生长的树的信息生长的。升压不涉及自举采样；相反，每棵树都适合原始数据集的修改版本。
—第 322 页，R中应用的统计学习介绍，2014。
装袋的第二个区别是基础学习算法，例如决策树，必须注意训练数据集的权重。反过来，这意味着 boosting 被特别设计成使用决策树作为基础学习器，或者在构建模型时支持行加权的其他算法。
模型的构建必须更多地关注与其分配权重成比例的训练样本。这意味着集成成员是以一种有偏见的方式构建的，以便在权重很大的例子上做出(或努力做出)正确的预测。
最后，缓慢地构建增强集成。集成成员按顺序添加，一个接一个，依此类推，直到集成拥有所需数量的成员。
重要的是，在添加每个集成成员之后，基于整个集成的能力更新训练数据集的权重。这确保了随后添加的每个成员努力纠正整个模型在训练数据集上产生的错误。
然而，在增强过程中，每个后续分类器的训练数据集越来越关注由先前生成的分类器错误分类的实例。
—第 13 页，集成机器学习，2012。
每个模型对最终预测的贡献是每个模型表现的加权和，例如加权平均或加权投票。
这种增加集成成员来纠正训练数据集中的错误听起来像是最终会过度填充训练数据集。在实践中，提升集成可以过拟合训练数据集，但通常，效果是微妙的，过拟合不是主要问题。
与装袋和随机森林不同，如果(树木数量)太大，提升会过拟合，尽管这种过拟合往往发生得很慢。
—第 323 页，R中应用的统计学习介绍，2014。
这是 boosting 集成方法的高级总结，非常类似于 AdaBoost 算法，但是我们可以概括该方法并提取基本元素。
提升集成的本质
提升的本质听起来可能是关于修正预测。
这就是所有现代提升算法的实现方式，这是一个有趣而重要的想法。然而，校正预测误差可能被认为是实现增强的实现细节(一个大而重要的细节)，而不是提升集成方法的本质。
提升的本质是多个弱学习器组合成一个强学习器。
分类器的提升和集成策略是学习许多弱分类器并以某种方式组合它们，而不是试图学习单个强分类器。
—第 35 页，集成机器学习，2012。
弱学习器是一种技能非常一般的模型，通常意味着其表现略高于用于二进制分类或预测回归平均值的随机分类器。传统上，这意味着一个决策树桩，它是一个考虑一个变量的一个值并进行预测的决策树。
弱学习器(WL)是一种学习算法，它能够产生错误概率严格(但仅略微)小于随机猜测概率的分类器
—第 35 页，集成机器学习，2012。
弱学习器可以与在预测建模问题上表现良好的强学习器形成对比。一般来说，我们寻求一个强有力的学习器来解决分类或回归问题。
……一个强有力的学习器(SL)能够(给定足够的训练数据)以任意小的错误概率产生分类器。
—第 35 页，集成机器学习，2012。
尽管我们寻求一个强有力的学习器来解决一个给定的预测建模问题，但是训练他们是有挑战性的。而学习能力弱的人训练起来很快也很容易。
Boosting 认识到了这一区别，并建议从多个弱学习器中明确构建一个强学习器。
Boosting 是一类机器学习方法，基于简单分类器的组合(由弱学习器获得)可以比单独的任何简单分类器表现更好的思想。
—第 35 页，集成机器学习，2012。
已经探索了许多促进发展的方法，但只有一种是真正成功的。这是上一节描述的方法，其中弱学习器被顺序地添加到集合中，以专门解决或校正回归树的残差或分类的类标签预测误差。结果是学习能力很强。
让我们仔细看看集成方法，它可能被认为是提升家族的一部分。
提升集成算法家族
有大量的提升集成学习算法，尽管它们的工作方式基本相同。
也就是说，它们包括顺序添加简单的基本学习器模型，这些模型在训练数据集的(重新)加权版本上进行训练。
术语增强指的是能够将弱学习器转化为强学习器的一系列算法。
—第 23 页，集合方法，2012。
我们可以考虑三大类提升方法；它们是:AdaBoost、经典梯度提升和现代梯度提升。
这种划分有些随意，因为有些技术可能跨越所有组或实现，可以配置成实现每个组的一个示例，甚至基于 bagging 的方法。
adaboost 在一起
最初，朴素增强方法探索在训练数据集的单独样本上训练弱分类器并组合预测。
与装袋相比，这些方法并不成功。
自适应升压，简称 AdaBoost，是升压的第一个成功实现。
研究人员努力了一段时间来寻找提升理论的有效实现，直到弗伦德和沙皮雷合作产生了 AdaBoost 算法。
—第 204 页，应用预测建模，2013 年。
这不仅仅是提升原则的成功实现；这是一种有效的分类算法。
增强，尤其是以 AdaBoost 算法的形式，被证明是一个强大的预测工具，通常优于任何单个模型。它的成功引起了建模社区的注意，它的使用变得广泛…
—第 204 页，应用预测建模，2013 年。
虽然 AdaBoost 最初是为二进制分类而开发的，但后来被扩展为多类分类、回归以及无数其他扩展和专用版本。
他们首先维护相同的训练数据集，并引入训练示例的权重和训练模型的顺序添加，以校正集合的预测误差。
经典梯度提升集成
AdaBoost 成功后，很多注意力都放在了 boosting 方法上。
梯度提升是 AdaBoost 技术组的推广，它允许使用任意损失函数来实现每个后续基础学习的训练。
与其为每个不同的损失函数推导新版本的升压，不如推导一个通用版本，称为梯度升压。
—第 560 页，机器学习:概率视角，2012 年。
梯度提升中的“梯度”指的是来自所选损失函数的预测误差，通过添加基础学习器使其最小化。
梯度提升的基本原理如下:给定损失函数(例如，回归的平方误差)和弱学习器(例如，回归树)，算法寻求找到最小化损失函数的加性模型。
—第 204 页，应用预测建模，2013 年。
在最初将 AdaBoost 重新定义为梯度提升和使用交替损失函数之后，有了许多进一步的创新，例如多元自适应回归树(MART)、树增强和梯度提升机(GBM)。
如果我们将梯度提升算法与(浅)回归树相结合，在将回归树拟合到残差(负梯度)后，我们得到了一个称为 MART【…】的模型，我们重新估计了树叶处的参数，以最小化损失…
—第 562 页，机器学习:概率视角，2012 年。
该技术被扩展到包括正则化，试图进一步减缓每个决策树的行和列的学习和采样，以便基于装袋的思想(称为随机梯度提升)为集成成员增加一些独立性。
现代梯度提升集成
该方法的梯度提升和方差被证明是非常有效的，但通常训练速度很慢，尤其是对于大型训练数据集。
这主要是由于集成成员的顺序训练，不能并行化。这是不幸的，因为并行训练集成成员和它提供的计算速度是使用集成的一个经常被描述的理想特性。
因此，在提高该方法的计算效率方面付出了很多努力。
这导致了梯度提升的高度优化的开源实现，引入了创新技术，既加速了模型的训练，又提供了进一步改进的预测表现。
值得注意的例子包括极限梯度提升(XGBoost)和光梯度提升机(LightGBM)项目。这两种方法都非常有效，以至于在处理表格数据时，它们成为了机器学习竞赛中实际使用的方法。
定制提升集成
我们简要回顾了提升算法的典型类型。
像 XGBoost 和 LightGBM 这样的算法的现代实现提供了足够的配置超参数来实现许多不同类型的增强算法。
虽然与像 bagging 这样更简单的实现方法相比，boosting 最初很难实现，但基本的想法可能有助于在您自己的预测建模项目中探索或扩展集成方法。
从弱学习器中培养一个强学习器的基本思想可以通过许多不同的方式来实现。例如，用决策树桩或标准机器学习算法的其他类似弱学习器配置装袋可以被认为是这种方法的实现。
- 给弱势学习器装袋。
它还提供了与其他集合类型的对比，例如堆叠，试图将多个强学习器组合成一个稍微强的学习器。即便如此，通过堆叠不同的弱学习器，也许在一个项目上可以获得交替的成功。
- 堆叠弱学习器。
有效提升的途径包括加权训练示例的具体实现细节、能够实现权重的模型，以及适合某种损失最小化方法的模型的顺序添加。
然而，这些原则可以更普遍地用于集合模型。
例如，也许成员可以被顺序地添加到装袋或堆叠集合中，并且只有当它们导致技能的有用提升、预测误差的下降或模型所做的预测分布的改变时才被保留。
- 顺序装袋或堆叠。
从某种意义上说，叠加提供了一种实现修正其他模型预测的想法。元模型(1 级学习器)试图有效地组合基础模型(0 级学习器)的预测。从某种意义上说，它正试图修正这些模型的预测。
可以添加堆叠模型的级别来满足特定要求，例如最小化一些或所有预测误差。
- 模型的深度堆叠。
这些也许是几个显而易见的例子，说明如何探索提升方法的本质，希望能激发更多的想法。我鼓励你集思广益，如何让这些方法适应你自己的特定项目。
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
相关教程
书
- 使用集成方法的模式分类，2010。
- 集成方法，2012。
- 集成机器学习，2012。
- 统计学习的要素，2016。
- R中应用的统计学习导论，2014。
- 机器学习:概率视角，2012。
- 应用预测建模，2013。
文章
摘要
在本教程中，您发现了增强机器学习集成的本质。
具体来说，您了解到:
- 用于机器学习的提升集成方法递增地添加在训练数据集的加权版本上训练的弱学习器。
- 所有增强算法的基本思想和每个增强算法中使用的关键方法。
- 如何在新的预测建模项目中探索提升背后的基本思想。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
自举聚合集成的本质
最后更新于 2021 年 10 月 22 日
Bootstrap 聚合，或 bagging，是一种流行的集成方法，它在训练数据集的不同 Bootstrap 样本上拟合决策树。
实现起来很简单，对各种各样的问题都很有效，重要的是，该技术的适度扩展产生了集成方法，这些集成方法是一些最强大的技术之一，如随机森林，在各种各样的预测建模问题上表现良好。
因此，我们可以将 bagging 方法推广到集成学习的框架中，并且比较和对比属于方法的“【bagging 家族】 ”的一套常见集成方法。我们还可以使用这个框架来探索进一步的扩展，以及如何根据项目数据集或选择的预测模型进一步定制该方法。
在本教程中，您将发现机器学习集成的引导聚合方法的本质。
完成本教程后，您将知道:
- 基于自举样本和决策树的机器学习 bagging 集成方法。
- 如何从装袋方法中提取基本元素，以及像随机森林这样的流行扩展如何与装袋直接相关。
- 如何通过为方法的基本要素选择新的程序来设计装袋的新扩展？
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
自举聚合集成精华 图片由 GPA 图片档案提供，保留部分权利。
教程概述
本教程分为四个部分；它们是:
- 自举聚合
- 装袋集成的本质
- 装袋集成家族
- 随机子空间集成
- 随机森林集合
- 额外树木组合
- 定制装袋集成
自举聚合
Bootstrap Aggregation，简称装袋，是一种集成机器学习算法。
该技术包括为每个集成成员创建训练数据集的自举样本，并在每个样本上训练决策树模型，然后使用类似预测平均值的统计量直接组合预测。
Breiman 的 bagging(Bootstrap Aggregation 的缩写)算法是最早、最简单、但有效的基于集成的算法之一。
—第 12 页，集成机器学习，2012。
训练数据集的样本是使用自举方法创建的，该方法包括随机选择样本并进行替换。
替换意味着相同的示例被隐喻性地返回到候选行池，并且可以在训练数据集的任何单个样本中被再次或多次选择。对于一些引导样本，训练数据集中的一些示例也可能根本没有被选择。
一些原始示例出现不止一次，而一些原始示例不在示例中。
—第 48 页，集合方法，2012。
bootstrap 方法的预期效果是使数据集的每个样本都非常不同，或者对于创建集合来说非常不同。
然后对每个数据样本进行决策树拟合。考虑到训练数据集中的差异，每棵树都会有所不同。通常，决策树被配置为可能具有增加的深度或者不使用修剪。这可以使每棵树对训练数据集更加专门化，进而进一步增加树之间的差异。
树的差异是可取的，因为它们将增加集成的“多样性”，这意味着产生在它们的预测或预测误差中具有较低相关性的集成成员。人们普遍认为，由技巧性和多样性(以不同方式技巧或犯不同错误)的集成成员组成的集成表现更好。
通过在其上训练每个分类器的自举副本内的变化，以及通过使用相对较弱的分类器来确保集合中的多样性，所述相对较弱的分类器的决策边界相对于训练数据中相对较小的扰动而可测量地变化。
—第 12 页，集成机器学习，2012。
装袋的一个好处是，它通常不会过度填充训练数据集，并且集成成员的数量可以继续增加，直到保持数据集的表现停止提高。
这是 bagging 集成方法的高级总结，但是我们可以概括该方法并提取基本元素。
装袋集成的本质
装袋的本质是利用独立的模型。
这样的话，可能是最接近大众智慧比喻的实现，尤其是考虑到随着独立贡献者的加入，表现不断提升。
不幸的是，我们不能开发真正独立的模型，因为我们只有一个训练数据集。相反，bagging 方法使用随机性逼近独立模型。具体来说，通过在用于训练每个模型的数据集的采样中使用随机性，迫使模型之间具有某种半独立性。
虽然实际上不可能获得真正独立的基础学习器，因为它们是从相同的训练数据集生成的，但是通过在学习过程中引入随机性，可以获得依赖性较小的基础学习器，并且集成可以期望良好的泛化能力。
—第 48 页，集合方法，2012。
装袋程序的结构可分为三个基本要素；它们是:
- 不同的训练数据集:为每个集成模型创建不同的训练数据集样本。
- 高方差模型:在训练数据集的每个样本上训练相同的高方差模型。
- 平均预测:使用统计数据组合预测。
我们可以将规范装袋方法映射到这些元素上，如下所示:
- 不同的训练数据集 : Bootstrap 样本。
- 高方差模型:决策树。
- 平均预测:回归平均值，分类模式。
这提供了一个框架，我们可以在其中为模型的每个基本元素考虑替代方法。
例如，我们可以将算法更改为另一种高方差技术，这种技术的学习行为有些不稳定，可能就像 k 超参数值适中的 k 近邻。
通常，装袋产生的组合模型优于使用原始数据的单个实例构建的模型。[……]这是真的，尤其是对于不稳定的诱导剂，因为装袋可以消除它们的不稳定性。在这种情况下，如果学习集中的扰动可以在构建的分类器中产生显著变化，则诱导子被认为是不稳定的。
—第 28 页，使用集成方法的模式分类，2010。
我们也可以将采样方法从引导改为另一种采样技术，或者更一般地说，完全不同的方法。事实上，这是文献中描述的 bagging 的许多扩展的基础。具体来说，就是尝试让集成成员更加独立，同时保持技巧。
我们知道独立基础学习器的组合将导致错误的急剧减少，因此，我们希望让基础学习器尽可能独立。
—第 48 页，集合方法，2012。
让我们仔细看看可能被认为是 bagging 系列的一部分的其他集成方法。
装袋集成家族
许多集成机器学习技术可以被认为是 bagging 的后代。
因此，我们可以将它们映射到我们的基本装袋框架中。这是一个有用的练习，因为它既强调了方法之间的差异，也强调了每种技术的独特性。也许更重要的是，它还可以激发您在自己的预测建模项目中想要探索的其他变体的想法。
让我们仔细看看与装袋相关的三种更流行的集成方法。
随机子空间集成
随机子空间方法，或随机子空间集成，包括为每个集成成员选择训练数据集中特征(列)的随机子集。
每个训练数据集都有所有行，因为它只是随机采样的列。
- 不同的训练数据集:随机抽取样本列。
随机森林集合
随机森林方法可能是最成功和最广泛使用的集成方法之一，因为它易于实现，并且在广泛的预测建模问题上通常具有优异的表现。
该方法通常包括选择训练数据集的自举样本和小的随机列子集，以便在选择每个集成成员中的每个分割点时考虑。
以这种方式，它就像是 bagging 和随机子空间方法的结合，尽管随机子空间是唯一用于决策树构造的方式。
- 不同的训练数据集 : Bootstrap 样本。
- 高方差模型:随机列子集上有分割点的决策树。
额外树木组合
额外树集合使用整个训练数据集，尽管它配置决策树算法来随机选择分割点。
- 不同的训练数据集:整个数据集。
- 高方差模型:随机分割点的决策树。
定制装袋集成
我们简要回顾了规范随机子空间、随机森林和额外树方法，尽管这些方法没有理由不能共享更多的实现细节。
事实上，像 bagging 和 random forest 这样的算法的现代实现证明了足够的配置来组合这些特性。
我们可以设计自己的扩展，映射到 bagging 框架中，而不是穷尽所有文献。这可能会启发您探索一种不太常见的方法，或者针对您的数据集或模型选择设计自己的装袋方法。
可能有几十个或几百个 bagging 扩展，对每个集成成员的训练数据集的准备方式或如何从训练数据集构建模型的细节稍作修改。
这些变化是围绕基本装袋方法的三个主要元素构建的，通常通过探索足够熟练的集成成员之间的平衡来寻求更好的表现，同时保持预测或预测误差之间足够的多样性。
例如，我们可以将训练数据集的采样改为无替换的随机采样，而不是自举采样。这就是所谓的粘贴
- 不同的训练数据集:行的随机子样本。
我们可以更进一步，为每个决策树选择一个随机的行子样本(比如粘贴)和一个随机的列子样本(随机子样本)。这就是所谓的“随机补丁”
- 不同的训练数据集:行和列的随机子样本。
我们也可以考虑自己对这个想法的简单扩展。
例如，通常使用特征选择技术来选择输入变量的子集，以降低预测问题的复杂性(更少的列)并获得更好的表现(更少的噪声)。我们可以想象一个 bagging 集成，其中每个模型都适合于由不同的特征选择或特征重要性方法选择的训练数据集的不同“视图”。
- 不同训练数据集:不同特征选择方法选择的列。
作为建模管道的一部分，用许多不同的数据转换测试模型也是很常见的。之所以这样做，是因为我们无法事先知道训练数据集的哪种表示将最好地将数据集的未知底层结构暴露给学习算法。我们可以想象一个 bagging 集成，其中每个模型都适合训练数据集的不同变换。
- 不同的训练数据集:原始训练数据集的数据变换。
这些也许是几个显而易见的例子，说明如何探索装袋方法的本质，希望能启发更多的想法。我鼓励你集思广益，如何让这些方法适应你自己的特定项目。
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
书
- 使用集成方法的模式分类，2010。
- 集成方法，2012。
- 集成机器学习，2012。
文章
摘要
在本教程中，您发现了机器学习集成的引导聚合方法的本质。
具体来说，您了解到:
- 基于自举样本和决策树的机器学习 bagging 集成方法。
- 如何从装袋方法中提取基本元素，以及像随机森林这样的流行扩展如何与装袋直接相关。
- 如何通过为方法的基本要素选择新的程序来设计装袋的新扩展？
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
机器学习堆叠集成的本质
最后更新于 2021 年 4 月 27 日
堆叠一般化，或堆叠，可能是一个不太受欢迎的机器学习集成，因为它描述的是一个框架，而不是一个特定的模型。
也许它在主流机器学习中不太受欢迎的原因是，在不遭受数据泄漏的情况下，正确训练堆叠模型可能会很棘手。这意味着这项技术主要被高技能专家在高风险环境中使用，如机器学习比赛，并被赋予新的名称，如混合集成。
然而，现代机器学习框架使得堆叠例程能够实现和评估分类和回归预测建模问题。因此，我们可以通过堆叠框架的镜头来回顾与堆叠相关的集成学习方法。这种更广泛的堆叠技术家族也有助于了解未来在探索我们自己的预测建模项目时如何定制该技术的配置。
在本教程中，您将发现机器学习集成的堆叠泛化方法的本质。
完成本教程后，您将知道:
- 机器学习的堆叠集成方法使用元模型来组合来自贡献成员的预测。
- 如何从堆叠方法中提取基本元素，以及像混合和超级集成这样的流行扩展是如何关联的。
- 如何通过为方法的基本元素选择新的过程来设计新的堆栈扩展。
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
机器学习堆叠集成精华 图片由托马斯提供，保留部分权利。
教程概述
本教程分为四个部分；它们是:
- 堆叠一般化
- 堆叠集合的本质
- 堆叠集成族
- 投票团
- 加权平均值
- 混合集成
- 超级学习器乐团
- 定制堆叠集成
堆叠一般化
堆叠泛化，简称堆叠，是一种集成机器学习算法。
堆叠包括使用机器学习模型来学习如何最好地组合来自贡献的集成成员的预测。
在投票中，集成成员通常是模型类型的不同集合，例如决策树、朴素贝叶斯和支持向量机。预测是通过平均预测进行的，例如选择投票最多的班级(统计模式)或总概率最大的班级。
……(未加权)投票只有在学习方案表现相当好的情况下才有意义。
—第 497 页，数据挖掘:实用机器学习工具与技术，2016。
投票的一个扩展是在预测中加权每个集合成员的贡献，提供加权和预测。这允许将更多的权重放在平均表现更好的模型上，而将较少的权重放在那些表现不佳但仍有一些预测技能的模型上。
必须了解分配给每个贡献成员的权重，例如每个模型在训练数据集或保持数据集上的表现。
堆叠概括了这种方法，并允许使用任何机器学习模型来学习如何最好地组合来自贡献成员的预测。组合预测的模型称为元模型，而集合成员称为基本模型。
投票的问题在于，不清楚该信任哪个分类器。堆叠试图学习哪些分类器是可靠的，使用另一种学习算法——元载体——来发现如何最好地组合基础学习器的输出。
—第 497 页，数据挖掘:实用机器学习工具与技术，2016。
在介绍该技术的论文中，基础模型被称为 0 级学习器，元模型被称为 1 级模型。
自然，模型的堆叠可以继续到任何期望的水平。
堆叠是一个通用的过程，在这个过程中，一个学习器被训练来组合各个学习器。在这里，个体学习器被称为一级学习器，而组合者被称为二级学习器或元学习器。
—第 83 页，集合方法，2012。
重要的是，元模型的训练方式不同于基础模型的训练方式。
元模型的输入是基础模型做出的预测，而不是数据集的原始输入。目标是相同的预期目标值。用于训练元模型的基础模型所做的预测是用于没有用于训练基础模型的例子，这意味着它们是不符合样本的。
例如，数据集可以分为训练数据集、验证数据集和测试数据集。然后，每个基础模型可以适合训练集，并在验证数据集上进行预测。来自验证集的预测然后被用于训练元模型。
这意味着当基础模型进行样本外预测时，元模型被训练为最佳组合基础模型的能力，例如在训练期间没有看到的例子。
…我们保留一些实例来形成 1 级学习器的训练数据，并从剩余数据中构建 0 级分类器。一旦建立了 0 级分类器，它们就被用来对保持集中的实例进行分类，形成 1 级训练数据。
—第 498 页，数据挖掘:实用机器学习工具与技术，2016。
一旦训练了元模型，就可以在组合的训练和验证数据集上重新训练基础模型。然后，可以在测试集上对整个系统进行评估，方法是首先通过基础模型传递示例以收集基础级别的预测，然后通过元模型传递这些预测以获得最终预测。当对新数据进行预测时，该系统可以以同样的方式使用。
这种训练、评估和使用堆叠模型的方法可以进一步推广到 k 倍交叉验证中。
通常，基础模型是使用不同的算法准备的，这意味着集合是模型类型的异构集合，为所做的预测提供了期望的多样性水平。然而，情况并非必须如此，可以使用相同模型的不同配置，或者在不同的数据集上训练相同的模型。
一级学习器通常是通过应用不同的学习算法产生的，因此，堆叠的集成通常是异构的
—第 83 页，集合方法，2012。
在分类问题上，当基础模型被配置为预测概率而不是简单的类标签时，堆叠集成通常表现得更好，因为预测中增加的不确定性为元模型在学习如何最好地组合预测时提供了更多的上下文。
…大多数学习方案能够输出每个类别标签的概率，而不是进行单一的分类预测。通过使用概率形成 1 级数据，可以利用这一点来提高堆叠的表现。
—第 498 页，数据挖掘:实用机器学习工具与技术，2016。
元模型通常是简单的线性模型，如回归问题的线性回归或分类的逻辑回归模型。同样，情况也不一定如此，任何机器学习模型都可以用作元学习器。
……因为大部分工作已经由 0 级学习器完成，1 级分类器基本上只是一个仲裁器，为此选择一个相当简单的算法是有意义的。[……]简单的线性模型或叶子上有线性模型的树通常效果很好。
—第 499 页，数据挖掘:实用机器学习工具与技术，2016。
这是堆叠集成方法的高级总结，但是我们可以概括该方法并提取基本元素。
堆叠集合的本质
堆叠的本质是学习如何组合贡献的集成成员。
这样，我们可能会认为堆叠是假设简单的群体智慧(例如平均)是好的，但不是最优的，如果我们能够识别并给予群体中的专家更多的权重，就可以获得更好的结果。
专家和次要专家是根据他们在新情况下的技能来确定的，例如样本外数据。这是与简单平均和投票的一个重要区别，尽管它引入了一定程度的复杂性，使得该技术难以正确实现并避免数据泄漏，进而导致不正确和乐观的表现。
然而，我们可以看到堆叠是一种非常通用的集成学习方法。
广义地说，我们可以把集成模型的加权平均看作是对投票集成的推广和改进，而叠加则是加权平均模型的进一步推广。
因此，堆叠程序的结构可以分为三个基本要素；它们是:
- 多样的集合成员:创建一组多样的模型，做出不同的预测。
- 成员考核:考核集成成员的表现。
- 与模型结合:使用模型结合成员的预测。
我们可以将规范堆叠映射到这些元素上，如下所示:
- 不同的集成成员:使用不同的算法来拟合每个贡献模型。
- 成员评估:评估模型在样本外预测上的表现。
- 结合模型:机器学习模型结合预测。
这提供了一个我们可以考虑相关集成算法的框架。
让我们仔细看看其他可能被认为是堆叠系列的一部分的集成方法。
堆叠集成族
许多集成机器学习技术可以被认为是堆叠的前身或后代。
因此，我们可以将它们映射到我们的基本堆叠框架上。这是一个有用的练习，因为它既强调了方法之间的差异，也强调了每种技术的独特性。也许更重要的是，它还可能激发出您想要在自己的预测建模项目中探索的其他变体的想法。
让我们仔细看看与堆叠相关的四种更常见的集成方法。
投票团
投票集成是最简单的集成学习技术之一。
投票集合通常包括使用不同的算法来准备每个集合成员，就像堆叠一样。不用学习如何组合预测，而是使用一个简单的统计数据。
在回归问题上，投票集合可以预测来自集合成员的预测的平均值或中值。对于分类问题，预测票数最多的标签，称为硬投票，或者预测获得最大和概率的标签，称为软投票。
与堆叠的重要区别在于，没有基于模型表现的模型称重。假设所有模型的平均技能水平相同。
- 成员考核:假设所有模特技术都一样。
- 结合模型:简单统计。
加权平均集成
加权平均可能被认为比整体投票高出一步。
像堆叠和投票集合一样，加权平均使用不同的模型类型集合作为贡献成员。
与投票不同，加权平均假设一些贡献成员比其他成员更好，并相应地对模型贡献进行加权。
最简单的加权平均集成基于每个模型在训练数据集上的表现对其进行加权。对这种天真方法的一个改进是根据每个成员在保留数据集上的表现来加权它，例如在 k 倍交叉验证期间的验证集或超倍预测。
下一步可能涉及使用优化算法调整每个模型的系数权重，以及保持数据集的表现。
加权平均模型的这些持续改进开始类似于原始叠加模型，其线性模型被训练来组合预测。
- 成员评估:成员在训练数据集上的表现。
- 结合模型:预测的加权平均值。
混合集成
混合显然是一种具有特定配置的堆叠概括模型。
堆叠的一个限制是没有普遍接受的配置。这使得该方法对初学者具有挑战性，因为基本上任何模型都可以用作基础模型和元模型，并且任何重采样方法都可以用于为元模型准备训练数据集。
混合是一个特定的叠加集合，它会开出两个处方。
第一种是使用保持验证数据集来准备用于训练元模型的样本外预测。第二种是使用线性模型作为元模型。
这项技术诞生于从事机器学习竞赛的从业者的需求，该竞赛涉及大量基础学习器模型的开发，这些模型可能来自不同的来源(或团队)，这反过来可能计算量太大，并且太具挑战性，难以使用数据集的 K 折交叉验证分区进行协调验证。
- 成员预测:验证数据集中的样本外预测。
- 结合模型:线性模型(如线性回归或逻辑回归)。
考虑到混合集成的流行，叠加有时会专门指使用 k 倍交叉验证来准备元模型的样本外预测。
超级学习器乐团
像混合一样，超级集成是堆叠集成的特定配置。
超级学习中的元模型是使用 k 倍交叉验证期间收集的基础学习器的超倍预测准备的。
因此，我们可以将超级学习器集合视为混合的兄弟，主要区别在于如何为元学习器准备样本外预测的选择。
- 多样的集成成员:使用不同的算法和相同算法的不同配置。
- 成员评估:k 倍交叉验证的出格预测。
定制堆叠集成
我们回顾了规范叠加作为一个结合来自不同模型类型集合的预测的框架。
堆叠是一种广泛的方法，这可能会使它很难开始使用。我们可以看到投票集成和加权平均集成是堆叠方法的简化，混合集成和超级学习器集成是堆叠的特定配置。
这篇综述强调了不同堆叠方法的重点在于元模型的复杂性，例如使用统计学、加权平均或真正的机器学习模型。重点还在于元模型的训练方式，例如从验证数据集中的样本预测或 k 倍交叉验证。
堆叠的另一个探索领域可能是集合成员的多样性，而不仅仅是使用不同的算法。
与使用决策树规定的提升和装袋相比，堆叠在模型类型中不是规定性的。这允许在自定义和探索方法在数据集上的使用时有很大的灵活性。
例如，我们可以想象在训练数据集的引导样本上拟合大量决策树，就像我们在 bagging 中所做的那样，然后测试一组不同的模型，以了解如何最好地组合来自这些树的预测。
- 不同的集成成员:在引导样本上训练的决策树。
或者，我们可以想象网格搜索单个机器学习模型的大量配置(这在机器学习项目中很常见)，并保持所有模型的匹配。然后，这些模型可以用作堆叠集合中的成员。
- 不同的集成成员:相同算法的交替配置。
我们可能还会看到“专家混合”技术适合堆叠方法。
专家混合(简称 MoE)是一种技术，它将问题明确地划分为子问题，并在每个子问题上训练一个模型，然后使用该模型来学习如何最好地权衡或组合专家的预测。
堆叠和专家混合之间的重要区别是 MoE 的明确分治方法，以及使用门控网络组合预测的更复杂方式。
然而，我们设想将一个输入特征空间划分为一个子空间网格，在每个子空间上训练一个模型，并使用一个元模型，该元模型从基本模型和原始输入样本中获取预测，并学习哪个基本模型对输入数据最有条件信任或最有权重。
- 多样集成成员:将输入特征空间划分为统一的子空间。
这可以进一步扩展到首先在每个子空间的众多模型类型中选择一个表现良好的模型类型，只保留每个子空间中表现最好的专家，然后学习如何最好地组合他们的预测。
最后，我们可能认为元模型是对基本模型的修正。我们可能会探索这个想法，并让多个元模型尝试纠正贡献成员的重叠或非重叠池以及堆叠在它们之上的额外模型层。这种更深层次的模型堆叠有时会在机器学习竞赛中使用，训练起来可能会变得复杂和具有挑战性，但在预测任务中可能会带来额外的好处，因为更好的模型技能远远超过了反思模型的能力。
我们可以看到，堆叠方法的通用性为实验和定制留下了很大的空间，来自增强和装袋的想法可以直接结合在一起。
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
相关教程
- 用 Python 堆叠集成机器学习
- 如何用 Keras 开发 Python 深度学习神经网络的堆叠集成
- 如何用 Python 从零开始实现堆叠泛化(堆叠)
- 如何用 Python 开发投票集成
- 如何在 Python 中开发超级学习器集成
书
- 使用集成方法的模式分类，2010。
- 集成方法，2012。
- 集成机器学习，2012。
- 数据挖掘:实用机器学习工具与技术，2016。
摘要
在本教程中，您发现了机器学习集成的堆叠泛化方法的本质。
具体来说，您了解到:
- 机器学习的堆叠集成方法使用元模型来组合来自贡献成员的预测。
- 如何从堆叠方法中提取基本元素，以及像混合和超级集成这样的流行扩展是如何关联的。
- 如何通过为方法的基本元素选择新的过程来设计新的堆栈扩展。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
如何使用 Python 开发额外树集合
最后更新于 2021 年 4 月 27 日
额外树是一种集成机器学习算法，它结合了许多决策树的预测。
它与广泛使用的随机森林算法有关。尽管它使用更简单的算法来构建用作集成成员的决策树，但它通常可以获得与随机森林算法一样好或更好的表现。
它也很容易使用，因为它只有很少的关键超参数和合理的试探法来配置这些超参数。
在本教程中，您将发现如何为分类和回归开发额外树集合。
完成本教程后，您将知道:
- 额外树集成是决策树的集成，与装袋和随机森林有关。
- 如何使用额外树集合进行分类和回归。
- 如何探索 Extra Trees 模型超参数对模型表现的影响。
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
如何用 Python 开发额外树组合 图片由尼古拉斯·雷蒙德提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 额外树算法
- 额外树木科学工具包-学习应用编程接口
- 额外的分类树
- 回归的额外树
- 额外树超参数
- 探索树的数量
- 探索功能数量
- 探索每次拆分的最小样本数
额外树算法
极随机化树，简称 Extra Trees，是一种集成机器学习算法。
具体来说，它是决策树的集合，并且与其他决策树算法的集合相关，例如自举聚合(bagging)和随机森林。
额外树算法通过从训练数据集中创建大量未运行的决策树来工作。在回归的情况下，通过对决策树的预测进行平均来进行预测，或者在分类的情况下，通过使用多数投票来进行预测。
- 回归:通过对决策树的预测进行平均而做出的预测。
- 分类:决策树多数投票做出的预测。
通过在分类问题中的多数投票和在回归问题中的算术平均，树的预测被聚集以产生最终预测。
——极随机化树，2006。
与根据训练数据集的引导样本开发每个决策树的装袋和随机森林不同，额外树算法适合整个训练数据集上的每个决策树。
像随机森林一样，额外树算法将在决策树的每个分割点随机采样特征。与使用贪婪算法选择最佳分割点的随机森林不同，额外树算法随机选择分割点。
额外树算法根据经典的自上而下的过程构建了一个未运行的决策树或回归树的集合。它与其他基于树的集成方法的两个主要区别是，它通过完全随机地选择切割点来分割节点，并且它使用整个学习样本(而不是自举副本)来生长树。
——极随机化树，2006。
因此，算法中有三个主要的超参数需要调整；它们是集成中决策树的数量、为每个分割点随机选择和考虑的输入特征的数量，以及在一个节点中创建新分割点所需的最小样本数量。
它有两个参数:K，每个节点随机选择的属性数量，nmin，分割一个节点的最小样本量。[……]我们用 M 表示这个集成的树的数量。
——极随机化树，2006。
分割点的随机选择使得集成中的决策树不太相关，尽管这增加了算法的方差。方差的增加可以通过增加集成中使用的树的数量来抵消。
参数 K、nmin 和 M 的作用不同:K 决定属性选择过程的强度，nmin 决定平均输出噪声的强度，M 决定集成模型聚合的方差降低的强度。
——极随机化树，2006。
额外树木科学工具包-学习应用编程接口
额外树集合可以从零开始实现，尽管这对初学者来说很有挑战性。
Sklearn Python 机器学习库为机器学习提供了一个 Extra Trees 的实现。
它可以在最新版本的库中找到。
首先，通过运行以下脚本来确认您使用的是现代版本的库:
# check Sklearn version
import sklearn
print(sklearn.__version__)
运行脚本将打印您的 Sklearn 版本。
您的版本应该相同或更高。
如果没有，您必须升级 Sklearn 库的版本。
0.22.1
这两个模型以相同的方式运行，并采用相同的参数来影响决策树的创建。
随机性用于模型的构建。这意味着算法每次在相同的数据上运行时，都会产生稍微不同的模型。
当使用具有随机学习算法的机器学习算法时，最好通过在多次运行或重复交叉验证中平均它们的表现来评估它们。当拟合最终模型时，可能需要增加树的数量，直到模型的方差在重复评估中减小，或者拟合多个最终模型并对它们的预测进行平均。
让我们看看如何为分类和回归开发一个额外树集合。
额外的分类树
在本节中，我们将研究如何使用额外树来解决分类问题。
首先，我们可以使用 make_classification()函数创建一个包含 1000 个示例和 20 个输入特征的合成二进制分类问题。
下面列出了完整的示例。
# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=4)
# summarize the dataset
print(X.shape, y.shape)
运行该示例将创建数据集并总结输入和输出组件的形状。
(1000, 20) (1000,)
接下来，我们可以在这个数据集上评估一个额外树算法。
我们将使用重复的分层 k 折叠交叉验证来评估模型，重复 3 次，折叠 10 次。我们将报告所有重复和折叠的模型准确率的平均值和标准偏差。
# evaluate extra trees algorithm for classification
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 sklearn.ensemble import ExtraTreesClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=4)
# define the model
model = ExtraTreesClassifier()
# evaluate the model
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, error_score='raise')
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到带有默认超参数的额外树集成在这个测试数据集上实现了大约 91%的分类准确率。
Accuracy: 0.910 (0.027)
我们也可以使用额外树模型作为最终模型，并对分类进行预测。
首先，额外树集合适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。
下面的示例在我们的二进制类别数据集上演示了这一点。
# make predictions using extra trees for classification
from sklearn.datasets import make_classification
from sklearn.ensemble import ExtraTreesClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=4)
# define the model
model = ExtraTreesClassifier()
# fit the model on the whole dataset
model.fit(X, y)
# make a single prediction
row = [[-3.52169364,4.00560592,2.94756812,-0.09755101,-0.98835896,1.81021933,-0.32657994,1.08451928,4.98150546,-2.53855736,3.43500614,1.64660497,-4.1557091,-1.55301045,-0.30690987,-1.47665577,6.818756,0.5132918,4.3598337,-4.31785495]]
yhat = model.predict(row)
print('Predicted Class: %d' % yhat[0])
运行该示例使 Extra Trees 集成模型适合整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。
Predicted Class: 0
现在我们已经熟悉了使用额外树进行分类，让我们看看回归的应用编程接口。
回归的额外树
在本节中，我们将研究如何使用额外树来解决回归问题。
首先，我们可以使用make _ revolution()函数创建一个包含 1000 个示例和 20 个输入特征的合成回归问题。
下面列出了完整的示例。
# test regression dataset
from sklearn.datasets import make_regression
# define dataset
X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=3)
# summarize the dataset
print(X.shape, y.shape)
运行该示例将创建数据集并总结输入和输出组件的形状。
(1000, 20) (1000,)
接下来，我们可以在这个数据集上评估一个额外树算法。
与上一节一样，我们将使用重复的 k 倍交叉验证来评估模型，重复 3 次，重复 10 次。我们将报告所有重复和折叠模型的平均绝对误差(MAE)。
Sklearn 库使 MAE 为负，因此它被最大化而不是最小化。这意味着负 MAE 越大越好，完美模型的 MAE 为 0。
下面列出了完整的示例。
# evaluate extra trees ensemble for regression
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 sklearn.ensemble import ExtraTreesRegressor
# define dataset
X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=3)
# define the model
model = ExtraTreesRegressor()
# evaluate the model
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')
# report performance
print('MAE: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到带有默认超参数的额外树集合达到了大约 70 的 MAE。
MAE: -69.561 (5.616)
我们也可以使用额外树模型作为最终模型，并对回归进行预测。
首先，额外树集合适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。
下面的例子在我们的回归数据集上演示了这一点。
# extra trees for making predictions for regression
from sklearn.datasets import make_regression
from sklearn.ensemble import ExtraTreesRegressor
# define dataset
X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=3)
# define the model
model = ExtraTreesRegressor()
# fit the model on the whole dataset
model.fit(X, y)
# make a single prediction
row = [[-0.56996683,0.80144889,2.77523539,1.32554027,-1.44494378,-0.80834175,-0.84142896,0.57710245,0.96235932,-0.66303907,-1.13994112,0.49887995,1.40752035,-0.2995842,-0.05708706,-2.08701456,1.17768469,0.13474234,0.09518152,-0.07603207]]
yhat = model.predict(row)
print('Prediction: %d' % yhat[0])
运行该示例使 Extra Trees 集成模型适合整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。
Prediction: 53
现在我们已经熟悉了使用 Sklearn API 来评估和使用 Extra Trees 集合，让我们来看看如何配置模型。
额外树超参数
在本节中，我们将仔细研究一些您应该考虑为额外树集合进行调整的超参数，以及它们对模型表现的影响。
探索树的数量
额外树算法的一个重要超参数是集成中使用的决策树的数量。
通常，树的数量会增加，直到模型表现稳定下来。直觉可能暗示更多的树会导致过拟合，尽管事实并非如此。考虑到学习算法的随机性，Bagging、Random Forest 和 Extra Trees 算法似乎在某种程度上不会过拟合训练数据集。
树的数量可以通过“n _ estimates”参数设置，默认为 100。
下面的示例探讨了值在 10 到 5，000 之间的树的数量的影响。
# explore extra trees 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 sklearn.ensemble import ExtraTreesClassifier
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=4)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
# define number of trees to consider
n_trees = [10, 50, 100, 500, 1000, 5000]
for n in n_trees:
models[str(n)] = ExtraTreesClassifier(n_estimators=n)
return models
# evaluate a given model using cross-validation
def evaluate_model(model, X, y):
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model and collect the results
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():
# evaluate the model
scores = evaluate_model(model, X, y)
# store the results
results.append(scores)
names.append(name)
# summarize the performance along the way
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.show()
运行该示例首先报告每个配置数量的决策树的平均准确性。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到大约 100 棵树后，表现会上升并保持不变。平均准确度分数在 100、500 和 1000 棵树之间波动，这可能是统计噪声。
>10 0.860 (0.029)
>50 0.904 (0.027)
>100 0.908 (0.026)
>500 0.910 (0.027)
>1000 0.910 (0.026)
>5000 0.912 (0.026)
为每个配置数量的树的准确度分数的分布创建一个方框和须图。
我们可以看到表现随着树的数量而增加的总体趋势，也许在 100 棵树后趋于平稳。
额外树集合大小与分类准确率的箱线图
探索功能数量
与随机森林一样，为每个分割点随机采样的要素数量可能是为额外树配置的最重要的要素。
像随机森林一样，额外树算法对使用的特定值不敏感，尽管它是一个需要调整的重要超参数。
它通过 max_features 参数设置，默认为输入特征数的平方根。在这种情况下，对于我们的测试数据集，这将是 sqrt(20)或大约四个特征。
以下示例探讨了在每个分割点随机选择的特征数量对模型准确率的影响。我们将尝试从 1 到 20 的值，并期望一个大约为 4 的小值根据启发式算法表现良好。
# explore extra trees number of features 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 sklearn.ensemble import ExtraTreesClassifier
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=4)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
# explore number of features from 1 to 20
for i in range(1, 21):
models[str(i)] = ExtraTreesClassifier(max_features=i)
return models
# evaluate a given model using cross-validation
def evaluate_model(model, X, y):
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model and collect the results
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():
# evaluate the model
scores = evaluate_model(model, X, y)
# store the results
results.append(scores)
names.append(name)
# summarize the performance along the way
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.show()
运行示例首先报告每个特征集大小的平均准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，结果表明介于 4 和 9 之间的值是合适的，这证实了在这个数据集上 4 是合理的默认值。
考虑到分类准确性的较大平均值和较小标准偏差，9 的值甚至可能更好，尽管分数的差异可能具有统计学意义，也可能不具有统计学意义。
>1 0.901 (0.028)
>2 0.909 (0.028)
>3 0.901 (0.026)
>4 0.909 (0.030)
>5 0.909 (0.028)
>6 0.910 (0.025)
>7 0.908 (0.030)
>8 0.907 (0.025)
>9 0.912 (0.024)
>10 0.904 (0.029)
>11 0.904 (0.025)
>12 0.908 (0.026)
>13 0.908 (0.026)
>14 0.906 (0.030)
>15 0.909 (0.024)
>16 0.908 (0.023)
>17 0.910 (0.021)
>18 0.909 (0.023)
>19 0.907 (0.025)
>20 0.903 (0.025)
为每个要素集大小的准确率分数分布创建了一个方框和触须图。
我们看到一种表现上升和峰值的趋势，数值在 4 到 9 之间，随着考虑更大的特征集大小，表现下降或保持不变。
额外树特征集大小与分类准确率的箱线图
探索每次拆分的最小样本数
最后一个有趣的超参数是在添加分割之前决策树节点中的样本数量。
只有当样本数等于或超过此值时，才会向决策树添加新的拆分。它通过“ min_samples_split ”参数设置，默认为两个样本(最低值)。样本数量越少，分裂越多，树越深，越特化。反过来，这可能意味着由集成中的树做出的预测和潜在的升力表现之间的相关性较低。
下面的示例探讨了拆分前额外树最小样本对模型表现的影响，测试值介于 2 和 14 之间。
# explore extra trees minimum number of samples for a split 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 sklearn.ensemble import ExtraTreesClassifier
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=4)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
# explore the number of samples per split from 2 to 14
for i in range(2, 15):
models[str(i)] = ExtraTreesClassifier(min_samples_split=i)
return models
# evaluate a given model using cross-validation
def evaluate_model(model, X, y):
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model and collect the results
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():
# evaluate the model
scores = evaluate_model(model, X, y)
# store the results
results.append(scores)
names.append(name)
# summarize the performance along the way
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.show()
运行示例首先报告每个配置的最大树深度的平均准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到较小的值会导致更好的表现，这证实了两个值的合理默认值。
>2 0.909 (0.025)
>3 0.907 (0.026)
>4 0.907 (0.026)
>5 0.902 (0.028)
>6 0.902 (0.027)
>7 0.904 (0.024)
>8 0.899 (0.026)
>9 0.896 (0.029)
>10 0.896 (0.027)
>11 0.897 (0.028)
>12 0.894 (0.026)
>13 0.890 (0.026)
>14 0.892 (0.027)
为每个配置的最大树深的准确率分数分布创建一个方框和须图。
在这种情况下，我们可以看到表现提高的趋势，分割的最小样本更少，如我们所料。
额外树木的箱线图每次分割的最小样本数与分类准确率
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
报纸
- 极随机化树，2006。
蜜蜂
摘要
在本教程中，您发现了如何开发用于分类和回归的额外树集合。
具体来说，您了解到:
- 额外树集成是决策树的集成，与装袋和随机森林有关。
- 如何使用额外树集合进行分类和回归。
- 如何探索 Extra Trees 模型超参数对模型表现的影响。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
Python 中的极限梯度提升（XGBoost）集成
最后更新于 2021 年 4 月 27 日
极限梯度提升(XGBoost)是一个开源库，它提供了梯度提升算法的高效和有效的实现。
尽管这种方法的其他开源实现在 XGBoost 之前就已经存在，但 XGBoost 的发布似乎释放了这种技术的力量，并使应用机器学习社区更普遍地注意到梯度提升。
在开发和最初发布后不久，XGBoost 就成为了一种流行的方法，并且经常是在机器学习竞赛中赢得分类和回归问题解决方案的关键组件。
在本教程中，您将发现如何为分类和回归开发极端梯度提升集成。
完成本教程后，您将知道:
- 极端梯度提升是随机梯度提升集成算法的一个有效的开源实现。
- 如何用 Sklearn API 开发用于分类和回归的 XGBoost 集成？
- 如何探索 XGBoost 模型超参数对模型表现的影响？
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
巨蟒极限梯度提升(XGBoost)集成 安德烈斯·涅托·波拉斯摄，版权所有。
教程概述
本教程分为三个部分；它们是:
- 极端梯度提升算法
- xboost Scikit-学习应用编程接口
- 用于分类的 XGBoost 集成
- 回归的 XGBoost 集成
- XGBoost 超参数
- 探索树的数量
- 探索树的深度
- 探索学习率
- 探索样本数量
- 探索功能数量
极端梯度提升算法
梯度提升是指一类可用于分类或回归预测建模问题的集成机器学习算法。
集成是由决策树模型构建的。树被一次一个地添加到集合中，并且适合于校正由先前模型产生的预测误差。这是一种称为 boosting 的集成机器学习模型。
使用任意可微损失函数和梯度下降优化算法拟合模型。这给这项技术起了一个名字，“梯度提升”，因为随着模型的拟合，损失梯度被最小化，很像一个神经网络。
有关梯度提升的更多信息，请参见教程:
极限梯度提升(简称 XGBoost)是梯度提升算法的一个高效开源实现。因此，XGBoost 是一个算法、一个开源项目和一个 Python 库。
它最初是由陈天棋开发的，并由陈和在他们 2016 年的论文《XGBoost:一个可扩展的树木提升系统》中进行了描述
它被设计为既有计算效率(例如，执行速度快)，又非常有效，可能比其他开源实现更有效。
然而，xgboost 这个名字实际上指的是工程目标，即提升树算法的计算资源极限。这也是很多人使用 xgboost 的原因。
—陈天琪在回答问题“R GBM(梯度提升机)和 xgboost(极限梯度提升)有什么区别？“在 Quora 上
使用 XGBoost 的两个主要原因是执行速度和模型表现。
一般来说，与其他梯度提升实现相比，XGBoost 速度更快。Szilard Pafka 执行了一些客观的基准测试，将 XGBoost 的表现与梯度提升和袋装决策树的其他实现进行了比较。2015 年 5 月，他在名为“基准测试随机森林实现”的博客文章中写下了自己的结果
他的结果显示，XGBoost 几乎总是比来自 R、Python Spark 和 H2O 的其他基准实现更快。
从他的实验中，他评论道:
我还尝试了 xgboost，这是一个流行的增强库，它也能构建随机森林。它速度快，内存效率高，准确率高
——基准测试随机森林实现，Szilard Pafka ，2015 年。
XGBoost 在分类和回归预测建模问题上主导结构化或表格数据集。证据是，它是 Kaggle 竞争数据科学平台上竞争赢家的 go-to 算法。
在 2015 年 Kaggle 博客上发布的 29 个挑战获胜解决方案 3 中，有 17 个解决方案使用了 XGBoost。[……]该系统的成功也在 KDDCup 2015 中得到了见证，在该赛事中，XGBoost 被前 10 名中的每一个获胜团队所使用。
——xboost:一个可扩展的树提升系统，2016。
既然我们已经熟悉了什么是 XGBoost 以及它为什么重要，那么让我们更仔细地看看如何在我们的预测建模项目中使用它。
xboost Scikit-学习应用编程接口
xboost 可以作为一个独立的库安装，并且可以使用 Sklearn API 开发一个 xboost 模型。
第一步是安装尚未安装的 XGBoost 库。这可以在大多数平台上使用 pip python 包管理器来实现；例如:
sudo pip install xgboost
然后，您可以通过运行以下脚本来确认 XGBoost 库安装正确，并且可以使用。
# check xgboost version
import xgboost
print(xgboost.__version__)
运行该脚本将打印您安装的 XGBoost 库的版本。
您的版本应该相同或更高。如果没有，您必须升级 XGBoost 库的版本。
1.1.1
您可能对最新版本的库有问题。这不是你的错。
有时，库的最新版本会带来额外的要求，或者可能不太稳定。
如果您在尝试运行上述脚本时确实有错误，我建议降级到 1.0.1 版(或更低版本)。这可以通过指定要安装到 pip 命令的版本来实现，如下所示:
sudo pip install xgboost==1.0.1
如果您看到一条警告消息，您可以暂时忽略它。例如，下面是一个警告消息示例，您可能会看到它，但可以忽略它:
FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.
如果您需要开发环境的特定说明，请参阅教程:
尽管我们将通过 Sklearn 包装类使用这个方法:xgbreversor和 XGBClassifier ，但是 XGBoost 库有自己的自定义 API。这将允许我们使用 Sklearn 机器学习库中的全套工具来准备数据和评估模型。
这两个模型以相同的方式运行，并采用相同的参数来影响决策树的创建和添加。
随机性用于模型的构建。这意味着算法每次在相同的数据上运行时，都会产生稍微不同的模型。
当使用具有随机学习算法的机器学习算法时，最好通过在多次运行或重复交叉验证中平均它们的表现来评估它们。当拟合最终模型时，可能需要增加树的数量，直到模型的方差在重复评估中减小，或者拟合多个最终模型并对它们的预测进行平均。
让我们看看如何为分类和回归开发一个 XGBoost 集成。
用于分类的 XGBoost 集成
在本节中，我们将研究如何使用 XGBoost 解决分类问题。
首先，我们可以使用 make_classification()函数创建一个包含 1000 个示例和 20 个输入特征的合成二进制分类问题。
下面列出了完整的示例。
# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# summarize the dataset
print(X.shape, y.shape)
运行该示例将创建数据集并总结输入和输出组件的形状。
(1000, 20) (1000,)
接下来，我们可以在这个数据集上评估一个 XGBoost 模型。
我们将使用重复的分层 k 折叠交叉验证来评估模型，重复 3 次，折叠 10 次。我们将报告所有重复和折叠的模型准确率的平均值和标准偏差。
# evaluate xgboost algorithm for classification
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 xgboost import XGBClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
model = XGBClassifier()
# evaluate the model
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)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到带有默认超参数的 XGBoost 集成在这个测试数据集上实现了大约 92.5%的分类准确率。
Accuracy: 0.925 (0.028)
我们也可以使用 XGBoost 模型作为最终模型，并对分类进行预测。
首先，XGBoost 集合适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。重要的是，该函数期望数据总是以 NumPy 数组的形式提供，即每个输入样本一行的矩阵。
下面的示例在我们的二进制类别数据集上演示了这一点。
# make predictions using xgboost for classification
from numpy import asarray
from sklearn.datasets import make_classification
from xgboost import XGBClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
model = XGBClassifier()
# fit the model on the whole dataset
model.fit(X, y)
# make a single prediction
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]
row = asarray([row])
yhat = model.predict(row)
print('Predicted Class: %d' % yhat[0])
运行该示例使 XGBoost 集成模型适合整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。
Predicted Class: 1
现在我们已经熟悉了使用 XGBoost 进行分类，让我们看看回归的 API。
回归的 XGBoost 集成
在本节中，我们将研究如何使用 XGBoost 解决回归问题。
首先，我们可以使用make _ revolution()函数创建一个包含 1000 个示例和 20 个输入特征的合成回归问题。
下面列出了完整的示例。
# test regression dataset
from sklearn.datasets import make_regression
# define dataset
X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=7)
# summarize the dataset
print(X.shape, y.shape)
运行该示例将创建数据集并总结输入和输出组件的形状。
(1000, 20) (1000,)
接下来，我们可以在这个数据集上评估一个 XGBoost 算法。
正如我们在上一节中所做的，我们将使用重复的 k-fold 交叉验证来评估模型，重复 3 次，重复 10 次。我们将报告所有重复和折叠模型的平均绝对误差(MAE)。Sklearn 库使 MAE 为负，因此它被最大化而不是最小化。这意味着负 MAE 越大越好，完美模型的 MAE 为 0。
下面列出了完整的示例。
# evaluate xgboost ensemble for regression
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 xgboost import XGBRegressor
# define dataset
X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=7)
# define the model
model = XGBRegressor()
# evaluate the model
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')
# report performance
print('MAE: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到带有默认超参数的 XGBoost 集成实现了大约 76 的 MAE。
MAE: -76.447 (3.859)
我们也可以使用 XGBoost 模型作为最终模型，并对回归进行预测。
首先，XGBoost 集合适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。与分类一样，单行数据必须以 NumPy 数组格式表示为二维矩阵。
下面的例子在我们的回归数据集上演示了这一点。
# gradient xgboost for making predictions for regression
from numpy import asarray
from sklearn.datasets import make_regression
from xgboost import XGBRegressor
# define dataset
X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=7)
# define the model
model = XGBRegressor()
# fit the model on the whole dataset
model.fit(X, y)
# make a single prediction
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]
row = asarray([row])
yhat = model.predict(row)
print('Prediction: %d' % yhat[0])
运行该示例使 XGBoost 集成模型适合整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。
Prediction: 50
现在我们已经熟悉了如何使用 xboost Sklearn API 来评估和使用 xboost 集成，让我们来看看如何配置模型。
XGBoost 超参数
在本节中，我们将仔细研究一些您应该考虑为梯度提升集成进行调整的超参数，以及它们对模型表现的影响。
探索树的数量
XGBoost 集成算法的一个重要超参数是集成中使用的决策树的数量。
回想一下，决策树被顺序地添加到模型中，以努力纠正和改进先前的树所做的预测。因此，更多的树往往更好。
树的数量可以通过“n _ estimates”参数设置，默认为 100。
下面的示例探讨了值在 10 到 5，000 之间的树的数量的影响。
# explore xgboost 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 xgboost import XGBClassifier
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)] = XGBClassifier(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()
运行该示例首先报告每个配置数量的决策树的平均准确性。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到该数据集上的表现有所提高，直到大约 500 棵树，之后表现似乎趋于平稳或下降。
>10 0.885 (0.029)
>50 0.915 (0.029)
>100 0.925 (0.028)
>500 0.927 (0.028)
>1000 0.926 (0.028)
>5000 0.925 (0.027)
为每个配置数量的树的准确度分数的分布创建一个方框和须图。
我们可以看到模型表现和集合规模增加的总体趋势。
XGBoost 集合大小与分类准确率的箱线图
探索树的深度
改变加入集成的每棵树的深度是梯度提升的另一个重要超参数。
树深度控制每棵树对训练数据集的专门化程度:它可能有多一般或多复杂。优选不太浅和一般的树(如 AdaBoost )和不太深和专门化的树(如 bootstrap aggregation )。
梯度提升通常在深度适中的树中表现良好，在技能和通用性之间找到了平衡。
树深度通过“最大深度参数控制，默认为 6。
下面的示例探讨了 1 到 10 之间的树深度以及对模型表现的影响。
# explore xgboost 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 xgboost import XGBClassifier
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)] = XGBClassifier(max_depth=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()
运行该示例首先报告每个配置的树深度的平均准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到表现随着树的深度而提高，可能在 3 到 8 的深度附近窥视，之后更深、更专门化的树会导致更差的表现。
>1 0.849 (0.028)
>2 0.906 (0.032)
>3 0.926 (0.027)
>4 0.930 (0.027)
>5 0.924 (0.031)
>6 0.925 (0.028)
>7 0.926 (0.030)
>8 0.926 (0.029)
>9 0.921 (0.032)
>10 0.923 (0.035)
为每个配置的树深度的准确率分数分布创建一个方框和须图。
我们可以看到模型表现随着树的深度增加到一定程度的总体趋势，在此之后，表现开始持平或随着过度专门化的树而下降。
XGBoost 集合树深度与分类准确率的方框图
探索学习率
学习率控制每个模型对集成预测的贡献量。
较小的速率可能需要集合中更多的决策树。
学习率可以通过“ eta ”参数控制，默认为 0.3。
下面的示例探讨了学习率，并比较了 0.0001 和 1.0 之间的值的效果。
# explore xgboost 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 xgboost import XGBClassifier
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] = XGBClassifier(eta=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()
运行示例首先报告每个配置的学习率的平均准确性。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到，较大的学习率会在该数据集上产生更好的表现。我们预计，为较小的学习率向集合中添加更多的树将进一步提升表现。
这突出了树的数量(训练速度)和学习率之间的权衡，例如，我们可以通过使用更少的树和更大的学习率来更快地拟合模型。
>0.0001 0.804 (0.039)
>0.0010 0.814 (0.037)
>0.0100 0.867 (0.027)
>0.1000 0.923 (0.030)
>1.0000 0.913 (0.030)
为每个配置的学习率的准确度分数的分布创建一个方框和须图。
我们可以看到随着学习率提高 0.1，模型表现提高的大趋势，之后表现会下降。
XGBoost 学习率与分类准确率的箱线图
探索样本数量
用于拟合每棵树的样本数量可以变化。这意味着每棵树都适合随机选择的训练数据集子集。
使用更少的样本会为每棵树引入更多的方差，尽管这可以提高模型的整体表现。
用于拟合每棵树的样本数量由“子样本参数指定，并且可以设置为训练数据集大小的一小部分。默认情况下，它被设置为 1.0 以使用整个训练数据集。
下面的示例演示了样本大小对模型表现的影响，比率从 10%到 100%以 10%的增量变化。
# explore xgboost subsample ratio 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 xgboost import XGBClassifier
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 arange(0.1, 1.1, 0.1):
key = '%.1f' % i
models[key] = XGBClassifier(subsample=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()
运行示例首先报告每个配置样本大小的平均准确度。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到平均表现对于覆盖大部分数据集的样本大小来说可能是最好的，例如 80%或更高。
>0.1 0.876 (0.027)
>0.2 0.912 (0.033)
>0.3 0.917 (0.032)
>0.4 0.925 (0.026)
>0.5 0.928 (0.027)
>0.6 0.926 (0.024)
>0.7 0.925 (0.031)
>0.8 0.928 (0.028)
>0.9 0.928 (0.025)
>1.0 0.925 (0.028)
为每个配置的采样比率的准确度分数分布创建一个方框和须图。
我们可以看到提高模型表现的总体趋势，可能在 80%左右达到峰值，并保持一定水平。
XGBoost 集合样本比与分类准确率的箱线图
探索功能数量
用于拟合每个决策树的特征数量可以变化。
像改变样本的数量一样，改变特征的数量会在模型中引入额外的方差，这可能会提高表现，尽管这可能需要增加树的数量。
每个树使用的特征数量被视为随机样本，由“ colsample_bytree ”参数指定，默认为训练数据集中的所有特征，例如 100%或值 1.0。您也可以对每个拆分的列进行采样，这是由“ colsample_bylevel ”参数控制的，但是这里我们不看这个超参数。
下面的示例探讨了特征数量对模型表现的影响，比率从 10%到 100%以 10%的增量变化。
# explore xgboost column ratio per tree 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 xgboost import XGBClassifier
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 arange(0.1, 1.1, 0.1):
key = '%.1f' % i
models[key] = XGBClassifier(colsample_bytree=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()
运行该示例首先报告每个配置的列比率的平均准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到平均表现增加到功能数量的一半(50%)，之后保持在一定水平。令人惊讶的是，删除每棵树一半的输入变量收效甚微。
>0.1 0.861 (0.033)
>0.2 0.906 (0.027)
>0.3 0.923 (0.029)
>0.4 0.917 (0.029)
>0.5 0.928 (0.030)
>0.6 0.929 (0.031)
>0.7 0.924 (0.027)
>0.8 0.931 (0.025)
>0.9 0.927 (0.033)
>1.0 0.925 (0.028)
为每个配置的柱比率的准确度分数的分布创建了一个方框和触须图。
我们可以看到提高模型表现的总体趋势，可能会达到 60%的峰值，并保持一定水平。
XGBoost 集合柱比率与分类准确率的箱线图
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
报纸
- XGBoost:一个可扩展的树木提升系统，2016。
项目
蜜蜂
文章
摘要
在本教程中，您发现了如何为分类和回归开发极端梯度提升集成。
具体来说，您了解到:
- 极端梯度提升是随机梯度提升集成算法的一个有效的开源实现。
- 如何用 Sklearn API 开发用于分类和回归的 XGBoost 集成？
- 如何探索 XGBoost 模型超参数对模型表现的影响？
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
