如何在 Python 中开发超级学习器集成

作者： Jason Brownlee 发布于 2021年8月24日分类：集成学习 159 条评论

为预测建模问题选择机器学习算法涉及使用 K 折交叉验证评估许多不同的模型和模型配置。

超级学习器（super learner）是一种集成机器学习算法，它结合了您可能为预测建模问题研究的所有模型和模型配置，并使用它们进行预测，其效果与您可能研究的任何单个模型一样好或更好。

超级学习器算法是K 折交叉验证中堆叠泛化（称为堆叠或混合）的一种应用，其中所有模型都使用相同的数据 K 折划分，并且元模型（meta-model）根据每个模型的折外预测（out-of-fold predictions）进行拟合。

在本教程中，您将了解超级学习器集成机器学习算法。

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

超级学习器是利用 K 折交叉验证中的折外预测进行堆叠泛化的应用。
超级学习器集成算法在 Python 中使用 scikit-learn 模型实现起来非常简单。
ML-Ensemble (mlens) 库提供了一个便捷的实现，只需几行代码即可拟合和使用超级学习器。

通过我的新书《使用 Python 的集成学习算法》启动您的项目，其中包括分步教程和所有示例的 Python 源代码文件。

让我们开始吧。

**2020年1月更新**：已针对 scikit-learn v0.22 API 的变更进行更新。

How to Develop Super Learner Ensembles in Python

如何在 Python 中开发超级学习器集成
图片由Mark Gunn拍摄，部分权利保留。

教程概述

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

什么是超级学习器？
使用 scikit-learn 手动开发超级学习器
使用 ML-Ensemble 库的超级学习器

什么是超级学习器？

对于一个预测建模问题，有数百种模型可供选择；哪种是最好的？

然后，在选择模型之后，如何针对您的特定数据集进行最佳配置？

这些都是应用机器学习中的开放性问题。目前我们最好的答案是使用经验实验来测试和发现最适合您数据集的方法。

实际上，事先通常不可能知道哪种学习器在给定的预测问题和数据集上表现最好。

— 《超级学习器》，2007。

这涉及选择许多可能适合您的回归或分类问题的不同算法，并使用重采样技术（例如K 折交叉验证）评估它们在您的数据集上的性能。

然后选择根据 K 折交叉验证在您的数据集上表现最好的算法，在所有可用数据上进行拟合，然后您可以开始使用它进行预测。

还有另一种方法。

考虑您已经在您的数据集上拟合了许多不同的算法，并且某些算法已使用不同的配置多次进行评估。您可能遇到数十或数百个不同的问题模型。为什么不使用所有这些模型，而不是从该组中选择最好的模型呢？

这就是所谓“超级学习器”集成算法背后的直觉。

超级学习器算法首先预定义数据的 K 折划分，然后在相同的数据划分上评估所有不同的算法和算法配置。然后保留所有折外预测，并用于训练一个算法，该算法学习如何最佳地组合这些预测。

算法可能在使用的协变量子集、基函数、损失函数、搜索算法以及调优参数范围等方面有所不同。

— 《预测中的超级学习器》，2010。

此模型的结果应不低于 K 折交叉验证期间评估的最佳性能模型，并且有可能优于任何单个模型。

超级学习器算法由伯克利的Mark van der Laan、Eric Polley和Alan Hubbard在他们2007年题为“《超级学习器》”的论文中提出。该论文发表在生物学期刊上，可能未被更广泛的机器学习社区所知。

超级学习器技术是“堆叠泛化”（简称“堆叠”）这种通用方法的一个例子，在应用机器学习中被称为混合，因为通常使用线性模型作为元模型。

超级学习器与神经网络上下文中引入的堆叠算法相关……

— 《预测中的超级学习器》，2010。

有关堆叠的更多信息，请参阅以下帖子

我们可以将“超级学习器”视为专门针对 K 折交叉验证的一种特定堆叠配置。

我有时会将这种混合集成称为交叉验证集成。

该过程可总结如下：

1. 选择训练数据集的 K 折划分。
2. 选择 m 个基本模型或模型配置。
3. 对于每个基本模型：
- a. 使用 K 折交叉验证进行评估。
- b. 存储所有折外预测。
- c. 在完整训练数据集上拟合模型并存储。
4. 根据折外预测拟合一个元模型。
5. 在保留数据集上评估模型或使用模型进行预测。

下面的图片取自原始论文，总结了此数据流。

Diagram Showing the Data Flow of the Super Learner Algorithm

超级学习器算法的数据流图
摘自《超级学习器》。

让我们仔细看看您可能在此过程中遇到的一些常见问题。

问：元模型的输入和输出是什么？

元模型将基本模型的预测作为输入，并预测训练数据集的目标作为输出。

输入：来自基本模型的预测。
输出：训练数据集的预测。

例如，如果我们有 50 个基本模型，那么一个输入样本将是一个包含 50 个值的向量，向量中的每个值代表一个基本模型对训练数据集中一个样本的预测。

如果训练数据集中有 1000 个示例（行）和 50 个模型，那么元模型的输入数据将是 1000 行和 50 列。

问：元模型不会过度拟合训练数据吗？

可能不会。

这正是超级学习器，以及通常堆叠泛化过程的诀窍。

元模型的输入是折外（样本外）预测。总体而言，一个模型的折外预测代表了该模型在对训练期间未见过的数据进行预测时的技能或能力。

通过在其他模型的样本外预测上训练元模型，元模型学习如何纠正每个模型的样本外预测，并学习如何最佳地组合来自多个模型的样本外预测；实际上，它同时完成了这两项任务。

重要的是，为了了解元模型的真实能力，必须在新的样本外数据上对其进行评估。也就是说，未用于训练基本模型的数据。

问：这适用于回归和分类吗？

是的，论文中描述了它用于回归（预测数值）。

它也同样适用于分类（预测类别标签），尽管最好预测概率，以便在组合预测时为元模型提供更多的粒度。

问：为什么我们在整个训练数据集上拟合每个基本模型？

每个基本模型都在整个训练数据集上进行拟合，以便该模型稍后可以用于对训练期间未见过的新示例进行预测。

在超级学习器需要预测之前，严格来说不需要此步骤。

问：我们如何进行预测？

为了对新样本（数据行）进行预测，首先将数据行作为输入提供给每个基本模型，以从每个模型生成预测。

然后将来自基本模型的预测连接成一个向量，并作为输入提供给元模型。元模型然后对数据行进行最终预测。

