Machine-Learning-Mastery-集成学习教程-五-

Machine Learning Mastery 集成学习教程（五）

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

Python 中基于直方图的梯度提升集成

原文：machinelearningmastery.com/histogram-b…

最后更新于 2021 年 4 月 27 日

梯度提升是决策树算法的集合。

它可能是结构化(表格)分类和回归预测建模问题最流行的技术之一，因为它在实践中在广泛的数据集上表现良好。

梯度提升的一个主要问题是训练模型的速度很慢。当在具有成千上万个示例(行)的大型数据集上使用模型时，这尤其是一个问题。

通过将连续的输入变量离散化(宁滨)为几百个唯一的值，可以极大地加速训练添加到集合中的树。实现该技术并在该变换下围绕输入变量定制训练算法的梯度提升集成被称为基于直方图的梯度提升集成。

在本教程中，您将发现如何开发基于直方图的梯度提升树集成。

完成本教程后，您将知道:

• 基于直方图的梯度提升是一种用于训练梯度提升集成中使用的更快决策树的技术。
• 如何在 Sklearn 库中使用基于直方图的梯度提升的实验实现？
• 如何在 XGBoost 和 LightGBM 第三方库中使用基于直方图的梯度提升集成。

用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

如何开发基于直方图的梯度提升集成 图片由 YoTuT 提供，保留部分权利。

教程概述

本教程分为四个部分；它们是:

1. 直方图梯度提升
2. 使用 Sklearn 增强直方图梯度
3. 使用 XGBoost 的直方图梯度提升
4. 用 LightGBM 提升直方图梯度

直方图梯度提升

梯度提升是一种集成机器学习算法。

Boosting 是指一类集成学习算法，它将树模型顺序添加到集成中。添加到集合中的每个树模型试图校正集合中已经存在的树模型所产生的预测误差。

梯度提升是将像 AdaBoost 这样的增强算法推广到一个统计框架，该框架将训练过程视为一个加法模型，并允许使用任意损失函数，从而大大提高了该技术的能力。因此，梯度提升集成是大多数结构化(例如表格数据)预测建模任务的首选技术。

尽管梯度提升在实践中表现得非常好，但模型训练起来可能很慢。这是因为树必须按顺序创建和添加，不像其他集成模型，如随机森林，集成成员可以并行训练，利用多个中央处理器内核。因此，已经在提高梯度提升训练算法的效率的技术上投入了大量努力。

两个著名的库总结了许多训练梯度提升算法的现代效率技术，包括极限梯度提升(XGBoost)和光梯度提升机(LightGBM)。

可以加速的训练算法的一个方面是构建每个决策树，其速度受训练数据集中的示例数(行)和特征数(列)的限制。大的数据集，例如数万个或更多的例子，会导致非常缓慢地构建树作为每个值上的分割点，因为在构建树的过程中必须考虑每个特征。

如果我们能够减少#数据或#特征，我们将能够大大加快 GBDT 的训练。

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

通过减少连续输入特征的值的数量，可以显著加快决策树的构建。这可以通过将或宁滨值离散化到固定数量的桶中来实现。这可以将每个特征的唯一值的数量从数万减少到几百。

这允许决策树对序数桶(整数)而不是训练数据集中的特定值进行操作。这种输入数据的粗略近似对模型技能的影响通常很小，如果不这样做的话，会提高模型技能，并显著加快决策树的构建。

此外，可以使用有效的数据结构来表示输入数据的宁滨；例如，可以使用直方图，并且可以进一步定制树构建算法，以便在每个树的构建中高效地使用直方图。

这些技术最初是在 20 世纪 90 年代末开发的，用于在大型数据集上高效开发单个决策树，但也可用于决策树的集成，如梯度提升。

因此，在现代机器学习库中，通常将支持“直方图”的梯度提升算法称为基于直方图的梯度提升。

基于直方图的算法不是在排序后的特征值上找到分割点，而是将连续的特征值存储到离散的箱中，并在训练过程中使用这些箱来构建特征直方图。由于基于直方图的算法在内存消耗和训练速度方面都更有效，我们将在此基础上开发我们的工作。

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

现在我们已经熟悉了在梯度提升中向决策树的构造中添加直方图的思想，让我们回顾一下我们可以在预测建模项目中使用的一些常见实现。

有三个主要的库支持这项技术；它们是 Sklearn、XGBoost 和 LightGBM。

让我们依次仔细看看每一个。

注:我们不是在和算法赛跑；相反，我们只是演示如何配置每个实现来使用直方图方法，并将所有其他不相关的超参数保持在默认值不变。

使用 Sklearn 增强直方图梯度

Sklearn 机器学习库提供了一个支持直方图技术的梯度提升实验实现。

具体来说，这在历史梯度提升分类器和历史梯度提升回归器类中提供。

为了使用这些类，您必须在项目中添加一行，表明您很乐意使用这些实验技术，并且它们的行为可能会随着库的后续发布而改变。

...
# explicitly require this experimental feature
from sklearn.experimental import enable_hist_gradient_boosting

Sklearn 文档声称，这些基于直方图的梯度提升实现比库提供的默认梯度提升实现快几个数量级。

当样本数量大于数万个样本时，这些基于直方图的估计器可以比梯度提升分类器和梯度提升回归器快几个数量级。

— 基于直方图的梯度提升，Sklearn 用户指南 e

这些类可以像任何其他 Sklearn 模型一样使用。

默认情况下，集合为每个连续输入特征使用 255 个面元，这可以通过“ max_bins ”参数设置。将该值设置为更小的值，例如 50 或 100，可能会进一步提高效率，尽管可能会以牺牲一些模型技能为代价。

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

...
# define the model
model = HistGradientBoostingClassifier(max_bins=255, max_iter=100)

下面的示例显示了如何在包含 10，000 个示例和 100 个特征的合成类别数据集上评估直方图梯度提升算法。

使用重复分层 k 折叠交叉验证评估模型，并报告所有折叠和重复的平均准确性。

# evaluate sklearn histogram gradient boosting 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.experimental import enable_hist_gradient_boosting
from sklearn.ensemble import HistGradientBoostingClassifier
# define dataset
X, y = make_classification(n_samples=10000, n_features=100, n_informative=50, n_redundant=50, random_state=1)
# define the model
model = HistGradientBoostingClassifier(max_bins=255, max_iter=100)
# 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(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例会评估模型在合成数据集上的表现，并报告平均和标准偏差分类准确率。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到 Sklearn 直方图梯度提升算法在合成数据集上实现了大约 94.3%的平均准确率。

Accuracy: 0.943 (0.007)

我们还可以探索箱的数量对模型表现的影响。

下面的示例评估了模型的表现，每个连续输入要素的箱数从 50 到(大约)250 不等，增量为 50。

下面列出了完整的示例。

# compare number of bins for sklearn histogram gradient boosting
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.experimental import enable_hist_gradient_boosting
from sklearn.ensemble import HistGradientBoostingClassifier
from matplotlib import pyplot

# get the dataset
def get_dataset():
	X, y = make_classification(n_samples=10000, n_features=100, n_informative=50, n_redundant=50, random_state=1)
	return X, y

# get a list of models to evaluate
def get_models():
	models = dict()
	for i in [10, 50, 100, 150, 200, 255]:
		models[str(i)] = HistGradientBoostingClassifier(max_bins=i, max_iter=100)
	return models

# evaluate a give 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 scores
	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 and collect the scores
	scores = evaluate_model(model, X, y)
	# stores the results
	results.append(scores)
	names.append(name)
	# report 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()

运行该示例评估每个配置，报告一路上的平均和标准偏差分类准确率，并最终创建分数分布图。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到，增加面元的数量可能会降低该数据集上模型的平均准确率。

我们可能会预计，箱数的增加也可能需要树数的增加( max_iter )，以确保模型可以有效地探索和利用额外的分割点。

重要的是，拟合一个集合，其中每个变量使用 10 或 50 个箱，比每个输入变量使用 255 个箱要快得多。

>10 0.945 (0.009)
>50 0.944 (0.007)
>100 0.944 (0.008)
>150 0.944 (0.008)
>200 0.944 (0.007)
>255 0.943 (0.007)

创建一个图形，使用方框图和触须图比较每种配置的准确度分数分布。

在这种情况下，我们可以看到，增加直方图中的箱数似乎会减少分布的扩散，尽管这可能会降低模型的平均表现。

Sklearn 直方图梯度提升集成的箱数和须图

使用 XGBoost 的直方图梯度提升

极限梯度提升，简称 XGBoost，是一个提供高度优化的梯度提升实现的库。

库中实现的技术之一是对连续输入变量使用直方图。

XGBoost 库可以用你喜欢的 Python 包管理器安装，比如 Pip 例如:

sudo pip install xgboost

我们可以通过 XGBClassifier 和xgbreversor类开发用于 Sklearn 库的 XGBoost 模型。

通过将“ tree_method ”参数设置为“近似，可以将训练算法配置为使用直方图方法，并且可以通过“ max_bin ”参数设置箱数。

...
# define the model
model = XGBClassifier(tree_method='approx', max_bin=255, n_estimators=100)

下面的示例演示了如何评估一个 XGBoost 模型，该模型被配置为使用直方图或近似技术来构建每个连续输入要素有 255 个面元的树以及模型中有 100 棵树。

# evaluate xgboost histogram gradient boosting 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=10000, n_features=100, n_informative=50, n_redundant=50, random_state=1)
# define the model
model = XGBClassifier(tree_method='approx', max_bin=255, n_estimators=100)
# 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(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例会评估模型在合成数据集上的表现，并报告平均和标准偏差分类准确率。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到 XGBoost 直方图梯度提升算法在合成数据集上实现了大约 95.7%的平均准确率。

Accuracy: 0.957 (0.007)

用 LightGBM 提升直方图梯度

Light Gradient Boosting Machine(简称 LightGBM)是另一个像 XGBoost 一样的第三方库，它提供了一个高度优化的梯度提升实现。

它可能在 XGBoost 之前实现了直方图技术，但 XGBoost 后来实现了同样的技术，突出了梯度提升库之间的“梯度提升效率”竞争。

LightGBM 库可以用你喜欢的 Python 包管理器安装，比如 Pip 例如:

sudo pip install lightgbm

我们可以通过lgbm 分类器和lgbm 回归器类开发 LightGBM 模型，用于 Sklearn 库。

默认情况下，训练算法使用直方图。每个连续输入变量的最大箱数可以通过“ max_bin ”参数设置。

...
# define the model
model = LGBMClassifier(max_bin=255, n_estimators=100)

下面的示例演示了如何评估 LightGBM 模型，该模型被配置为使用直方图或近似技术来构建每个连续输入要素有 255 个面元的树和模型中的 100 棵树。