我们可以将此过程总结如下：

1. 取一个训练期间模型未见过的样本。
2. 对于每个基本模型：
- a. 根据样本进行预测。
- b. 存储预测。
3. 将子模型的预测连接成一个单一向量。
4. 将向量作为输入提供给元模型，以进行最终预测。

现在我们已经熟悉了超级学习器算法，让我们看一个实际的例子。

想开始学习集成学习吗？

立即参加我为期7天的免费电子邮件速成课程（附示例代码）。

点击注册，同时获得该课程的免费PDF电子书版本。

使用 scikit-learn 手动开发超级学习器

超级学习器算法相对容易在 scikit-learn Python 机器学习库之上实现。

在本节中，我们将开发一个用于回归和分类的超级学习器示例，您可以将其应用于您自己的问题。

用于回归的超级学习器

我们将使用 make_regression() 测试问题，生成 1,000 个示例（行），包含 100 个特征（列）。这是一个简单的回归问题，输入和输出之间存在线性关系，并添加了噪声。

我们将划分数据，其中 50% 用于训练模型，50% 留作评估最终的超级模型和基本模型。

...
# create the inputs and outputs
X, y = make_regression(n_samples=1000, n_features=100, noise=0.5)
# split
X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)
print('Train', X.shape, y.shape, 'Test', X_val.shape, y_val.shape)

...

# 创建输入和输出

X, y = make_regression(n_samples=1000, n_features=100, noise=0.5)

# 划分

X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)

print('训练集', X.shape, y.shape, '测试集', X_val.shape, y_val.shape)

接下来，我们将定义一系列不同的回归模型。

在这种情况下，我们将使用九种不同的算法，配置适中。您可以使用任何您喜欢的模型或模型配置。

下面的 get_models() 函数定义了所有模型并将其作为列表返回。

# create a list of base-models
def get_models():
	models = list()
	models.append(LinearRegression())
	models.append(ElasticNet())
	models.append(SVR(gamma='scale'))
	models.append(DecisionTreeRegressor())
	models.append(KNeighborsRegressor())
	models.append(AdaBoostRegressor())
	models.append(BaggingRegressor(n_estimators=10))
	models.append(RandomForestRegressor(n_estimators=10))
	models.append(ExtraTreesRegressor(n_estimators=10))
	return models

# 创建基本模型列表

定义获取_模型():

models = list()

models.append(LinearRegression())

models.append(ElasticNet())

models.append(SVR(gamma='scale'))

models.append(DecisionTreeRegressor())

models.append(KNeighborsRegressor())

models.append(AdaBoostRegressor())

models.append(BaggingRegressor(n_estimators=10))

models.append(RandomForestRegressor(n_estimators=10))

models.append(ExtraTreesRegressor(n_estimators=10))

返回 models

接下来，我们将使用 K 折交叉验证来生成折外预测，这些预测将用作训练元模型或“超级学习器”的数据集。

这包括首先将数据划分为 K 个折；我们将使用 10 个折。对于每个折，我们将在划分的训练部分上拟合模型，并在划分的测试部分上进行折外预测。对每个模型重复此操作，并存储所有折外预测。

每个折外预测将是元模型输入的一列。我们将从每个算法中收集一列数据，用于数据的一个折叠，水平堆叠行。然后对于我们收集的所有列组，我们将这些行垂直堆叠成一个长数据集，包含 500 行和 9 列。

下面的 get_out_of_fold_predictions() 函数针对给定的测试数据集和模型列表执行此操作；它将返回训练元模型所需的输入和输出数据集。

# collect out of fold predictions form k-fold cross validation
def get_out_of_fold_predictions(X, y, models):
	meta_X, meta_y = list(), list()
	# define split of data
	kfold = KFold(n_splits=10, shuffle=True)
	# enumerate splits
	for train_ix, test_ix in kfold.split(X):
		fold_yhats = list()
		# get data
		train_X, test_X = X[train_ix], X[test_ix]
		train_y, test_y = y[train_ix], y[test_ix]
		meta_y.extend(test_y)
		# fit and make predictions with each sub-model
		for model in models:
			model.fit(train_X, train_y)
			yhat = model.predict(test_X)
			# store columns
			fold_yhats.append(yhat.reshape(len(yhat),1))
		# store fold yhats as columns
		meta_X.append(hstack(fold_yhats))
	return vstack(meta_X), asarray(meta_y)

# 从 K 折交叉验证中收集折外预测

def get_out_of_fold_predictions(X, y, models):

meta_X, meta_y = list(), list()

# 定义数据划分

kfold = KFold(n_splits=10, shuffle=True)

# 枚举划分

for train_ix, test_ix in kfold.split(X):

fold_yhats = list()

# 获取数据

train_X, test_X = X[train_ix], X[test_ix]

train_y, test_y = y[train_ix], y[test_ix]

meta_y.extend(test_y)

# 拟合并使用每个子模型进行预测

for model in models:

model.fit(train_X, train_y)

yhat = model.predict(test_X)

# 存储列

fold_yhats.append(yhat.reshape(len(yhat),1))

# 将折叠预测存储为列

meta_X.append(hstack(fold_yhats))

return vstack(meta_X), asarray(meta_y)

然后我们可以调用该函数来获取模型，并调用该函数来准备元模型数据集。

...
# get models
models = get_models()
# get out of fold predictions
meta_X, meta_y = get_out_of_fold_predictions(X, y, models)
print('Meta ', meta_X.shape, meta_y.shape)

...

# 获取模型

模型 = 获取_模型()

# 获取折外预测

meta_X, meta_y = get_out_of_fold_predictions(X, y, models)

print('元模型 ', meta_X.shape, meta_y.shape)

接下来，我们可以在整个训练数据集上拟合所有基本模型。

# fit all base models on the training dataset
def fit_base_models(X, y, models):
	for model in models:
		model.fit(X, y)

# 在训练数据集上拟合所有基本模型

def fit_base_models(X, y, models):

for model in models:

model.fit(X, y)

然后，我们可以在准备好的数据集上拟合元模型。

在这种情况下，我们将使用线性回归模型作为元模型，就像原始论文中使用的那样。

# fit a meta model
def fit_meta_model(X, y):
	model = LinearRegression()
	model.fit(X, y)
	return model

# 拟合元模型

def fit_meta_model(X, y):

model = LinearRegression()

model.fit(X, y)

return model