# evaluate lightgbm histogram gradient boosting 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 lightgbm import LGBMClassifier
# define dataset
X, y = make_classification(n_samples=10000, n_features=100, n_informative=50, n_redundant=50, random_state=1)
# define the model
model = LGBMClassifier(max_bin=255, n_estimators=100)
# 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(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例会评估模型在合成数据集上的表现，并报告平均和标准偏差分类准确率。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到 LightGBM 直方图梯度提升算法在合成数据集上实现了大约 94.2%的平均准确率。

Accuracy: 0.942 (0.006)

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

教程

• 如何在 Python 中开发梯度提升机集成
• 使用 Sklearn、XGBoost、LightGBM 和 CatBoost 进行梯度提升

报纸

• Sprint:数据挖掘的可扩展并行分类器，1996。
• cloud:一个用于大数据集的决策树分类器，1998。
• 通信与内存高效并行决策树构建，2003。
• LightGBM:一种高效的梯度提升决策树，2017。
• XGBoost:一个可扩展的树木提升系统，2016。

蜜蜂

• 硬化。一起。组渐增分类器 API 。
• 硬化。一起。组曲提升器 API 。
• xboost，快速直方图优化生长器，8 倍至 10 倍加速
• xgboost。xgbcclassifier API。
• xboost。xgbreversor API。
• 光弹。LGBMClassifier API 。
• light GBM . lgbmr API。

摘要

在本教程中，您发现了如何开发基于直方图的梯度提升树集成。

具体来说，您了解到:

• 基于直方图的梯度提升是一种用于训练梯度提升集成中使用的更快决策树的技术。
• 如何在 Sklearn 库中使用基于直方图的梯度提升的实验实现？
• 如何在 XGBoost 和 LightGBM 第三方库中使用基于直方图的梯度提升集成。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

开发对集成学习如何工作的直觉

原文：machinelearningmastery.com/how-ensembl…

最后更新于 2021 年 4 月 27 日

集成是一种机器学习方法，它结合了来自多个模型的预测，以获得更好的预测表现。

有许多不同类型的集成，尽管所有方法都有两个关键属性:它们要求贡献模型不同，从而产生不同的误差；它们组合预测，试图利用每个不同模型的优点。

然而，尚不清楚集成如何实现这一点，尤其是在分类和回归类型预测建模问题的背景下。重要的是要培养一种直觉，即当集合组合预测时，它们到底在做什么，因为这将有助于在预测建模项目中选择和配置合适的模型。

在这篇文章中，你将发现集成学习方法背后的直觉。

看完这篇文章，你会知道:

• 集成学习方法通过组合贡献成员学习的映射函数来工作。
• 分类的集合最好通过成员决策边界的组合来理解。
• 回归的集合最好通过成员超平面的组合来理解。

用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

培养对集合学习如何工作的直觉 照片由马可·韦奇拍摄，版权所有。

教程概述

本教程分为三个部分；它们是:

1. 集成是如何工作的
2. 分类集成的直觉
3. 回归集成的直觉

集成是如何工作的

集成学习指的是组合来自两个或更多模型的预测。

使用集合方法的目标是提高预测的技巧，而不是任何一个贡献成员的技巧。

这个目标很简单，但是不太清楚集成方法是如何实现的。

培养对集成技术如何工作的直觉很重要，因为它将帮助您为预测任务选择和配置特定的集成方法，并解释它们的结果，以提出进一步提高表现的替代方法。

考虑一个简单的集合，它在训练数据集稍微不同的样本上训练两个模型，并对它们的预测进行平均。

每个成员模型都可以以独立的方式进行预测，尽管希望对它们的预测进行平均可以提高它们的表现。只有当每个模型做出不同的预测时，才会出现这种情况。

不同的预测意味着在某些情况下，模型 1 会产生很少的误差，而模型 2 会产生更多的误差，而对于其他情况则相反。平均他们的预测试图减少这两个模型预测的误差。

反过来，模型要做出不同的预测，就必须对预测问题做出不同的假设。更具体地说，他们必须学习从输入到输出的不同映射函数。在简单的情况下，我们可以通过在训练数据集的不同样本上训练每个模型来实现这一点，但是还有许多其他方法可以实现这种差异；训练不同的模型类型是其一。

这些元素是一般意义上的集成方法的工作原理，即:

1. 成员针对同一个问题学习不同的映射函数。这是为了确保模型产生不同的预测误差。
2. 成员做出的预测以某种方式组合。这是为了确保利用预测误差的差异。

我们不能简单地消除预测误差，尽管我们可以；相反，我们平滑了贡献成员学习的映射函数。

改进的映射功能允许进行更好的预测。

这是一个更深层次的问题，理解它很重要。让我们仔细看看这对分类和回归任务意味着什么。

分类集成的直觉

分类预测建模是指必须从输入的例子中预测类别标签的问题。

模型可以预测清晰的类别标签，例如分类变量，或者所有可能的分类结果的概率。

在简单的情况下，可以通过投票来组合由集成成员预测的清晰类别标签，例如，具有最多投票的统计模式或标签决定了集成结果。集成成员预测的类概率可以被求和和归一化。

在功能上，类似这样的过程发生在分类任务的集成中，但是影响的是从输入示例到类标签或概率的映射函数。现在让我们坚持标签。

考虑分类映射函数的最常见方式是使用一个图，其中输入数据表示由输入变量范围定义的 n 维空间中的一个点，称为特征空间。例如，如果我们有两个输入要素，x 和 y，都在 0 到 1 的范围内，那么输入空间将是二维平面，并且数据集中的每个示例都是该平面上的一个点。然后，可以根据类别标签为每个点指定颜色或形状。

学习如何对点进行分类的模型实际上是在特征空间中绘制线来分隔示例。我们可以对网格中的特征空间中的点进行采样，并通过每个类标签获得模型认为特征空间应该如何的地图。

模型对特征空间中的示例的分离称为决策边界，模型如何对特征空间中的点进行分类的网格或地图的图称为决策边界图。

现在考虑一个集合，其中每个模型都有不同的输入到输出的映射。实际上，每个模型都有不同的决策边界，或者对如何在特征空间中通过类标签进行分割有不同的想法。每个模型会画出不同的线，并犯不同的错误。

当我们组合来自这些多个不同模型的预测时，我们实际上是在平均决策边界。我们正在定义一个新的决策边界，试图从贡献成员所了解的特征空间的所有不同视图中学习。

下图取自“集成机器学习”的第 1 页，提供了这方面的有用描述。

使用集成组合决策边界的示例 摘自集成机器学习，2012 年。

我们可以看到顶部的贡献成员，每个成员在特征空间中都有不同的决策边界。然后左下角在同一个图上画出所有的决策边界，显示它们是如何不同并产生不同的错误的。

最后，我们可以将这些边界组合起来，在右下角创建一个新的广义决策边界，它可以更好地捕捉特征空间的真实但未知的划分，从而获得更好的预测表现。

回归集成的直觉

回归预测建模指的是必须从输入的例子中预测数值的问题。

在简单的情况下，集成成员所做的数值预测可以使用统计方法(如平均值)进行组合，尽管也可以使用更复杂的组合。

像分类一样，集合的效果是每个贡献成员的映射函数被平均或组合。

考虑回归的映射函数的最常见方式是使用线图，其中输出变量是添加到输入要素空间的另一个维度。特征空间和目标变量维度的关系然后可以被总结为超平面，例如多个维度中的线。

这是令人费解的，所以让我们考虑一个最简单的情况，我们有一个数字输入和一个数字输出。考虑一个平面或图形，其中 x 轴代表输入特征，y 轴代表目标变量。我们可以将数据集中的每个示例绘制为图上的一个点。

学习从输入到输出的映射的模型实际上学习了将特征空间中的点连接到目标变量的超平面。我们可以对输入特征空间中的点网格进行采样，以设计目标变量的值，并绘制一条线来连接它们，以表示这个超平面。

在我们的二维例子中，这是一条穿过图上点的线。线不穿过图的任何点表示预测误差，并且从线到点的距离是误差的大小。

现在考虑一个集合，其中每个模型都有不同的输入到输出的映射。实际上，每个模型都有一个连接特征空间和目标的不同超平面。每个模型会画出不同的线，并以不同的幅度产生不同的误差。

当我们结合这些多个不同模型的预测时，我们实际上是在平均超平面。我们正在定义一个新的超平面，试图从所有不同的特征中学习如何将输入映射到输出。

下图给出了具有不同学习超平面映射的一维输入特征空间和目标空间的示例。

使用集成组合超平面的示例

我们可以从训练数据集中看到代表点的点。我们还可以通过数据看到许多不同的直线。模型不需要学习直线，但在这种情况下，它们需要。

最后，我们可以看到一条黑色虚线，显示了所有模型的总体平均值，从而降低了预测误差。

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

书

• 使用集成方法的模式分类，2010。
• 集成方法，2012。
• 集成机器学习，2012。
• 数据挖掘中的集成方法，2010。

文章

• 一起学习，维基百科。
• 一起学习，学院派。

摘要

在这篇文章中，你发现了集成学习方法背后的直觉。

具体来说，您了解到:

• 集成学习方法通过组合贡献成员学习的映射函数来工作。
• 分类的集合最好通过成员决策边界的组合来理解。
• 回归的集合最好通过成员超平面的组合来理解。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

如何开轻量梯度提升机（LightGBM）集合

原文：machinelearningmastery.com/light-gradi…

最后更新于 2021 年 4 月 27 日

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

LightGBM 通过添加一种自动特征选择以及关注具有更大梯度的增强示例来扩展梯度提升算法。这可以大大加快训练速度，提高预测表现。

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

在本教程中，您将发现如何开发用于分类和回归的光梯度提升机集成。

完成本教程后，您将知道:

• 光梯度提升机(LightGBM)是随机梯度提升集成算法的一个高效开源实现。
• 如何用 Sklearn API 开发用于分类和回归的 LightGBM 集成？
• 如何探索 LightGBM 模型超参数对模型表现的影响？

用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

如何通过 GPA 照片档案开轻量梯度提升机(LightGBM)集成 照片，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 光梯度提升机算法
2. LightGBM Sklearn API
   1. 用于分类的 LightGBM 集成
   2. 回归的 LightGBM 集成
3. LightGBM 超参数
   1. 探索树的数量
   2. 探索树的深度
   3. 探索学习率
   4. 探索提升类型

光梯度提升机算法

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

集成是由决策树模型构建的。树被一次一个地添加到集合中，并且适合于校正由先前模型产生的预测误差。这是一种称为 boosting 的集成机器学习模型。

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

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

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

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

因此， LightGBM 指的是开源项目、软件库和机器学习算法。这样，它非常类似于极限梯度提升或 XGBoost 技术。

LightGBM 是由柯等人在 2017 年发表的论文中描述的，论文标题为“ LightGBM:一种高效的梯度提升决策树”实现引入了两个关键思想:高斯和 EFB。

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

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

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

排他特征捆绑，简称 EFB，是一种捆绑稀疏(大部分为零)互斥特征的方法，例如已经过一次热编码的分类变量输入。因此，这是一种自动特征选择。

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

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

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

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

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

LightGBM Sklearn API

LightGBM 可以作为独立的库安装，LightGBM 模型可以使用 Sklearn API 开发。

第一步是安装 LightGBM 库，如果还没有安装的话。这可以在大多数平台上使用 pip python 包管理器来实现；例如:

sudo pip install lightgbm

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

# check lightgbm version
import lightgbm
print(lightgbm.__version__)

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

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

2.3.1

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

• LightGBM 安装指南

LightGBM 库有自己的定制 API，尽管我们将通过 Sklearn 包装类使用该方法:lgbmreversor和 LGBMClassifier 。这将允许我们使用 Sklearn 机器学习库中的全套工具来准备数据和评估模型。

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

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

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

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

用于分类的 LightGBM 集成

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

首先，我们可以使用 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,)

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

我们将使用三次重复和 10 次折叠的重复分层 k 折叠交叉验证来评估模型。我们将报告所有重复和折叠的模型准确率的平均值和标准偏差。

# evaluate lightgbm 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 lightgbm import LGBMClassifier
# 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 = LGBMClassifier()
# 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)))

运行该示例会报告模型的均值和标准差准确率。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

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

Accuracy: 0.925 (0.031)

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

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

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

# make predictions using lightgbm for classification
from sklearn.datasets import make_classification
from lightgbm import LGBMClassifier
# 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 = LGBMClassifier()
# 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]
yhat = model.predict([row])
print('Predicted Class: %d' % yhat[0])

运行该示例使 LightGBM 集成模型适合整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。

Predicted Class: 1

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

回归的 LightGBM 集成

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

首先，我们可以使用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,)

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

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

下面列出了完整的示例。

# evaluate lightgbm 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 lightgbm import LGBMRegressor
# 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 = LGBMRegressor()
# 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)))

运行该示例会报告模型的均值和标准差准确率。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

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

MAE: -60.004 (2.887)

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

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

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

# gradient lightgbm for making predictions for regression
from sklearn.datasets import make_regression
from lightgbm import LGBMRegressor
# 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 = LGBMRegressor()
# 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]
yhat = model.predict([row])
print('Prediction: %d' % yhat[0])

运行该示例使 LightGBM 集成模型适合整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。

Prediction: 52

现在我们已经熟悉了使用 Sklearn API 来评估和使用 LightGBM 集成，让我们来看看如何配置模型。

LightGBM 超参数

在本节中，我们将仔细研究一些您应该考虑为 LightGBM 集成进行调整的超参数，以及它们对模型表现的影响。

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

有关调优 LightGBM 超参数的一般建议，请参见文档:

• LightGBM 参数调谐。

探索树的数量

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

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

树的数量可以通过“n _ estimates”参数设置，默认为 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()

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

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

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

>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 )和不太深和专门化的树(如 bootstrap aggregation )。

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

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

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

下面的示例探讨了 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()

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

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到表现随着树的深度而提高，可能一直到 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 之间的值的效果。

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

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

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到，较大的学习率会在该数据集上产生更好的表现。我们预计，为较小的学习率向集合中添加更多的树将进一步提升表现。

>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 ':丢弃者遇到多重加性回归树(dart)。
• goss ':基于梯度的单侧采样(goss)。

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

DART 在 2015 年的一篇题为《 DART:丢弃生遇到多重加性回归树》的论文中有所描述，顾名思义，它将丢弃生的概念从深度学习添加到多重加性回归树(MART)算法中，这是梯度提升决策树的前身。

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

——DART:丢弃者遇到多重加性回归树，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()

运行示例首先报告每种配置的升压类型的平均准确率。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

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

>gbdt 0.925 (0.031)
>dart 0.912 (0.028)
>goss 0.918 (0.027)

为每种配置的增强方法的准确度分数分布创建一个方框和须图，允许直接比较技术。

LightGBM 增强类型与分类准确率的箱线图

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

相关教程

• 机器学习梯度提升算法的简单介绍
• 使用 Sklearn、XGBoost、LightGBM 和 CatBoost 进行梯度提升

报纸

• LightGBM:一种高效的梯度提升决策树，2017。
• DART:丢弃者遇到多重加性回归树，2015。

蜜蜂

• 光格姆项目，GitHub
• LightGBM 的文档。
• LightGBM 安装指南
• LightGBM 参数调谐。
• 光弹。LGBMClassifier API 。
• light GBM . lgbmr API。

文章

• 梯度提升，维基百科。

摘要

在本教程中，您发现了如何开发用于分类和回归的光梯度提升机集成。

具体来说，您了解到:

• 光梯度提升机(LightGBM)是随机梯度提升集成算法的一个有效的开源实现。
• 如何用 Sklearn API 开发用于分类和回归的 LightGBM 集成？
• 如何探索 LightGBM 模型超参数对模型表现的影响？

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

什么是机器学习中的元学习？

原文：machinelearningmastery.com/meta-learni…

最后更新于 2021 年 4 月 27 日

机器学习中的元学习是指从其他学习算法中学习的学习算法。

最常见的是，这意味着使用机器学习算法，该算法学习如何最好地组合来自集成学习领域中其他机器学习算法的预测。

然而，元学习也可能指的是在现代自动算法寻求自动化的机器学习项目中，由实践者执行的模型选择和算法调整的手动过程。它还指跨多个相关预测建模任务的学习，称为多任务学习，其中元学习算法学习如何学习。

在本教程中，您将发现机器学习中的元学习。

完成本教程后，您将知道:

• 元学习是指从其他机器学习算法的输出中学习的机器学习算法。
• 元学习算法通常指像叠加这样的集成学习算法，它学习如何组合来自集成成员的预测。
• 元学习也指学习如何跨一套相关预测任务进行学习的算法，称为多任务学习。

用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

什么是机器学习中的元学习？ 瑞安·哈洛克摄影，版权所有。

教程概述

本教程分为五个部分；它们是:

1. 什么是元？
2. 什么是元学习？
3. 元算法、元分类器和元模型
4. 作为元学习的模型选择和调整
5. 作为元学习的多任务学习

什么是元？

Meta 是指一个等级以上。

Meta 通常意味着将抽象级别提高一步，通常指的是关于其他东西的信息。

例如，您可能熟悉“元数据”，它是关于数据的数据。

关于数据的数据通常被称为元数据…

—第 512 页，数据挖掘:实用机器学习工具与技术，2016。

您将数据存储在文件中，元数据的一个常见示例是关于存储在文件中的数据的数据，例如:

• 文件的名称。
• 文件的大小。
• 文件的创建日期。
• 上次修改文件的日期。
• 文件的类型。
• 文件的路径。

既然我们已经熟悉了“ meta ”这个概念，我们就来考虑一下这个术语在机器学习中的用法，比如“ meta-learning ”

什么是元学习？

元学习是指关于学习的学习。

机器学习中的元学习最常见的是指从其他机器学习算法的输出中学习的机器学习算法。

在我们的机器学习项目中，我们试图找出(学习)什么算法在我们的数据上表现最好，我们可以认为机器学习算法取代了我们自己，至少在某种程度上是这样。

机器学习算法从历史数据中学习。例如，监督学习算法学习如何将输入模式的例子映射到输出模式的例子，以解决分类和回归预测建模问题。

算法直接在历史数据上训练，以产生模型。该模型随后可用于预测输出值，例如数字或类别标签，用于输入的新示例。

• 学习算法:从历史数据中学习，给出新的数据例子进行预测。

元学习算法从其他从数据中学习的机器学习算法的输出中学习。这意味着元学习需要已经在数据上训练过的其他学习算法的存在。

例如，监督元学习算法学习如何将其他学习算法的输出示例(如预测数字或类别标签)映射到分类和回归问题的目标值示例上。

类似地，元学习算法通过将现有机器学习算法的输出作为输入并预测数字或类别标签来进行预测。

• 元学习算法:从学习算法的输出中学习，给定其他模型做出的预测，做出预测。

这样，元学习发生在机器学习之上的一个级别。

如果机器学习学会如何最好地使用数据中的信息来进行预测，那么元学习或元机器学习学会如何最好地使用来自机器学习算法的预测来进行预测。

现在我们已经熟悉了元学习的思想，让我们来看一些元学习算法的例子。

元算法、元分类器和元模型

元学习算法通常简称为元算法或元学习器。

• 元算法:元学习机器学习算法的简称。

类似地，用于分类任务的元学习算法可以被称为元分类器，用于回归任务的元学习算法可以被称为元回归器。

• 元分类器:分类预测建模任务的元学习算法。
• 元回归:回归预测建模任务的元学习算法。

在元学习算法被训练之后，它产生元学习模型，例如从数据中学习的特定规则、系数或结构。元学习模型或元模型然后可以用于进行预测。

• 元模型:运行元学习算法的结果。

最广为人知的元学习算法叫做堆叠泛化，简称堆叠。

堆叠可能是最流行的元学习技术。

—第 82 页，使用集成方法的模式分类，2010。

堆叠是一种集成学习算法。集成学习指的是结合两个或多个预测模型的预测的机器学习算法。堆叠使用另一个机器学习模型，一个元模型，来学习如何最好地组合贡献的集成成员的预测。

为了归纳元分类器，首先训练基本分类器(第一阶段)，然后训练元分类器(第二阶段)。在预测阶段，基本分类器将输出它们的分类，然后元分类器将进行最终分类(作为基本分类器的函数)。

—第 82 页，使用集成方法的模式分类，2010。

因此，堆叠集成算法被称为一种元学习，或元学习算法。

• 堆叠:集成机器学习算法，使用元学习来组合集成成员做出的预测。

还有一些不太为人所知的集成学习算法，它们使用元模型来学习如何组合来自其他机器学习模型的预测。最值得注意的是，专家混合使用门控模型(元模型)来学习如何组合专家模型的预测。

通过使用元学习器，该方法试图归纳哪些分类器是可靠的，哪些是不可靠的。

—第 82 页，使用集成方法的模式分类，2010。

更一般地，用于监督学习的元模型几乎总是集成学习算法，并且使用另一个模型来组合来自集成成员的预测的任何集成学习算法可以被称为元学习算法。

相反，堆叠引入了元载体的概念[…]堆叠试图学习哪些分类器是可靠的，使用另一种学习算法——元载体——来发现如何最好地组合基础学习器的输出。

—第 497 页，数据挖掘:实用机器学习工具与技术，2016。

作为元学习的模型选择和调整

在历史数据集上训练机器学习算法是一个搜索过程。

构成模型的内部结构、规则或系数根据某种损失函数进行修改。

这种类型的搜索过程被称为优化，因为我们不是简单地寻求一个解决方案，而是一个最大化表现指标(如分类)或最小化损失分数(如预测误差)的解决方案。