接下来，我们可以在保留数据集上评估基本模型。

# evaluate a list of models on a dataset
def evaluate_models(X, y, models):
	for model in models:
		yhat = model.predict(X)
		mse = mean_squared_error(y, yhat)
		print('%s: RMSE %.3f' % (model.__class__.__name__, sqrt(mse)))

# 在数据集上评估模型列表

def evaluate_models(X, y, models):

for model in models:

yhat = model.predict(X)

mse = mean_squared_error(y, yhat)

print('%s: RMSE %.3f' % (model.__class__.__name__, sqrt(mse)))

最后，使用超级学习器（基本模型和元模型）对保留数据集进行预测，并评估该方法的性能。

下面的 super_learner_predictions() 函数将使用元模型对新数据进行预测。

# make predictions with stacked model
def super_learner_predictions(X, models, meta_model):
	meta_X = list()
	for model in models:
		yhat = model.predict(X)
		meta_X.append(yhat.reshape(len(yhat),1))
	meta_X = hstack(meta_X)
	# predict
	return meta_model.predict(meta_X)

# 使用堆叠模型进行预测

def super_learner_predictions(X, models, meta_model):

meta_X = list()

for model in models:

yhat = model.predict(X)

meta_X.append(yhat.reshape(len(yhat),1))

meta_X = hstack(meta_X)

# 预测

return meta_model.predict(meta_X)

我们可以调用此函数并评估结果。

...
# evaluate meta model
yhat = super_learner_predictions(X_val, models, meta_model)
print('Super Learner: RMSE %.3f' % (sqrt(mean_squared_error(y_val, yhat))))

...

# 评估元模型

yhat = super_learner_predictions(X_val, models, meta_model)

print('超级学习器: RMSE %.3f' % (sqrt(mean_squared_error(y_val, yhat))))

综合起来，下面列出了使用 scikit-learn 模型进行回归的超级学习器算法的完整示例。

# example of a super learner model for regression
from math import sqrt
from numpy import hstack
from numpy import vstack
from numpy import asarray
from sklearn.datasets import make_regression
from sklearn.model_selection import KFold
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import ElasticNet
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
from sklearn.ensemble import AdaBoostRegressor
from sklearn.ensemble import BaggingRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import ExtraTreesRegressor

# create a list of base-models
def get_models():
	models = list()
	models.append(LinearRegression())
	models.append(ElasticNet())
	models.append(SVR(gamma='scale'))
	models.append(DecisionTreeRegressor())
	models.append(KNeighborsRegressor())
	models.append(AdaBoostRegressor())
	models.append(BaggingRegressor(n_estimators=10))
	models.append(RandomForestRegressor(n_estimators=10))
	models.append(ExtraTreesRegressor(n_estimators=10))
	return models

# collect out of fold predictions form k-fold cross validation
def get_out_of_fold_predictions(X, y, models):
	meta_X, meta_y = list(), list()
	# define split of data
	kfold = KFold(n_splits=10, shuffle=True)
	# enumerate splits
	for train_ix, test_ix in kfold.split(X):
		fold_yhats = list()
		# get data
		train_X, test_X = X[train_ix], X[test_ix]
		train_y, test_y = y[train_ix], y[test_ix]
		meta_y.extend(test_y)
		# fit and make predictions with each sub-model
		for model in models:
			model.fit(train_X, train_y)
			yhat = model.predict(test_X)
			# store columns
			fold_yhats.append(yhat.reshape(len(yhat),1))
		# store fold yhats as columns
		meta_X.append(hstack(fold_yhats))
	return vstack(meta_X), asarray(meta_y)

# fit all base models on the training dataset
def fit_base_models(X, y, models):
	for model in models:
		model.fit(X, y)

# fit a meta model
def fit_meta_model(X, y):
	model = LinearRegression()
	model.fit(X, y)
	return model

# evaluate a list of models on a dataset
def evaluate_models(X, y, models):
	for model in models:
		yhat = model.predict(X)
		mse = mean_squared_error(y, yhat)
		print('%s: RMSE %.3f' % (model.__class__.__name__, sqrt(mse)))

# make predictions with stacked model
def super_learner_predictions(X, models, meta_model):
	meta_X = list()
	for model in models:
		yhat = model.predict(X)
		meta_X.append(yhat.reshape(len(yhat),1))
	meta_X = hstack(meta_X)
	# predict
	return meta_model.predict(meta_X)

# create the inputs and outputs
X, y = make_regression(n_samples=1000, n_features=100, noise=0.5)
# split
X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)
print('Train', X.shape, y.shape, 'Test', X_val.shape, y_val.shape)
# get models
models = get_models()
# get out of fold predictions
meta_X, meta_y = get_out_of_fold_predictions(X, y, models)
print('Meta ', meta_X.shape, meta_y.shape)
# fit base models
fit_base_models(X, y, models)
# fit the meta model
meta_model = fit_meta_model(meta_X, meta_y)
# evaluate base models
evaluate_models(X_val, y_val, models)
# evaluate meta model
yhat = super_learner_predictions(X_val, models, meta_model)
print('Super Learner: RMSE %.3f' % (sqrt(mean_squared_error(y_val, yhat))))

100

101

102

# 回归超级学习器模型的示例

from math import sqrt

from numpy import hstack

from numpy import vstack

from numpy import asarray

from sklearn.datasets import make_regression

from sklearn.model_selection import KFold

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error

来自 sklearn.linear_model 导入 LinearRegression

来自 sklearn.linear_model 导入 ElasticNet

from sklearn.neighbors import KNeighborsRegressor

来自 sklearn.tree 导入 DecisionTreeRegressor

来自 sklearn.svm 导入 SVR

from sklearn.ensemble import AdaBoostRegressor

from sklearn.ensemble import BaggingRegressor

from sklearn.ensemble import RandomForestRegressor

from sklearn.ensemble import ExtraTreesRegressor

# 创建基本模型列表

定义获取_模型():

models = list()

models.append(LinearRegression())

models.append(ElasticNet())

models.append(SVR(gamma='scale'))

models.append(DecisionTreeRegressor())

models.append(KNeighborsRegressor())

models.append(AdaBoostRegressor())

models.append(BaggingRegressor(n_estimators=10))

models.append(RandomForestRegressor(n_estimators=10))

models.append(ExtraTreesRegressor(n_estimators=10))

返回模型

# 从 K 折交叉验证中收集折外预测