这种将学习视为优化的想法不仅仅是一个有用的隐喻；它是在大多数机器学习算法的核心执行的文字计算，无论是解析的(最小二乘)还是数值的(梯度下降)，或者是某种混合优化过程。

元学习是训练模型之上的一个层次，它包括寻找数据准备过程、学习算法和学习算法超参数(完整的建模管道)，这些超参数为测试工具上的表现指标获得最佳分数。

这也是通常由人执行的优化过程。

因此，我们可以认为自己是机器学习项目中的元学习器。

这不是这个术语的普通含义，但它是一个有效的用法。这将涵盖模型选择和算法超参数调整等任务。

自动化程序通常被称为自动机器学习，简称为“ automl ”

…用户只需提供数据，AutoML 系统就会自动确定最适合该特定应用的方法。因此，AutoML 使对应用机器学习感兴趣但没有资源详细了解机器学习背后技术的领域科学家可以使用最先进的机器学习方法。

—第九页，自动化机器学习:方法、系统、挑战，2019。

Automl 可能不被称为元学习，但是 automl 算法可以利用跨学习任务的元学习，称为学会学习。

元学习，或学习学习，是一门系统地观察不同的机器学习方法如何在广泛的学习任务中执行的科学，然后从这种经验或元数据中学习，以比其他方式更快地学习新任务。

—第 35 页，自动化机器学习:方法、系统、挑战，2019。

作为元学习的多任务学习

学习学习是一个相关的研究领域，通俗地说就是元学习。

如果学习涉及一种随着任务经验而改进的算法，那么学习就是一种在多个任务中使用的算法，它随着经验和任务而改进。

……一种算法被称为学会学习它在每项任务中的表现是否随着经验和任务数量的增加而提高。

——学会学习:介绍与概述，1998。

学习学习算法不是为每个任务手动开发算法或为每个任务选择和调整现有算法，而是根据相似任务的集合来调整自己。

元学习提供了一种替代范式，在这种范式中，机器学习模型通过多次学习获得经验——通常涵盖相关任务的分布——并利用这种经验来提高其未来的学习绩效。

——神经网络中的元学习:一项调查，2020。

这被称为多任务学习的问题。

为多任务学习问题开发的算法学习如何学习，可以称为执行元学习。

使用学习来学习或元学习来获取知识或归纳偏见的想法由来已久。

——通过梯度下降学习通过梯度下降学习，2016。

• Learning to Learning:多任务学习问题上的应用学习算法，其中他们跨任务执行元学习，例如，学习关于任务的学习。

这包括熟悉的技术，例如在计算机视觉的深度学习算法中常见的转移学习。这是一个深度神经网络在一个计算机视觉任务上被训练的地方，并被用作起点，可能对相关的视觉任务进行很少的修改或训练。

当网络从输入图像中自动提取的特征在多个相关任务中有用时，例如从照片中的常见对象中提取的抽象特征，迁移学习效果很好。

这通常在监督学习环境中理解，其中输入是相同的，但是目标可能是不同的性质。例如，我们可能在第一个设置中了解一组视觉类别，如猫和狗，然后在第二个设置中了解一组不同的视觉类别，如蚂蚁和黄蜂。

—第 536 页，深度学习，2016。

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

相关教程

• 用 Python 堆叠集成机器学习
• 如何用 Keras 开发 Python 深度学习神经网络的堆叠集成
• 如何用 Python 从零开始实现堆叠泛化(堆叠)
• 用计算机视觉模型在 Keras 中进行迁移学习
• 深度学习迁移学习入门

报纸

• 学会学习:介绍与概述，1998。
• 通过梯度下降学习通过梯度下降学习，2016。
• 神经网络中的元学习:一项调查，2020。

书

• 集成方法，2012。
• 使用集成方法的模式分类，2010。
• 数据挖掘:实用机器学习工具与技术，2016。
• 深度学习，2016 年。
• 自动化机器学习:方法、系统、挑战，2019。

文章

• 元，维基百科。
• 元建模，维基百科。
• 元学习(计算机科学)，维基百科。

摘要

在本教程中，您发现了机器学习中的元学习。

具体来说，您了解到:

• 元学习是指从其他机器学习算法的输出中学习的机器学习算法。
• 元学习算法通常指像叠加这样的集成学习算法，它学习如何组合来自集成成员的预测。
• 元学习也指学习如何跨一套相关预测任务进行学习的算法，称为多任务学习。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

混合专家集成的温和介绍

原文：machinelearningmastery.com/mixture-of-…

最后更新于 2021 年 11 月 7 日

专家混合是神经网络领域发展起来的集成学习技术。

它包括将预测建模任务分解为子任务，在每个子任务上训练一个专家模型，开发一个门控模型，该模型根据要预测的输入学习信任哪个专家，并组合预测。

尽管该技术最初是使用神经网络专家和门控模型描述的，但它可以推广到使用任何类型的模型。因此，它显示出与堆叠概括的强相似性，并且属于被称为元学习的集成学习方法的类别。

在本教程中，您将发现集成学习的专家混合方法。

完成本教程后，您将知道:

• 集成学习的一种直观方法包括将任务划分为子任务，并在每个子任务上培养专家。
• 专家混合是一种集成学习方法，它试图使用专家模型根据子任务明确地解决预测建模问题。
• 分治法与决策树的构建有关，元学习器法与堆叠概括集成法有关。

用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

《混合专家集成》的温柔介绍拉德克·库恰尔斯基摄，版权所有。

教程概述

本教程分为三个部分；它们是:

1. 子任务和专家
2. 专家混合
   1. 子任务
   2. 专家模型
   3. 门控模型
   4. 联营法
3. 与其他技术的关系
   1. 专家和决策树的混合
   2. 专家和堆叠的混合

子任务和专家

一些预测建模任务非常复杂，尽管它们可能适合于自然划分为子任务。

例如，考虑一个一维函数，它在二维中有一个像 S 一样的复杂形状。我们可以尝试设计一个完全模拟函数的模型，但是如果我们知道函数的形式，S 形，我们也可以把问题分成三个部分:顶部的曲线，底部的曲线和连接曲线的线。

这是一种解决问题的分治方法，是许多预测建模自动化方法以及更广泛的解决问题方法的基础。

这种方法也可以作为开发集成学习方法的基础。

例如，我们可以基于问题的一些领域知识将输入特征空间划分为子空间。然后可以在问题的每个子空间上训练模型，实际上是特定子问题的专家。然后，模型会学习需要哪个专家来预测未来的新例子。

子问题可能重叠，也可能不重叠，来自类似或相关子问题的专家可能能够为技术上超出其专业知识的例子做出贡献。

这种集成学习的方法是一种称为专家混合的技术的基础。

专家混合

混合专家，简称 MoE 或 ME，是一种集成学习技术，实现了在预测建模问题的子任务上训练专家的思想。

在神经网络社区中，一些研究人员已经检查了分解方法。[……]专家混合(ME)方法，分解输入空间，以便每个专家检查空间的不同部分。[……]门控网络负责组合各种专家。

—第 73 页，使用集成方法的模式分类，2010。

该方法有四个要素，它们是:

• 将任务分成子任务。
• 为每个子任务培养一名专家。
• 使用门控模型来决定使用哪个专家。
• 池预测和门控模型输出进行预测。

下图取自 2012 年出版的《集合方法》第 94 页，提供了该方法的架构元素的有用概述。

专家模型与专家成员和选通网络的混合示例 取自:集成方法

子任务

第一步是将预测建模问题分成子任务。这通常涉及到使用领域知识。例如，一幅图像可以被分成单独的元素，如背景、前景、对象、颜色、线条等等。

……ME 采用分而治之的策略，将复杂的任务分解成几个更简单、更小的子任务，并针对不同的子任务对单个学习器(称为专家)进行培训。

—第 94 页，集合方法，2012。

对于那些任务划分为子任务不明显的问题，可以使用更简单、更通用的方法。例如，可以想象一种方法，该方法将输入特征空间按列组划分，或者根据标准分布的距离度量、内联和离群值来分离特征空间中的示例，等等。

……在 ME 中，一个关键问题是如何找到任务的自然划分，然后从子解中推导出整体解。

—第 94 页，集合方法，2012。

专家模型

接下来，为每个子任务设计一个专家。

专家混合方法最初是在人工神经网络领域开发和探索的，因此传统上，专家本身是神经网络模型，用于在回归的情况下预测数值，或者在分类的情况下预测类别标签。

应该清楚的是，我们可以为专家“插入”任何模型。例如，我们可以使用神经网络来表示门控功能和专家。结果被称为混合密度网络。

—第 344 页，机器学习:概率视角，2012。

每个专家接收相同的输入模式(行)并做出预测。

门控模型

模型用于解释每个专家做出的预测，并帮助决定对于给定的输入信任哪个专家。这被称为门控模型或门控网络，因为它传统上是一个神经网络模型。

选通网络将提供给专家模型的输入模式作为输入，并输出每个专家在对输入进行预测时应有的贡献。

……由选通网络确定的权重是基于给定的输入动态分配的，因为 MoE 可以有效地了解每个集成成员学习了特征空间的哪个部分

—第 16 页，集成机器学习，2012。

选通网络是该方法的关键，并且模型有效地学习为给定的输入选择子任务类型，并且反过来信任专家来做出强有力的预测。

专家混合也可以看作是一种分类器选择算法，其中个体分类器被训练成为特征空间某一部分的专家。

—第 16 页，集成机器学习，2012。

当使用神经网络模型时，门控网络和专家一起被训练，使得门控网络学习何时信任每个专家来做出预测。该培训程序传统上使用期望最大化 (EM)来实现。选通网络可能有一个软最大值输出，为每个专家给出类似概率的置信度得分。

一般来说，训练过程试图实现两个目标:对于给定的专家，找到最优的选通函数；对于给定的选通函数，就选通函数指定的分布对专家进行培训。

—第 95 页，集合方法，2012。

联营法

最后，专家模型的混合必须进行预测，这是使用池化或聚合机制实现的。这可能就像选择由选通网络提供最大输出或置信度的专家一样简单。

可选地，可以进行加权和预测，该加权和预测明确地组合了每个专家进行的预测和选通网络估计的置信度。您可能会想到其他方法来有效利用预测和门控网络输出。

然后，池化/组合系统可以选择具有最高权重的单个分类器，或者计算每个类别的分类器输出的加权和，并挑选接收最高加权和的类别。

—第 16 页，集成机器学习，2012。

与其他技术的关系

专家混合法今天不太流行，也许是因为它被描述在神经网络领域。

尽管如此，这项技术已经有超过 25 年的进步和探索，你可以在 2012 年的论文“二十年的专家混合”中看到一个很好的总结。”

重要的是，我建议考虑该技术更广泛的意图，并探索如何在您自己的预测建模问题上使用它。

例如:

• 有没有明显的或系统的方法可以将预测建模问题分成子任务？
• 你能在每个子任务上训练专门的方法吗？
• 考虑开发一个模型来预测每个专家模型的可信度。

专家和决策树的混合

我们还可以看到分类和回归树专家的混合之间的关系，通常被称为 CART。

决策树适合使用对特征空间的分治方法。每个分割被选为输入特征的常数值，并且每个子树可以被认为是子模型。

专家混合主要在神经网络社区中进行研究。在这个思路中，研究人员一般会考虑分而治之的策略，尝试联合学习参数模型的混合，并使用组合规则来获得整体解决方案。

—第 16 页，集合方法，2012。

在设计专家混合时，我们可以采用类似的递归分解方法将预测建模任务分解为子问题。这通常被称为专家的层级混合。

专家分层混合(HME)程序可被视为基于树的方法的变体。主要区别在于，树分裂不是硬决策，而是软概率决策。

—第 329 页，统计学习的要素，2016。

与决策树不同，将任务划分为子任务通常是显式的和自上而下的。此外，与决策树不同，专家混合试图调查所有的专家子模型，而不是单个模型。

HMEs 和树的 CART 实现之间还有其他区别。在 HME，线性(或逻辑回归)模型适用于每个终端节点，而不是像 CART 那样的常数。拆分可以是多路的，而不仅仅是二进制的，并且拆分是输入的线性组合的概率函数，而不是像 CART 的标准使用那样的单个输入。

—第 329 页，统计学习的要素，2016。

然而，对于给定的预测建模问题，这些差异可能会引发方法上的变化。

例如:

• 考虑将特征空间或问题划分为子任务的自动或通用方法，以帮助拓宽方法的适用性。
• 考虑探索信任最佳专家的组合方法，以及寻求专家间加权共识的方法。

专家和堆叠的混合

该技术的应用不必局限于神经网络模型，一系列标准的机器学习技术可以用于寻找类似的目的。

这样，专家混合方法属于更广泛的集成学习方法类别，该类别还将包括堆叠泛化，称为堆叠。就像专家的混合一样，堆叠训练一组不同的机器学习模型，然后学习一个更高阶的模型来最好地组合预测。

我们可以将这类集成学习方法称为元学习模型。也就是说，模型试图从输出中学习，或者学习如何最好地组合其他低级模型的输出。

元学习是向学习器(分类者)学习的过程。[……]为了诱导元分类器，首先训练基本分类器(第一阶段)，然后训练元分类器(第二阶段)。

—第 82 页，使用集成方法的模式分类，2010。

与专家的混合不同，堆叠模型通常都适合同一训练数据集，例如，没有将任务分解为子任务。此外，与专家的混合不同，组合来自较低层次模型的预测的较高层次模型通常不接收提供给较低层次模型的输入模式，而是将来自每个较低层次模型的预测作为输入。

元学习方法最适合于某些分类器始终正确分类或始终错误分类某些实例的情况。

—第 82 页，使用集成方法的模式分类，2010。

然而，没有理由不能开发出混合叠加和混合专家模型，在给定的预测建模问题上，这两种方法都比单独的方法表现得更好。

例如:

• 考虑将堆叠中的较低层模型视为在训练数据的不同视角上训练的专家。也许这可能涉及使用一种更软的方法将问题分解为子问题，其中不同的数据转换或特征选择方法用于每个模型。
• 考虑在堆叠中向元模型提供输入模式，以使低层模型的权重或贡献以预测的特定上下文为条件。

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

报纸

• 二十年的专家混合，2012 年。

书

• 使用集成方法的模式分类，2010。
• 集成方法，2012。
• 集成机器学习，2012。
• 数据挖掘中的集成方法，2010。
• 统计学习的要素，2016。
• 机器学习:概率视角，2012。
• 用于模式识别的神经网络，1995。
• 深度学习，2016 年。

文章

• 一起学习，维基百科。
• 专家混合，维基百科。

摘要

在本教程中，您发现了专家混合的集成学习方法。

具体来说，您了解到:

• 集成学习的一种直观方法包括将任务划分为子任务，并在每个子任务上培养专家。
• 专家混合是一种集成学习方法，它试图使用专家模型根据子任务明确地解决预测建模问题。
• 分治法与决策树的构建有关，元学习器法与堆叠概括集成法有关。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

如何用 Python 开发多输出回归模型

原文：machinelearningmastery.com/multi-outpu…

最后更新于 2021 年 4 月 27 日

多输出回归是一种回归问题，在给定输入示例的情况下，涉及预测两个或多个数值。

一个例子可能是预测给定输入的坐标，例如预测 x 和 y 值。另一个例子是多步时间序列预测，包括预测给定变量的多个未来时间序列。

许多机器学习算法被设计用于预测单个数值，简称为回归。有些算法本质上支持多输出回归，如线性回归和决策树。还有一些特殊的变通模型可以用来包装和使用那些不支持预测多个输出的算法。

在本教程中，您将发现如何为多输出回归开发机器学习模型。

完成本教程后，您将知道:

• 机器学习中的多输出回归问题。
• 如何开发内在支持多输出回归的机器学习模型？
• 如何开发包装器模型，允许不支持多输出的算法用于多输出回归。

用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

• 2020 年 8 月更新:包装器模型的详细示例。

如何在 Python 中开发多输出回归模型 图片由 a_terracini 提供，保留部分权利。

教程概述

本教程分为五个部分；它们是:

1. 多输出回归问题
   1. 检查 Scikit-学习版本
   2. 多输出回归测试问题
2. 固有多输出回归算法
   1. 多输出回归的线性回归
   2. 多输出回归的 k 近邻
   3. 使用交叉验证评估多输出回归
3. 包装多输出回归算法
4. 直接多输出回归
5. 链式多输出回归

多输出回归问题

回归是指涉及预测数值的预测建模问题。

例如，预测尺寸、重量、数量、销售数量和点击数量是回归问题。通常，给定输入变量，预测单个数值。

一些回归问题需要预测两个或更多的数值。例如，预测 x 和 y 坐标。

这些问题被称为多输出回归或多输出回归。

• 回归:预测给定输入的单个数值输出。
• 多输出回归:给定一个输入，预测两个或多个数值输出。

在多输出回归中，输出通常依赖于输入并且相互依赖。这意味着输出通常不是相互独立的，可能需要一个模型来一起预测两个输出，或者每个输出取决于其他输出。

多步时间序列预测可以被认为是一种多输出回归，其中预测一系列未来值，并且每个预测值取决于该序列中的先前值。

有许多处理多输出回归的策略，我们将在本教程中探讨其中的一些。

检查套件-学习版本

首先，确认您安装了 Sklearn 库的现代版本。

这很重要，因为我们将在本教程中探索的一些模型需要一个现代版本的库。

您可以使用下面的代码示例检查库的版本:

# check Sklearn version
import sklearn
print(sklearn.__version__)

运行该示例将打印库的版本。

在撰写本文时，这大约是 0.22 版本。您需要使用 Sklearn 或更高版本。

0.22.1

多输出回归测试问题

我们可以定义一个测试问题，用来演示不同的建模策略。

我们将使用make _ revolution()函数创建一个多输出回归的测试数据集。我们将生成 1000 个具有 10 个输入特征的示例，其中五个是冗余的，五个是信息丰富的。这个问题需要预测两个数值。

• 问题输入 : 10 个数字变量。
• 问题输出 : 2 个数值变量。

下面的示例生成数据集并总结形状。

# example of multioutput regression test problem
from sklearn.datasets import make_regression
# create datasets
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=2, random_state=1, noise=0.5)
# summarize dataset
print(X.shape, y.shape)

运行该示例会创建数据集，并总结数据集的输入和输出元素的形状以进行建模，从而确认所选的配置。

(1000, 10) (1000, 2)

接下来，我们直接来看建模这个问题。

固有多输出回归算法

一些回归机器学习算法直接支持多输出。

这包括 Sklearn 库中实现的大多数流行的机器学习算法，例如:

• linearregrecession _ 及相关)
• KNeighborsRegressor
• 决策树回归器
• 随机森林回归器(及相关)

让我们看几个具体的例子。

多输出回归的线性回归

以下示例在多输出回归数据集上拟合线性回归模型，然后使用拟合模型进行单次预测。

# linear regression for multioutput regression
from sklearn.datasets import make_regression
from sklearn.linear_model import LinearRegression
# create datasets
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=2, random_state=1, noise=0.5)
# define model
model = LinearRegression()
# fit model
model.fit(X, y)
# make a prediction
row = [0.21947749, 0.32948997, 0.81560036, 0.440956, -0.0606303, -0.29257894, -0.2820059, -0.00290545, 0.96402263, 0.04992249]
yhat = model.predict([row])
# summarize prediction
print(yhat[0])

运行该示例符合模型，然后对一个输入进行预测，确认模型预测了两个所需值。

[-11.73511093  52.78406297]

多输出回归的 k 近邻

以下示例在多输出回归数据集上拟合 k 近邻模型，然后用拟合模型进行单次预测。

# k-nearest neighbors for multioutput regression
from sklearn.datasets import make_regression
from sklearn.neighbors import KNeighborsRegressor
# create datasets
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=2, random_state=1, noise=0.5)
# define model
model = KNeighborsRegressor()
# fit model
model.fit(X, y)
# make a prediction
row = [0.21947749, 0.32948997, 0.81560036, 0.440956, -0.0606303, -0.29257894, -0.2820059, -0.00290545, 0.96402263, 0.04992249]
yhat = model.predict([row])
# summarize prediction
print(yhat[0])

运行该示例符合模型，然后对一个输入进行预测，确认模型预测了两个所需值。

[-11.73511093  52.78406297]

多输出回归的决策树

以下示例在多输出回归数据集上拟合决策树模型，然后使用拟合模型进行单次预测。

# decision tree for multioutput regression
from sklearn.datasets import make_regression
from sklearn.tree import DecisionTreeRegressor
# create datasets
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=2, random_state=1, noise=0.5)
# define model
model = DecisionTreeRegressor()
# fit model
model.fit(X, y)
# make a prediction
row = [0.21947749, 0.32948997, 0.81560036, 0.440956, -0.0606303, -0.29257894, -0.2820059, -0.00290545, 0.96402263, 0.04992249]
yhat = model.predict([row])
# summarize prediction
print(yhat[0])

运行该示例符合模型，然后对一个输入进行预测，确认模型预测了两个所需值。

[49.93137149 64.08484989]

使用交叉验证评估多输出回归

我们可能希望使用 k 倍交叉验证来评估多输出回归。

这可以通过与评估任何其他机器学习模型相同的方式来实现。

我们将使用三次重复的 10 倍交叉验证来拟合和评估测试问题的决策树回归器模型。我们将使用平均绝对误差(MAE)表现指标作为分数。

下面列出了完整的示例。