def get_out_of_fold_predictions(X, y, models):

meta_X, meta_y = list(), list()

# 定义数据划分

kfold = KFold(n_splits=10, shuffle=True)

# 枚举划分

for train_ix, test_ix in kfold.split(X):

fold_yhats = list()

# 获取数据

train_X, test_X = X[train_ix], X[test_ix]

train_y, test_y = y[train_ix], y[test_ix]

meta_y.extend(test_y)

# 拟合并使用每个子模型进行预测

for model in models:

model.fit(train_X, train_y)

yhat = model.predict(test_X)

# 存储列

fold_yhats.append(yhat.reshape(len(yhat),1))

# 将折叠预测存储为列

meta_X.append(hstack(fold_yhats))

return vstack(meta_X), asarray(meta_y)

# 在训练数据集上拟合所有基本模型

def fit_base_models(X, y, models):

for model in models:

model.fit(X, y)

# 拟合元模型

def fit_meta_model(X, y):

model = LinearRegression()

model.fit(X, y)

return model

# 在数据集上评估模型列表

def evaluate_models(X, y, models):

for model in models:

yhat = model.predict(X)

mse = mean_squared_error(y, yhat)

print('%s: RMSE %.3f' % (model.__class__.__name__, sqrt(mse)))

# 使用堆叠模型进行预测

def super_learner_predictions(X, models, meta_model):

meta_X = list()

for model in models:

yhat = model.predict(X)

meta_X.append(yhat.reshape(len(yhat),1))

meta_X = hstack(meta_X)

# 预测

return meta_model.predict(meta_X)

# 创建输入和输出

X, y = make_regression(n_samples=1000, n_features=100, noise=0.5)

# 划分

X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)

print('训练集', X.shape, y.shape, '测试集', X_val.shape, y_val.shape)

# 获取模型

模型 = 获取_模型()

# 获取折外预测

meta_X, meta_y = get_out_of_fold_predictions(X, y, models)

print('元模型 ', meta_X.shape, meta_y.shape)

# 拟合基本模型

fit_base_models(X, y, models)

# 拟合元模型

meta_model = fit_meta_model(meta_X, meta_y)

# 评估基本模型

evaluate_models(X_val, y_val, models)

# 评估元模型

yhat = super_learner_predictions(X_val, models, meta_model)

print('超级学习器: RMSE %.3f' % (sqrt(mean_squared_error(y_val, yhat))))

运行该示例首先报告准备好的数据集的形状，然后报告元模型数据集的形状。

接下来，报告每个基本模型在保留数据集上的性能，最后报告超级学习器在保留数据集上的性能。

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

在这种情况下，我们可以看到线性模型在该数据集上表现良好，而非线性算法则表现不佳。

我们还可以看到超级学习器优于所有基本模型。

Train (500, 100) (500,) Test (500, 100) (500,)
Meta  (500, 9) (500,)

LinearRegression: RMSE 0.548
ElasticNet: RMSE 67.142
SVR: RMSE 172.717
DecisionTreeRegressor: RMSE 159.137
KNeighborsRegressor: RMSE 154.064
AdaBoostRegressor: RMSE 98.422
BaggingRegressor: RMSE 108.915
RandomForestRegressor: RMSE 115.637
ExtraTreesRegressor: RMSE 105.749

Super Learner: RMSE 0.546

训练集 (500, 100) (500,) 测试集 (500, 100) (500,)

元模型 (500, 9) (500,)

LinearRegression: RMSE 0.548

ElasticNet: RMSE 67.142

SVR: RMSE 172.717

DecisionTreeRegressor: RMSE 159.137

KNeighborsRegressor: RMSE 154.064

AdaBoostRegressor: RMSE 98.422

BaggingRegressor: RMSE 108.915

RandomForestRegressor: RMSE 115.637

ExtraTreesRegressor: RMSE 105.749

超级学习器: RMSE 0.546

您可以想象在这个示例中插入各种不同的模型，包括 XGBoost 和 Keras 深度学习模型。

现在我们已经了解了如何开发用于回归的超级学习器，接下来我们来看一个用于分类的示例。

用于分类的超级学习器

用于分类的超级学习器算法基本相同。

元学习器的输入可以是类别标签或类别概率，后者可能更有用，因为其捕获了预测中增加的粒度或不确定性。

在这个问题中，我们将使用make_blobs()测试分类问题，并使用1000个样本，包含100个输入变量和两个类别标签。

...
# create the inputs and outputs
X, y = make_blobs(n_samples=1000, centers=2, n_features=100, cluster_std=20)
# split
X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)
print('Train', X.shape, y.shape, 'Test', X_val.shape, y_val.shape)

...

# 创建输入和输出

X, y = make_blobs(n_samples=1000, centers=2, n_features=100, cluster_std=20)

# 划分

X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)

print('训练集', X.shape, y.shape, '测试集', X_val.shape, y_val.shape)

接下来，我们可以更改 get_models() 函数来定义一套线性分类算法和非线性分类算法。

# create a list of base-models
def get_models():
	models = list()
	models.append(LogisticRegression(solver='liblinear'))
	models.append(DecisionTreeClassifier())
	models.append(SVC(gamma='scale', probability=True))
	models.append(GaussianNB())
	models.append(KNeighborsClassifier())
	models.append(AdaBoostClassifier())
	models.append(BaggingClassifier(n_estimators=10))
	models.append(RandomForestClassifier(n_estimators=10))
	models.append(ExtraTreesClassifier(n_estimators=10))
	return models

# 创建基本模型列表

定义获取_模型():

models = list()

models.append(LogisticRegression(solver='liblinear'))

models.append(DecisionTreeClassifier())

models.append(SVC(gamma='scale', probability=True))

models.append(GaussianNB())

models.append(KNeighborsClassifier())

models.append(AdaBoostClassifier())

models.append(BaggingClassifier(n_estimators=10))

models.append(RandomForestClassifier(n_estimators=10))

models.append(ExtraTreesClassifier(n_estimators=10))

返回 models

接下来，我们可以更改 get_out_of_fold_predictions() 函数，通过调用 predict_proba() 函数来预测概率。

# collect out of fold predictions form k-fold cross validation
def get_out_of_fold_predictions(X, y, models):
	meta_X, meta_y = list(), list()
	# define split of data
	kfold = KFold(n_splits=10, shuffle=True)
	# enumerate splits
	for train_ix, test_ix in kfold.split(X):
		fold_yhats = list()
		# get data
		train_X, test_X = X[train_ix], X[test_ix]
		train_y, test_y = y[train_ix], y[test_ix]
		meta_y.extend(test_y)
		# fit and make predictions with each sub-model
		for model in models:
			model.fit(train_X, train_y)
			yhat = model.predict_proba(test_X)
			# store columns
			fold_yhats.append(yhat)
		# store fold yhats as columns
		meta_X.append(hstack(fold_yhats))
	return vstack(meta_X), asarray(meta_y)

# 从 K 折交叉验证中收集折外预测

def get_out_of_fold_predictions(X, y, models):

meta_X, meta_y = list(), list()

# 定义数据划分

kfold = KFold(n_splits=10, shuffle=True)

# 枚举划分

for train_ix, test_ix in kfold.split(X):

fold_yhats = list()

# 获取数据

train_X, test_X = X[train_ix], X[test_ix]

train_y, test_y = y[train_ix], y[test_ix]

meta_y.extend(test_y)

# 拟合并使用每个子模型进行预测

for model in models:

model.fit(train_X, train_y)

yhat = model.predict_proba(test_X)

# 存储列

fold_yhats.append(yhat)

# 将折叠预测存储为列

meta_X.append(hstack(fold_yhats))

return vstack(meta_X), asarray(meta_y)

在 fit_meta_model() 函数中，将使用逻辑回归算法而不是线性回归算法作为元算法。

# fit a meta model
def fit_meta_model(X, y):
	model = LogisticRegression(solver='liblinear')
	model.fit(X, y)
	return model

# 拟合元模型

def fit_meta_model(X, y):

model = LogisticRegression(solver='liblinear')

model.fit(X, y)

return model

并将使用分类准确率来报告模型性能。

下面列出了使用 scikit-learn 模型进行分类的超级学习器算法的完整示例。

# example of a super learner model for binary classification
from numpy import hstack
from numpy import vstack
from numpy import asarray
from sklearn.datasets import make_blobs
from sklearn.model_selection import KFold
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier

# create a list of base-models
def get_models():
	models = list()
	models.append(LogisticRegression(solver='liblinear'))
	models.append(DecisionTreeClassifier())
	models.append(SVC(gamma='scale', probability=True))
	models.append(GaussianNB())
	models.append(KNeighborsClassifier())
	models.append(AdaBoostClassifier())
	models.append(BaggingClassifier(n_estimators=10))
	models.append(RandomForestClassifier(n_estimators=10))
	models.append(ExtraTreesClassifier(n_estimators=10))
	return models

# collect out of fold predictions form k-fold cross validation
def get_out_of_fold_predictions(X, y, models):
	meta_X, meta_y = list(), list()
	# define split of data
	kfold = KFold(n_splits=10, shuffle=True)
	# enumerate splits
	for train_ix, test_ix in kfold.split(X):
		fold_yhats = list()
		# get data
		train_X, test_X = X[train_ix], X[test_ix]
		train_y, test_y = y[train_ix], y[test_ix]
		meta_y.extend(test_y)
		# fit and make predictions with each sub-model
		for model in models:
			model.fit(train_X, train_y)
			yhat = model.predict_proba(test_X)
			# store columns
			fold_yhats.append(yhat)
		# store fold yhats as columns
		meta_X.append(hstack(fold_yhats))
	return vstack(meta_X), asarray(meta_y)

# fit all base models on the training dataset
def fit_base_models(X, y, models):
	for model in models:
		model.fit(X, y)

# fit a meta model
def fit_meta_model(X, y):
	model = LogisticRegression(solver='liblinear')
	model.fit(X, y)
	return model

# evaluate a list of models on a dataset
def evaluate_models(X, y, models):
	for model in models:
		yhat = model.predict(X)
		acc = accuracy_score(y, yhat)
		print('%s: %.3f' % (model.__class__.__name__, acc*100))

# make predictions with stacked model
def super_learner_predictions(X, models, meta_model):
	meta_X = list()
	for model in models:
		yhat = model.predict_proba(X)
		meta_X.append(yhat)
	meta_X = hstack(meta_X)
	# predict
	return meta_model.predict(meta_X)

# create the inputs and outputs
X, y = make_blobs(n_samples=1000, centers=2, n_features=100, cluster_std=20)
# split
X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)
print('Train', X.shape, y.shape, 'Test', X_val.shape, y_val.shape)
# get models
models = get_models()
# get out of fold predictions
meta_X, meta_y = get_out_of_fold_predictions(X, y, models)
print('Meta ', meta_X.shape, meta_y.shape)
# fit base models
fit_base_models(X, y, models)
# fit the meta model
meta_model = fit_meta_model(meta_X, meta_y)
# evaluate base models
evaluate_models(X_val, y_val, models)
# evaluate meta model
yhat = super_learner_predictions(X_val, models, meta_model)
print('Super Learner: %.3f' % (accuracy_score(y_val, yhat) * 100))

100

101

# 二元分类超级学习器模型的示例

from numpy import hstack

from numpy import vstack

from numpy import asarray

from sklearn.datasets import make_blobs

from sklearn.model_selection import KFold

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

from sklearn.neighbors import KNeighborsClassifier

from sklearn.linear_model import LogisticRegression

from sklearn.tree import DecisionTreeClassifier

from sklearn.svm import SVC

from sklearn.naive_bayes import GaussianNB

from sklearn.ensemble import AdaBoostClassifier

from sklearn.ensemble import BaggingClassifier

from sklearn.ensemble import RandomForestClassifier

从 sklearn.集成导入 ExtraTreesClassifier

# 创建基本模型列表

定义获取_模型():

models = list()

models.append(LogisticRegression(solver='liblinear'))

models.append(DecisionTreeClassifier())

models.append(SVC(gamma='scale', probability=True))

models.append(GaussianNB())

models.append(KNeighborsClassifier())

models.append(AdaBoostClassifier())

models.append(BaggingClassifier(n_estimators=10))

models.append(RandomForestClassifier(n_estimators=10))

models.append(ExtraTreesClassifier(n_estimators=10))

返回模型

# 从 K 折交叉验证中收集折外预测

def get_out_of_fold_predictions(X, y, models):

meta_X, meta_y = list(), list()

# 定义数据划分

kfold = KFold(n_splits=10, shuffle=True)

# 枚举划分

for train_ix, test_ix in kfold.split(X):

fold_yhats = list()

# 获取数据