# evaluate multioutput regression model with k-fold cross-validation
from numpy import absolute
from numpy import mean
from numpy import std
from sklearn.datasets import make_regression
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
# create datasets
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=2, random_state=1, noise=0.5)
# define model
model = DecisionTreeRegressor()
# define the evaluation procedure
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model and collect the scores
n_scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# force the scores to be positive
n_scores = absolute(n_scores)
# summarize performance
print('MAE: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例评估决策树模型在测试问题上的多输出回归的表现。报告了所有折叠和所有重复的平均和标准偏差。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

重要的是，误差是跨两个输出变量报告的，而不是每个输出变量单独的误差分数。

MAE: 51.817 (2.863)

包装多输出回归算法

并非所有回归算法都支持多输出回归。

一个例子是支持向量机，虽然对于回归，它被称为支持向量回归，或支持向量回归。

此算法不支持回归问题的多个输出，并且会产生错误。我们可以用下面列出的例子来证明这一点。

# failure of support vector regression for multioutput regression (causes an error)
from sklearn.datasets import make_regression
from sklearn.svm import LinearSVR
# create datasets
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=2, random_state=1)
# define model
model = LinearSVR()
# fit model
# (THIS WILL CAUSE AN ERROR!)
model.fit(X, y)

运行该示例会报告一条错误消息，指示模型不支持多输出回归。

ValueError: bad input shape (1000, 2)

使用为预测多输出回归的一个值而设计的回归模型的一种变通方法是将多输出回归问题分成多个子问题。

最明显的方法是将一个多输出回归问题分解成多个单输出回归问题。

例如，如果一个多输出回归问题需要预测三个值 y1 、 y2 和 y3 ，给定一个输入 X ，那么这个问题可以分为三个单输出回归问题:

• 问题 1 :给定 X ，预测 y1 。
• 问题 2 :给定 X ，预测 y2 。
• 问题 3 :给定 X ，预测 y3 。

实现这种技术有两种主要方法。

第一种方法是为每个要预测的产值开发一个单独的回归模型。我们可以认为这是一种直接的方法，因为每个目标值都是直接建模的。

第二种方法是第一种方法的扩展，只是模型被组织成一个链。来自第一个模型的预测被作为第二个模型的输入的一部分，并且输出到输入依赖的过程沿着模型链重复。

• 直接多输出:为每个要预测的数值开发一个独立的模型。
• 链式多输出:开发一系列相关模型，以匹配要预测的数值数量。

让我们依次仔细看看这些技术。

直接多输出回归

多输出回归的直接方法包括将回归问题分成一个单独的问题，用于预测每个目标变量。

这假设输出是相互独立的，这可能不是一个正确的假设。然而，这种方法可以对一系列问题提供令人惊讶的有效预测，并且可能值得尝试，至少作为表现基线。

例如，你的问题的输出实际上可能大部分是独立的，如果不是完全独立的话，这个策略可以帮助你找到答案。

这种方法得到了以回归模型为参数的multipoutputruler类的支持。然后，它将为问题中的每个输出创建所提供模型的一个实例。

下面的例子演示了我们如何首先创建一个单输出回归模型，然后使用multi outputerrors类包装回归模型并添加对多输出回归的支持。

...
# define base model
model = LinearSVR()
# define the direct multioutput wrapper model
wrapper = MultiOutputRegressor(model)

我们可以用一个关于我们的综合多输出回归问题的工作示例来演示这个策略。

下面的例子演示了使用重复的 k 倍交叉验证和报告所有折叠和重复的平均绝对误差(MAE)用线性支持向量回归机评估多输出处理器类。

下面列出了完整的示例。