train_X, test_X = X[train_ix], X[test_ix]

train_y, test_y = y[train_ix], y[test_ix]

meta_y.extend(test_y)

# 拟合并使用每个子模型进行预测

for model in models:

model.fit(train_X, train_y)

yhat = model.predict_proba(test_X)

# 存储列

fold_yhats.append(yhat)

# 将折叠预测存储为列

meta_X.append(hstack(fold_yhats))

return vstack(meta_X), asarray(meta_y)

# 在训练数据集上拟合所有基本模型

def fit_base_models(X, y, models):

for model in models:

model.fit(X, y)

# 拟合元模型

def fit_meta_model(X, y):

model = LogisticRegression(solver='liblinear')

model.fit(X, y)

return model

# 在数据集上评估模型列表

def evaluate_models(X, y, models):

for model in models:

yhat = model.predict(X)

acc = accuracy_score(y, yhat)

print('%s: %.3f' % (model.__class__.__name__, acc*100))

# 使用堆叠模型进行预测

def super_learner_predictions(X, models, meta_model):

meta_X = list()

for model in models:

yhat = model.predict_proba(X)

meta_X.append(yhat)

meta_X = hstack(meta_X)

# 预测

return meta_model.predict(meta_X)

# 创建输入和输出

X, y = make_blobs(n_samples=1000, centers=2, n_features=100, cluster_std=20)

# 划分

X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)

print('训练集', X.shape, y.shape, '测试集', X_val.shape, y_val.shape)

# 获取模型

模型 = 获取_模型()

# 获取折外预测

meta_X, meta_y = get_out_of_fold_predictions(X, y, models)

print('元模型 ', meta_X.shape, meta_y.shape)

# 拟合基本模型

fit_base_models(X, y, models)

# 拟合元模型

meta_model = fit_meta_model(meta_X, meta_y)

# 评估基本模型

evaluate_models(X_val, y_val, models)

# 评估元模型

yhat = super_learner_predictions(X_val, models, meta_model)

print('超级学习器: %.3f' % (accuracy_score(y_val, yhat) * 100))

和以前一样，首先报告数据集和准备好的元数据集的形状，然后是基本模型在保留数据集上的性能，最后是超级模型本身在保留数据集上的性能。

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

在这种情况下，我们可以看到超级学习器的性能略好于基本学习器算法。

Train (500, 100) (500,) Test (500, 100) (500,)
Meta (500, 18) (500,)

LogisticRegression: 96.600
DecisionTreeClassifier: 74.400
SVC: 97.400
GaussianNB: 97.800
KNeighborsClassifier: 95.400
AdaBoostClassifier: 93.200
BaggingClassifier: 84.400
RandomForestClassifier: 82.800
ExtraTreesClassifier: 82.600

Super Learner: 98.000

训练集 (500, 100) (500,) 测试集 (500, 100) (500,)

元模型 (500, 18) (500,)

LogisticRegression: 96.600

DecisionTreeClassifier: 74.400

SVC: 97.400

GaussianNB: 97.800

KNeighborsClassifier: 95.400

AdaBoostClassifier: 93.200

BaggingClassifier: 84.400

RandomForestClassifier: 82.800

ExtraTreesClassifier: 82.600

超级学习器: 98.000

使用 ML-Ensemble 库的超级学习器

手动实现超级学习器是一个很好的练习，但并不理想。

我们可能会在实现中引入错误，并且所列出的示例没有利用多核来加快执行速度。

幸运的是，Sebastian Flennerhag在他的ML-Ensemble (mlens) Python 库中提供了超级学习器算法和其他集成算法的高效且经过测试的实现。它专门设计用于 scikit-learn 模型。

首先，必须安装该库，可以通过 pip 实现，如下所示

sudo pip install mlens

1	sudo pip install mlens

接下来，可以定义一个 SuperLearner 类，通过调用 add() 函数添加模型，通过调用 add_meta() 函数添加元学习器，然后像使用任何其他 scikit-learn 模型一样使用该模型。

...
# configure model
ensemble = SuperLearner(...)
# add list of base learners
ensemble.add(...)
# add meta learner
ensemble.add_meta(...)
# use model ...

...

# 配置模型

ensemble = SuperLearner(...)

# 添加基本学习器列表

ensemble.add(...)

# 添加元学习器

ensemble.add_meta(...)

# 使用模型 ...

我们可以在上一节的回归和分类问题上使用这个类。

使用 ML-Ensemble 库的回归超级学习器

首先，我们可以定义一个函数来计算我们问题的 RMSE，超级学习器可以使用它来评估基本模型。

# cost function for base models
def rmse(yreal, yhat):
	return sqrt(mean_squared_error(yreal, yhat))

# 基本模型的成本函数

def rmse(yreal, yhat):

return sqrt(mean_squared_error(yreal, yhat))

接下来，我们可以配置 SuperLearner，使其采用 10 折交叉验证、我们的评估函数，并在准备折外预测以用作元模型的输入时使用整个训练数据集。

下面的 get_super_learner() 函数实现了这一点。

# create the super learner
def get_super_learner(X):
	ensemble = SuperLearner(scorer=rmse, folds=10, shuffle=True, sample_size=len(X))
	# add base models
	models = get_models()
	ensemble.add(models)
	# add the meta model
	ensemble.add_meta(LinearRegression())
	return ensemble

# 创建超级学习器

def get_super_learner(X):

ensemble = SuperLearner(scorer=rmse, folds=10, shuffle=True, sample_size=len(X))

# 添加基本模型

models = get_models()

ensemble.add(models)

# 添加元模型

ensemble.add_meta(LinearRegression())

return ensemble

然后我们可以在训练数据集上拟合模型。

...
# fit the super learner
ensemble.fit(X, y)

...

# 拟合超级学习器

ensemble.fit(X, y)

一旦拟合完成，我们可以通过访问模型的“data”属性，获得一份关于每个基本模型在使用 K 折交叉验证的训练数据集上性能的良好报告。

...
# summarize base learners
print(ensemble.data)

...

# 总结基本学习器

print(ensemble.data)

就是这样。

综合起来，下面列出了使用 mlens 库进行回归的超级学习器评估的完整示例。

# example of a super learner for regression using the mlens library
from math import sqrt
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import ElasticNet
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
from sklearn.ensemble import AdaBoostRegressor
from sklearn.ensemble import BaggingRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import ExtraTreesRegressor
from mlens.ensemble import SuperLearner