# example of evaluating direct multioutput regression with an SVM model
from numpy import mean
from numpy import std
from numpy import absolute
from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.multioutput import MultiOutputRegressor
from sklearn.svm import LinearSVR
# define dataset
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=2, random_state=1, noise=0.5)
# define base model
model = LinearSVR()
# define the direct multioutput wrapper model
wrapper = MultiOutputRegressor(model)
# define the evaluation procedure
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model and collect the scores
n_scores = cross_val_score(wrapper, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# force the scores to be positive
n_scores = absolute(n_scores)
# summarize performance
print('MAE: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行这个例子报告了直接包装模型的平均值和标准偏差。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到由直接多输出回归策略包装的线性支持向量回归模型实现了大约 0.419 的 MAE。

MAE: 0.419 (0.024)

我们还可以使用直接多输出回归包装器作为最终模型，并对新数据进行预测。

首先，模型适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。

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

# example of making a prediction with the direct multioutput regression model
from sklearn.datasets import make_regression
from sklearn.multioutput import MultiOutputRegressor
from sklearn.svm import LinearSVR
# define dataset
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=2, random_state=1, noise=0.5)
# define base model
model = LinearSVR()
# define the direct multioutput wrapper model
wrapper = MultiOutputRegressor(model)
# fit the model on the whole dataset
wrapper.fit(X, y)
# make a single prediction
row = [0.21947749, 0.32948997, 0.81560036, 0.440956, -0.0606303, -0.29257894, -0.2820059, -0.00290545, 0.96402263, 0.04992249]
yhat = wrapper.predict([row])
# summarize the prediction
print('Predicted: %s' % yhat[0])

运行该示例使直接包装模型适合整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。

Predicted: [50.01932887 64.49432991]

现在我们已经熟悉了直接多输出回归包装器的使用，让我们看看链式方法。

链式多输出回归

将单输出回归模型用于多输出回归的另一种方法是创建模型的线性序列。

序列中的第一个模型使用输入并预测一个输出；第二模型使用来自第一模型的输入和输出来进行预测；第三个模型使用前两个模型的输入和输出进行预测，依此类推。

例如，如果一个多输出回归问题需要预测三个值 y1 、 y2 和 y3 ，给定一个输入 X ，那么这可以被划分为如下三个相关的单输出回归问题:

• 问题 1 :给定 X ，预测 y1 。
• 问题 2 :给定 X 和 yhat1 ，预测 y2 。
• 问题 3 :给定 X，yhat1，yhat2 ，预测 y3 。

这可以使用 Sklearn 库中的returnorchain类来实现。

模型的顺序可以基于数据集中输出的顺序(默认)或通过“顺序参数指定。例如，阶=[0，1] 将首先预测第 0 个输出，然后是第 1 个输出，而阶=[1，0] 将首先预测最后一个输出变量，然后是我们测试问题中的第一个输出变量。

下面的例子演示了我们如何首先创建单输出回归模型，然后使用回归链类包装回归模型并添加对多输出回归的支持。

...
# define base model
model = LinearSVR()
# define the chained multioutput wrapper model
wrapper = RegressorChain(model, order=[0,1])

我们可以用一个关于我们的综合多输出回归问题的工作示例来演示这个策略。

下面的例子演示了使用重复的 k 倍交叉验证和报告所有折叠和重复的平均绝对误差(MAE)用线性支持向量回归机评估回归链类。

下面列出了完整的示例。

# example of evaluating chained multioutput regression with an SVM model
from numpy import mean
from numpy import std
from numpy import absolute
from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.multioutput import RegressorChain
from sklearn.svm import LinearSVR
# define dataset
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=2, random_state=1, noise=0.5)
# define base model
model = LinearSVR()
# define the chained multioutput wrapper model
wrapper = RegressorChain(model)
# define the evaluation procedure
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model and collect the scores
n_scores = cross_val_score(wrapper, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# force the scores to be positive
n_scores = absolute(n_scores)
# summarize performance
print('MAE: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行这个例子报告了链式包装模型的平均值和标准偏差。 请注意，在运行示例时，您可能会看到一个收敛警告，可以安全地忽略。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到由链式多输出回归策略包装的线性支持向量回归模型实现了大约 0.643 的 MAE。

MAE: 0.643 (0.313)

我们还可以使用链式多输出回归包装器作为最终模型，并对新数据进行预测。

首先，模型适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。

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

# example of making a prediction with the chained multioutput regression model
from sklearn.datasets import make_regression
from sklearn.multioutput import RegressorChain
from sklearn.svm import LinearSVR
# define dataset
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=2, random_state=1, noise=0.5)
# define base model
model = LinearSVR()
# define the chained multioutput wrapper model
wrapper = RegressorChain(model)
# fit the model on the whole dataset
wrapper.fit(X, y)
# make a single prediction
row = [0.21947749, 0.32948997, 0.81560036, 0.440956, -0.0606303, -0.29257894, -0.2820059, -0.00290545, 0.96402263, 0.04992249]
yhat = wrapper.predict([row])
# summarize the prediction
print('Predicted: %s' % yhat[0])

运行该示例使链式包装模型适合整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。

Predicted: [50.03206    64.73673318]

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

蜜蜂

• 多类和多标签算法，API 。
• sklearn . datasets . make _ revolution API。
• 硬化。多倍体。多倍体回归 API 。
• 硬化。多倍体。回归 API 。

摘要

在本教程中，您发现了如何为多输出回归开发机器学习模型。

具体来说，您了解到:

• 机器学习中的多输出回归问题。
• 如何开发内在支持多输出回归的机器学习模型？
• 如何开发包装器模型，允许不支持多输出的算法用于多输出回归。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

多模型机器学习入门

原文：machinelearningmastery.com/multiple-mo…

最后更新于 2021 年 10 月 22 日

集成学习方法包括组合来自多个贡献模型的预测。

然而，并非所有利用多机器学习模型的技术都是集成学习算法。

将预测问题分成子问题是很常见的。例如，一些问题自然地细分为独立但相关的子问题，并且可以为每个子问题准备一个机器学习模型。不太清楚这些是否代表集成学习的例子，尽管我们可能会将这些方法与集成区分开来，因为有贡献的集成成员无法为整体预测问题提供解决方案(无论多么弱)。

在本教程中，您将发现机器学习的多模型技术及其与集成学习的关系。

完成本教程后，您将知道:

• 多模型机器学习是指以某种方式使用多个模型的技术，类似于集成学习。
• 使用多模型进行多类分类和多输出回归不同于集成，因为没有贡献成员可以解决问题。
• 专家混合可能被认为是一种真正的集成方法，尽管混合机器学习模型可能不是集成学习方法。

用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

多模型机器学习简介 图片由托拜厄斯·贝格曼提供，版权所有。

教程概述

本教程分为五个部分；它们是:

1. 多模型技术
2. 多类分类的多模型
3. 多输出回归的多重模型
4. 多专家模型
5. 由多个模型构建的混血儿

多模型技术

集成学习涉及结合两个或更多模型的预测的方法。

如果模型具有两个属性，我们可以将它描述为集成学习技术，例如:

• 包括两个或多个模型。
• 预测结合在一起。

我们可能还会建议，集合模型的目标是提高对任何贡献成员的预测。尽管较小的目标可能是提高模型的稳定性，例如减少预测中的方差或预测误差。

然而，有包含集成学习方法元素的模型和模型体系结构，但是不清楚它们是否可以被认为是集成学习。

例如，我们可以将集成学习技术定义为由两个或多个模型组成。问题是，可能有技术有两个以上的模型，但没有结合他们的预测。或者，他们可能会以意想不到的方式组合他们的预测。

有一些方法试图利用多个学习器，但从严格意义上来说，它们不能被认为是集成组合方法。

—第 89 页，集合方法，2012。

由于缺乏更好的名称，我们将这些称为“多模型技术，以帮助将它们与集成学习方法区分开来。然而，正如我们将看到的，区分这两种机器学习方法的界限并不那么清楚。

• 多模型技术:由多个模型组成的机器学习算法，结合了多种技术，但可能不被视为集成学习。

因此，重要的是回顾和探索位于集成学习边界的多模型技术，以便更好地理解集成学习，并利用可能改进我们创建的集成学习模型的相关思想。

存在预测建模问题，其中问题本身的结构可能建议使用多个模型。

通常，这些问题可以自然地分为子问题。这并不意味着将问题分成子问题是给定示例的最佳解决方案；这只是意味着问题自然会分解。

两个例子是多类分类和多输出回归。

多类分类的多模型

分类问题包括给输入的例子分配一个类别标签。

二分类任务是那些有两个类的任务。每个示例都有一个决定，要么将其分配给一个类，要么分配给另一个类。如果使用概率建模，则预测该示例属于一类的单一概率，其中逆概率是第二类的概率，称为二项式概率分布。

两个以上的班级会带来挑战。为两个类设计的技术可以扩展到多个类，有时，这很简单。

• 多类分类:在给定输入示例的多个类标签中指定一个。

或者，问题可以自然地划分为多个二进制分类任务。

有很多方法可以做到这一点。

例如，这些类可以被分成多个一对一与静态预测问题。然后，模型可以适合每个子问题，通常每个模型使用相同的算法类型。当新示例需要预测时，响应比其他模型更强的模型可以指定预测。这被称为一对多(OvR)或一对多(OvA)方法。

• OvR :将多类分类拆分为每类一个二分类问题的技术。

多类分类问题可以分为多对类，每对类上适合一个模型。同样，新示例的预测可以从响应更强的模型中选择。这被称为一对一(OvO)。

• OvR :将多类分类拆分为每对类一个二分类问题的技术。

有关一对一和一对一分类的更多信息，请参见教程:

• 如何使用一比一休息和一比一进行多类分类

这种将多类分类问题划分为多个二进制分类问题的方法可以推广。对于任意长度的类，每个类都可以映射到唯一的二进制字符串。然后，一个分类器可以适合预测位串中的每个位，允许使用任意数量的分类器。

然后，该位串可以被映射到具有最接近匹配的类标签。额外的比特起到纠错码的作用，在某些情况下比更简单的 OvR 和 OvO 方法提高了该方法的表现。这种方法被称为纠错输出码，ECOC。

• ECOC :将多类分类拆分成任意数量的二进制分类问题的技术。

有关这种方法的更多信息，请参见教程:

• 机器学习的纠错输出码(ECOC)

在每种情况下，都使用多个模型，就像一个集合一样。预测也是结合在一起的，就像一个集合方法，尽管是赢家通吃的方法，而不是投票或加权总和。从技术上讲，这是一种组合方法，但与大多数典型的集成学习方法不同。

与集成学习不同，这些技术旨在探索预测问题的自然分解，并利用可能不容易扩展到多个类别的二进制分类问题。

而集成学习不关心开发新的功能，通常只关注于改进贡献模型的预测表现。使用像 OvR、OvR 和 ECOC 这样的技术，根据定义，贡献模型不能用来孤立地解决预测问题。

多输出回归的多重模型

回归问题包括预测给定输入示例的数值。

通常，预测单个输出值。然而，存在回归问题，其中必须为每个输入示例预测多个数值。这些问题被称为多输出回归问题。

• 多输出回归:给定一个输入，预测两个或多个数值输出。

可以开发模型来一次预测所有目标值，尽管多输出回归问题是可以自然划分为子问题的问题的另一个例子。

与上一节中的二进制分类一样，大多数回归预测建模技术都是为了预测单个值而设计的。预测多个值可能会带来问题，并且需要修改技术。有些技术无法针对多个值进行合理修改。

一种方法是开发单独的回归模型来预测多输出回归问题中的每个目标值。通常，每个模型使用相同的算法类型。例如，具有三个目标值的多输出回归将涉及拟合三个模型，每个目标一个模型。

当需要预测时，相同的输入模式被提供给每个模型，并且每个模型的特定目标被预测并且一起表示该方法的矢量输出。

• 多输出回归:多输出回归问题中每个目标使用一个回归模型的技术。

另一个相关的方法是创建回归模型的顺序链。不同之处在于，第一模型的输出预测第一输出目标值，但是该值被用作链中第二模型的输入的一部分，以便预测第二输出目标值，以此类推。

这样，链在回归模型之间引入了线性相关性，允许链中后面模型的输出以链中前面模型的输出为条件。

• 回归链:一种技术，其中使用回归模型的顺序链来预测多输出回归问题中的每个目标，链中后面的一个模型使用链中前面模型预测的值。

有关多输出回归的更多信息，请参见教程:

• 如何用 Python 开发多输出回归模型

在每种情况下，都使用多元回归模型，就像一个集合。

与集成的一个可能区别是，每个模型所做的预测没有直接组合。然而，我们可以扩展结合预测的“T0”的定义来涵盖这种方法。例如，在多输出回归模型的情况下，预测是串联的，而在链式回归中是通过条件方法间接连接的。

与集成学习方法的关键区别在于，没有贡献的集成成员可以单独解决预测问题。只有结合所有成员的预测才能找到解决方案。

多专家模型

到目前为止，我们已经着眼于根据预测的结构将问题分成子任务。

还有一些问题可以根据输入数据自然地划分为子问题。这可能就像输入特征空间的划分一样简单，也可能是更复杂的事情，比如将图像分为前景和背景，并为每一个都开发一个模型。

神经网络领域对此的一种更普遍的方法被称为专家混合(MoE)。

该方法包括首先将学习任务划分为子任务，为每个子任务开发专家模型，使用选通模型来决定或学习为每个示例使用哪个专家，池化专家的输出，并将模型选通在一起进行最终预测。

• MoE :为每个子任务开发一个专家模型的技术，在对具体的例子进行预测时，学习对每个专家的信任程度。

有关专家混合的更多信息，请参见教程:

• 混合专家集成的温和介绍

MoE 的两个方面使这种方法独一无二。第一种是输入特征空间的显式划分，第二种是使用门控网络或门控模型，学习在每种情况下信任哪个专家，例如每个输入案例。

与前面的将目标划分为子问题的多类分类和多输出回归的例子不同，混合专家模型中的贡献成员可以解决整个问题，至少是部分或一定程度上。虽然专家可能不适合特定的输入，但它仍然可以用于对其专业领域之外的事情进行预测。

此外，与那些先前审查的方法不同，专家的混合还使用加权和来组合所有贡献成员的预测，尽管是通过门控网络来测量的。

因此，它更类似于更熟悉的集成学习技术，例如堆叠泛化，称为堆叠。

由多个模型构建的混血儿

另一种类型的机器学习涉及多个模型的使用，并且与集成学习松散相关，这就是混合模型。

混合模型是明确组合两个或更多模型的模型。因此，混合模型的定义可能是模糊的。

• 混合模型:以某种方式将两个或多个不同的机器学习模型结合在一起的技术。

例如，学习如何将输入模式压缩到瓶颈层的自动编码器神经网络，其输出然后被馈送到另一个模型，例如支持向量机，将被认为是混合机器学习模型。

这个例子有两个机器学习模型，一个神经网络和一个支持向量机。碰巧的是，模型被一个接一个地线性堆叠成一个管道，管道中的最后一个模型进行预测。

考虑一种集成学习方法，该方法具有不同类型的多个贡献集成成员(例如，逻辑回归和支持向量机)，并使用投票来平均它们的预测。根据更广泛的定义，这种集成也可以被认为是一种混合机器学习模型。

也许集成学习和混合机器学习的关键区别在于混合模型需要使用不同类型的模型。而在集成学习中，集成的贡献成员可以是任何类型。

此外，混合机器学习更有可能将一个或多个模型移植到另一个基础模型上，这与我们在集成学习中所做的拟合单独的模型并组合它们的预测非常不同。

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

相关教程

• 机器学习的离散概率分布
• 如何使用一比一休息和一比一进行多类分类
• 机器学习的纠错输出码(ECOC)
• 如何用 Python 开发多输出回归模型
• 混合专家集成的温和介绍
• 机器学习建模管道的温和介绍

书

• 使用集成方法的模式分类，2010。
• 集成方法，2012。
• 集成机器学习，2012。

摘要

在本教程中，您发现了机器学习的多模型技术及其与集成学习的关系。

具体来说，您了解到:

• 多模型机器学习是指以某种方式使用多个模型的技术，类似于集成学习。
• 使用多模型进行多类分类和多输出回归不同于集成，因为没有贡献成员可以解决问题。
• 专家混合可能被认为是一种真正的集成方法，尽管混合机器学习模型可能不是集成学习方法。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

Python 中的多元自适应回归样条（MARS）

原文：machinelearningmastery.com/multivariat…

最后更新于 2021 年 4 月 27 日

多元自适应回归样条，或 MARS ，是一种用于复杂非线性回归问题的算法。

该算法包括找到一组简单的线性函数，这些函数合计起来产生最佳的预测表现。通过这种方式，MARS 是一种简单线性函数的集成，并且可以在具有许多输入变量和复杂非线性关系的挑战性回归问题上获得良好的表现。

在本教程中，您将发现如何在 Python 中开发多元自适应回归样条模型。

完成本教程后，您将知道:

• 多元非线性回归预测建模问题的 MARS 算法。
• 如何使用 py-earth API 开发与 Sklearn 兼容的 MARS 模型？
• 如何用 MARS 模型对回归预测建模问题进行评估和预测。

用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

Python 中的多元自适应回归样条(MARS) 图片由 Sei F 提供，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 多元自适应回归样条
2. 火星 Python API
3. 回归的火星工作实例

多元自适应回归样条

多元自适应回归样条，简称 MARS，是一种为多元非线性回归问题设计的算法。

回归问题是模型必须预测数值的问题。多变量意味着输入变量不止一个(通常是几十个)，非线性意味着输入变量和目标变量之间的关系不是线性的，意味着不能用直线来描述(例如，它是弯曲的或弯曲的)。

MARS 是回归的自适应过程，非常适合高维问题(即大量输入)。它可以看作是逐步线性回归的推广

—第 321 页，统计学习的要素，2016。

MARS 算法包括发现一组简单的分段线性函数来表征数据，并将其集合起来进行预测。在某种意义上，模型是线性函数的集合。

A 分段线性函数是由较小的函数组成的函数。在这种情况下，它是直接输出 0 或输入值的函数。

一个输入变量的“右功能”包括为该变量选择一个特定值，并为低于该值的所有值输出一个 0，为高于所选值的所有值输出该值。

• f(x) = x 如果 x >值，则为 0

或者相反，可以使用“左功能”，其中小于所选值的值直接输出，大于所选值的值输出零。

• f(x) = x 如果 x

这被称为铰链函数，其中选择的值或分割点是函数的“结”。它也被称为神经网络中的校正线性函数。

这些函数也被称为“样条线”，因此得名该算法。

每个函数都是分段线性的，在值 t 处有一个结。在……的术语中，这些是线性样条。

—第 322 页，统计学习的要素，2016。

MARS 算法生成许多这样的函数，称为一个或多个输入变量的基函数。

然后，从这些具有目标变量的基函数的输出中学习线性回归模型。这意味着每个基函数的输出由一个系数加权。通过对模型中所有基函数的加权输出求和来进行预测。

MARS 算法的关键是如何选择基函数。这包括两个步骤:生长或生成阶段称为前向阶段，修剪或精炼阶段称为后向阶段。

• 前向阶段:生成模型的候选基函数。
• 后向阶段:从模型中删除基础函数。

前一阶段包括生成基函数并添加到模型中。像决策树一样，训练数据集中每个输入变量的每个值都被视为基函数的候选值。

切割点是如何确定的？通过创建具有候选特征的线性回归模型，将每个预测器的每个数据点评估为候选切割点，并计算相应的模型误差。

—第 146 页，应用预测建模，2013 年。

对于相同分割点的分段线性函数的左右版本，函数总是成对添加。只有当生成的一对函数减少了整个模型产生的误差时，才会将其添加到模型中。

向后阶段包括选择要从模型中删除的函数，一次一个。只有当某项功能不会对表现产生影响(中性)或提升预测表现时，才会从模型中删除该功能。

一旦创建了完整的特征集，该算法将依次移除对模型方程没有显著贡献的单个特征。这个“修剪”过程评估每个预测变量，并通过将其包含在模型中来估计误差率降低了多少。

—第 148 页，应用预测建模，2013 年。

使用训练数据集的交叉验证来评估后向阶段中模型表现的变化，简称为广义交叉验证或 GCV。因此，可以估计每个分段线性模型对模型表现的影响。

模型使用的函数数量是自动确定的，因为当没有进一步的改进时，修剪过程将停止。

唯一需要考虑的两个关键超参数是要生成的候选函数的总数(通常设置为非常大的数字)和要生成的函数的程度。

……有两个与 MARS 模型相关的调优参数:添加到模型中的特性的程度和保留的术语数量。后一个参数可以使用默认修剪过程(使用 GCV)自动确定，由用户设置或使用外部重采样技术确定。

—第 149 页，应用预测建模，2013 年。

度是每个分段线性函数考虑的输入变量的数量。默认情况下，该值设置为 1，但可以设置为更大的值，以允许模型捕获输入变量之间的复杂交互。程度通常保持较小，以限制模型的计算复杂性(内存和执行时间)。

MARS 算法的一个好处是，它只使用提升模型表现的输入变量。与装袋和随机森林集成算法非常相似，MARS 实现了自动类型的特征选择。

……模型自动进行特征选择；模型方程独立于不涉及任何最终模型特征的预测变量。这一点不能低估。

—第 149 页，应用预测建模，2013 年。

现在我们已经熟悉了 MARS 算法，让我们看看如何用 Python 开发 MARS 模型。

火星 Python API

Sklearn 库中没有提供 MARS 算法；相反，必须使用第三方库。

MARS 由 py-earth Python 库提供。

“地球”是“火星”(行星)上的一个玩法，也是 R 中提供 Mars 算法的包的名字。

py-earth Python 包是以 R 版本命名的 MARS 的 Python 实现，提供了与 Sklearn 机器学习库的完全可比性。

第一步是安装 py-earth 库。我建议使用 pip 包管理器，从命令行使用以下命令:

sudo pip install sklearn-contrib-py-earth

安装后，我们可以加载库，并在 Python 脚本中打印版本，以确认它安装正确。

# check pyearth version
import pyearth
# display version
print(pyearth.__version__)

运行脚本将加载 py-earth 库并打印库版本号。

您的版本号应该相同或更高。

0.1.0

通过创建地球类的实例，可以使用默认模型超参数创建火星模型。

...
# define the model
model = Earth()

一旦创建，模型就可以直接拟合训练数据。

...
# fit the model on training dataset
model.fit(X, y)

默认情况下，您可能不需要设置任何算法超参数。

该算法自动发现要使用的基函数的数量和类型。

基函数的最大数量由“ max_terms ”参数配置，并设置为与输入变量数量成比例的大数，上限为 400。

分段线性函数的度，即每个基函数中考虑的输入变量的数量，由“ max_degree 参数控制，默认为 1。

一旦拟合，该模型可用于对新数据进行预测。

...
Xnew = ...
# make a prediction
yhat = model.predict(Xnew)

通过调用 summary() 函数，可以创建拟合模型的概要。

...
# print a summary of the fit model
print(model.summary())

摘要返回模型中使用的基函数列表，以及在训练数据集上通过广义交叉验证(GCV)估计的模型的估计表现。

下面提供了一个总结输出的例子，我们可以看到该模型有 19 个基函数，估计的均方误差约为 25。

Earth Model
--------------------------------------
Basis Function   Pruned  Coefficient
--------------------------------------
(Intercept)      No      313.89
h(x4-1.88408)    No      98.0124
h(1.88408-x4)    No      -99.2544
h(x17-1.82851)   No      99.7349
h(1.82851-x17)   No      -99.9265
x14              No      96.7872
x15              No      85.4874
h(x6-1.10441)    No      76.4345
h(1.10441-x6)    No      -76.5954
x9               No      76.5097
h(x3+2.41424)    No      73.9003
h(-2.41424-x3)   No      -73.2001
x0               No      71.7429
x2               No      71.297
x19              No      67.6034
h(x11-0.575217)  No      66.0381
h(0.575217-x11)  No      -65.9314
x18              No      62.1124
x12              No      38.8801
--------------------------------------
MSE: 25.5896, GCV: 25.8266, RSQ: 0.9997, GRSQ: 0.9997

现在我们已经熟悉了使用 py-earth API 开发 MARS 模型，让我们来看一个成功的例子。

回归的火星工作实例

在本节中，我们将看一个为回归预测建模问题评估和使用 MARS 模型的工作示例。

首先，我们必须定义一个回归数据集。

我们将使用make _ revolution()函数创建一个包含 20 个特征(列)和 10，000 个示例(行)的合成回归问题。下面的示例创建并总结了合成数据集的形状。

# define a synthetic regression dataset
from sklearn.datasets import make_regression
# define dataset
X, y = make_regression(n_samples=10000, n_features=20, n_informative=15, noise=0.5, random_state=7)
# summarize the dataset
print(X.shape, y.shape)

运行该示例会创建数据集并汇总行数和列数，与我们的预期相符。

(10000, 20) (10000,)

接下来，我们可以在数据集上评估一个 MARS 模型。

我们将使用默认的超参数来定义模型。

...
# define the model
model = Earth()

我们将使用重复的 k 倍交叉验证来评估模型，这在评估回归模型时是一个很好的实践。

在这种情况下，我们将使用三次重复和 10 次折叠。

...
# define the evaluation procedure
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)

我们将使用平均绝对误差(简称 MAE)来评估模型表现。

Sklearn API 将使 MAE 分数为负，以便将其最大化，这意味着分数范围将从负无穷大(最差)到 0(最佳)。

...
# evaluate the model and collect results
n_scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)

最后，我们将报告模型的表现，作为所有重复和交叉验证折叠的平均 MAE 分数。

...
# report performance
print('MAE: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

将这些联系在一起，下面列出了在回归数据集上评估 MARS 模型的完整示例。

# evaluate multivariate adaptive regression splines 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 pyearth import Earth
# define dataset
X, y = make_regression(n_samples=10000, n_features=20, n_informative=15, noise=0.5, random_state=7)
# define the model
model = Earth()
# define the evaluation procedure
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model and collect results
n_scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# report performance
print('MAE: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例评估 MARS 模型的表现，并报告 MAE 分数的平均值和标准偏差。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到 MARS 算法在合成回归数据集上实现了大约 4.0(忽略符号)的平均 MAE。

MAE: -4.041 (0.085)

我们可能希望使用 MARS 作为我们的最终模型，并使用它对新数据进行预测。

这需要首先在所有可用数据上定义和拟合模型。

...
# define the model
model = Earth()
# fit the model on the whole dataset
model.fit(X, y)

然后我们可以调用 predict() 函数，传入新的输入数据，以便进行预测。

...
# make a prediction for a single row of data
yhat = model.predict([row])

下面列出了拟合 MARS 最终模型并对单行新数据进行预测的完整示例。

# make a prediction with multivariate adaptive regression splines for regression
from sklearn.datasets import make_regression
from pyearth import Earth
# define dataset
X, y = make_regression(n_samples=10000, n_features=20, n_informative=15, noise=0.5, random_state=7)
# define the model
model = Earth()
# fit the model on the whole dataset
model.fit(X, y)
# define a single row of data
row = [-0.6305395, -0.1381388, -1.23954844, 0.32992515, -0.36612979, 0.74962718, 0.21532504, 0.90983424, -0.60309177, -1.46455027, -0.06788126, -0.30329357, -0.60350541, 0.7369983, 0.21774321, -1.2365456, 0.69159078, -0.16074843, -1.39313206, 1.16044301]
# make a prediction for a single row of data
yhat = model.predict([row])
# summarize the prediction
print('Prediction: %d' % yhat[0])

运行该示例使 MARS 模型适用于所有可用数据，然后进行单一回归预测。

Prediction: -393

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

报纸

• 多元自适应回归样条，1991。
• 多元自适应回归样条导论，1995。

书

• 第 9.4 节 MARS:多元自适应回归样条，统计学习的要素，2016。
• 第 7.2 节多元自适应回归样条，应用预测建模，2013。

蜜蜂

• py-earth 项目，GitHub 。
• Py-地球文件。
• sklearn . datasets . make _ revolution API。

文章

• 多元自适应回归样条，维基百科。
• 分段，维基百科。

摘要

在本教程中，您发现了如何在 Python 中开发多元自适应回归样条模型。

具体来说，您了解到:

• 多元非线性回归预测建模问题的 MARS 算法。
• 如何使用 py-earth API 开发与 Sklearn 兼容的 MARS 模型？
• 如何用 MARS 模型对回归预测建模问题进行评估和预测。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。