# create a list of base-models
def get_models():
	models = list()
	models.append(LinearRegression())
	models.append(ElasticNet())
	models.append(SVR(gamma='scale'))
	models.append(DecisionTreeRegressor())
	models.append(KNeighborsRegressor())
	models.append(AdaBoostRegressor())
	models.append(BaggingRegressor(n_estimators=10))
	models.append(RandomForestRegressor(n_estimators=10))
	models.append(ExtraTreesRegressor(n_estimators=10))
	return models

# cost function for base models
def rmse(yreal, yhat):
	return sqrt(mean_squared_error(yreal, yhat))

# create the super learner
def get_super_learner(X):
	ensemble = SuperLearner(scorer=rmse, folds=10, shuffle=True, sample_size=len(X))
	# add base models
	models = get_models()
	ensemble.add(models)
	# add the meta model
	ensemble.add_meta(LinearRegression())
	return ensemble

# create the inputs and outputs
X, y = make_regression(n_samples=1000, n_features=100, noise=0.5)
# split
X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)
print('Train', X.shape, y.shape, 'Test', X_val.shape, y_val.shape)
# create the super learner
ensemble = get_super_learner(X)
# fit the super learner
ensemble.fit(X, y)
# summarize base learners
print(ensemble.data)
# evaluate meta model
yhat = ensemble.predict(X_val)
print('Super Learner: RMSE %.3f' % (rmse(y_val, yhat)))

# 使用 mlens 库进行回归的超级学习器示例

from math import sqrt

from sklearn.datasets import make_regression

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error

来自 sklearn.linear_model 导入 LinearRegression

来自 sklearn.linear_model 导入 ElasticNet

from sklearn.neighbors import KNeighborsRegressor

来自 sklearn.tree 导入 DecisionTreeRegressor

来自 sklearn.svm 导入 SVR

from sklearn.ensemble import AdaBoostRegressor

from sklearn.ensemble import BaggingRegressor

from sklearn.ensemble import RandomForestRegressor

from sklearn.ensemble import ExtraTreesRegressor

from mlens.ensemble import SuperLearner

# 创建基本模型列表

定义获取_模型():

models = list()

models.append(LinearRegression())

models.append(ElasticNet())

models.append(SVR(gamma='scale'))

models.append(DecisionTreeRegressor())

models.append(KNeighborsRegressor())

models.append(AdaBoostRegressor())

models.append(BaggingRegressor(n_estimators=10))

models.append(RandomForestRegressor(n_estimators=10))

models.append(ExtraTreesRegressor(n_estimators=10))

返回模型

# 基本模型的成本函数

def rmse(yreal, yhat):

return sqrt(mean_squared_error(yreal, yhat))

# 创建超级学习器

def get_super_learner(X):

ensemble = SuperLearner(scorer=rmse, folds=10, shuffle=True, sample_size=len(X))

# 添加基本模型

models = get_models()

ensemble.add(models)

# 添加元模型

ensemble.add_meta(LinearRegression())

return ensemble

# 创建输入和输出

X, y = make_regression(n_samples=1000, n_features=100, noise=0.5)

# 划分

X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)

print('训练集', X.shape, y.shape, '测试集', X_val.shape, y_val.shape)

# 创建超级学习器

ensemble = get_super_learner(X)

# 拟合超级学习器

ensemble.fit(X, y)

# 总结基本学习器

print(ensemble.data)

# 评估元模型

yhat = ensemble.predict(X_val)

print('超级学习器: RMSE %.3f' % (rmse(y_val, yhat)))

运行该示例首先报告每个基本模型的 RMSE（得分-m），然后报告超级学习器本身的 RMSE。

由于后端使用了多线程，允许使用机器的所有核心，因此拟合和评估速度非常快。

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

在这种情况下，我们可以看到超级学习器表现良好。

请注意，我们不能将表格中的基本学习器得分与超级学习器进行比较，因为基本学习器仅在训练数据集上进行评估，而不在保留数据集上进行评估。

[MLENS] backend: threading
Train (500, 100) (500,) Test (500, 100) (500,)
                                  score-m  score-s  ft-m  ft-s  pt-m  pt-s
layer-1  adaboostregressor          86.67     9.35  0.56  0.02  0.03  0.01
layer-1  baggingregressor           94.46    11.70  0.22  0.01  0.01  0.00
layer-1  decisiontreeregressor     137.99    12.29  0.03  0.00  0.00  0.00
layer-1  elasticnet                 62.79     5.51  0.01  0.00  0.00  0.00
layer-1  extratreesregressor        84.18     7.87  0.15  0.03  0.00  0.01
layer-1  kneighborsregressor       152.42     9.85  0.00  0.00  0.00  0.00
layer-1  linearregression            0.59     0.07  0.02  0.01  0.00  0.00
layer-1  randomforestregressor      93.19    10.10  0.20  0.02  0.00  0.00
layer-1  svr                       162.56    12.48  0.03  0.00  0.00  0.00

Super Learner: RMSE 0.571

[MLENS] 后端：多线程

训练集 (500, 100) (500,) 测试集 (500, 100) (500,)

score-m score-s ft-m ft-s pt-m pt-s

第一层 adaboostregressor 86.67 9.35 0.56 0.02 0.03 0.01

第一层 baggingregressor 94.46 11.70 0.22 0.01 0.01 0.00

第一层 decisiontreeregressor 137.99 12.29 0.03 0.00 0.00 0.00

第一层 elasticnet 62.79 5.51 0.01 0.00 0.00 0.00

第一层 extratreesregressor 84.18 7.87 0.15 0.03 0.00 0.01

第一层 kneighborsregressor 152.42 9.85 0.00 0.00 0.00 0.00

第一层 linearregression 0.59 0.07 0.02 0.01 0.00 0.00

第一层 randomforestregressor 93.19 10.10 0.20 0.02 0.00 0.00

第一层 svr 162.56 12.48 0.03 0.00 0.00 0.00

超级学习器: RMSE 0.571

使用 ML-Ensemble 库进行分类的超级学习器

ML-Ensemble 也非常容易用于分类问题，遵循相同的通用模式。

在这种情况下，我们将使用我们的分类器模型列表和逻辑回归模型作为元模型。

下面列出了使用 mlens 库为测试分类问题拟合和评估超级学习器模型的完整示例。

# example of a super learner using the mlens library
from sklearn.datasets import make_blobs
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from mlens.ensemble import SuperLearner

# create a list of base-models
def get_models():
	models = list()
	models.append(LogisticRegression(solver='liblinear'))
	models.append(DecisionTreeClassifier())
	models.append(SVC(gamma='scale', probability=True))
	models.append(GaussianNB())
	models.append(KNeighborsClassifier())
	models.append(AdaBoostClassifier())
	models.append(BaggingClassifier(n_estimators=10))
	models.append(RandomForestClassifier(n_estimators=10))
	models.append(ExtraTreesClassifier(n_estimators=10))
	return models

# create the super learner
def get_super_learner(X):
	ensemble = SuperLearner(scorer=accuracy_score, folds=10, shuffle=True, sample_size=len(X))
	# add base models
	models = get_models()
	ensemble.add(models)
	# add the meta model
	ensemble.add_meta(LogisticRegression(solver='lbfgs'))
	return ensemble

# create the inputs and outputs
X, y = make_blobs(n_samples=1000, centers=2, n_features=100, cluster_std=20)
# split
X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)
print('Train', X.shape, y.shape, 'Test', X_val.shape, y_val.shape)
# create the super learner
ensemble = get_super_learner(X)
# fit the super learner
ensemble.fit(X, y)
# summarize base learners
print(ensemble.data)
# make predictions on hold out set
yhat = ensemble.predict(X_val)
print('Super Learner: %.3f' % (accuracy_score(y_val, yhat) * 100))

# 使用 mlens 库的超级学习器示例

from sklearn.datasets import make_blobs

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

from sklearn.neighbors import KNeighborsClassifier

from sklearn.linear_model import LogisticRegression

from sklearn.tree import DecisionTreeClassifier

from sklearn.svm import SVC

from sklearn.naive_bayes import GaussianNB

from sklearn.ensemble import AdaBoostClassifier

from sklearn.ensemble import BaggingClassifier

from sklearn.ensemble import RandomForestClassifier

from sklearn.ensemble import ExtraTreesClassifier

from mlens.ensemble import SuperLearner

# 创建基本模型列表

定义获取_模型():

models = list()

models.append(LogisticRegression(solver='liblinear'))

models.append(DecisionTreeClassifier())

models.append(SVC(gamma='scale', probability=True))

models.append(GaussianNB())

models.append(KNeighborsClassifier())

models.append(AdaBoostClassifier())

models.append(BaggingClassifier(n_estimators=10))

models.append(RandomForestClassifier(n_estimators=10))

models.append(ExtraTreesClassifier(n_estimators=10))

返回模型

# 创建超级学习器

def get_super_learner(X):

ensemble = SuperLearner(scorer=accuracy_score, folds=10, shuffle=True, sample_size=len(X))

# 添加基本模型

models = get_models()

ensemble.add(models)

# 添加元模型

ensemble.add_meta(LogisticRegression(solver='lbfgs'))

return ensemble

# 创建输入和输出

X, y = make_blobs(n_samples=1000, centers=2, n_features=100, cluster_std=20)

# 划分

X, X_val, y, y_val = train_test_split(X, y, test_size=0.50)

print('训练集', X.shape, y.shape, '测试集', X_val.shape, y_val.shape)

# 创建超级学习器

ensemble = get_super_learner(X)

# 拟合超级学习器

ensemble.fit(X, y)

# 总结基本学习器

print(ensemble.data)

# 对保留集进行预测

yhat = ensemble.predict(X_val)

print('超级学习器: %.3f' % (accuracy_score(y_val, yhat) * 100))

运行该示例总结了数据集的形状、基本模型的性能，最后是超级学习器在保留数据集上的性能。

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

同样，我们可以看到超级学习器在这个测试问题上表现良好，更重要的是，与上一节中的手动示例相比，它的拟合和评估速度非常快。

[MLENS] backend: threading
Train (500, 100) (500,) Test (500, 100) (500,)
                                   score-m  score-s  ft-m  ft-s  pt-m  pt-s
layer-1  adaboostclassifier           0.90     0.04  0.51  0.05  0.04  0.01
layer-1  baggingclassifier            0.83     0.06  0.21  0.01  0.01  0.00
layer-1  decisiontreeclassifier       0.68     0.07  0.03  0.00  0.00  0.00
layer-1  extratreesclassifier         0.80     0.05  0.09  0.01  0.00  0.00
layer-1  gaussiannb                   0.96     0.04  0.01  0.00  0.00  0.00
layer-1  kneighborsclassifier         0.90     0.03  0.00  0.00  0.03  0.01
layer-1  logisticregression           0.93     0.03  0.01  0.00  0.00  0.00
layer-1  randomforestclassifier       0.81     0.06  0.09  0.03  0.00  0.00
layer-1  svc                          0.96     0.03  0.10  0.01  0.00  0.00

Super Learner: 97.400

[MLENS] 后端：多线程

训练集 (500, 100) (500,) 测试集 (500, 100) (500,)

score-m score-s ft-m ft-s pt-m pt-s

第一层 adaboostclassifier 0.90 0.04 0.51 0.05 0.04 0.01

第一层 baggingclassifier 0.83 0.06 0.21 0.01 0.01 0.00

第一层 decisiontreeclassifier 0.68 0.07 0.03 0.00 0.00 0.00

第一层 extratreesclassifier 0.80 0.05 0.09 0.01 0.00 0.00

第一层 gaussiannb 0.96 0.04 0.01 0.00 0.00 0.00

第一层 kneighborsclassifier 0.90 0.03 0.00 0.00 0.03 0.01

第一层 logisticregression 0.93 0.03 0.01 0.00 0.00 0.00

第一层 randomforestclassifier 0.81 0.06 0.09 0.03 0.00 0.00

第一层 svc 0.96 0.03 0.10 0.01 0.00 0.00

超级学习器: 97.400

进一步阅读

如果您想深入了解，本节提供了更多关于该主题的资源。

教程

书籍

论文

R 软件

Python 软件

总结

在本教程中，您学习了超级学习器集成机器学习算法。

具体来说，你学到了：

超级学习器是利用 K 折交叉验证中的折外预测进行堆叠泛化的应用。
超级学习器集成算法在 Python 中使用 scikit-learn 模型实现起来非常简单。
ML-Ensemble (mlens) 库提供了一个便捷的实现，只需几行代码即可拟合和使用超级学习器。

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

关于此主题的更多信息

通过实例理解贝叶斯定理

调整分类机器学习算法的超参数