【翻译自 ： Stacking Ensemble Machine Learning With Python】

      【说明：Jason Brownlee PhD大神的文章个人很喜欢，所以闲暇时间里会做一点翻译和学习实践的工作，这里是相应工作的实践记录，希望能帮到有需要的人！】

      Stacking或Stacked Generalization是一种集成的机器学习算法。 它使用元学习算法来学习如何最佳地组合来自两个或多个基础机器学习算法的预测。 堆叠的好处在于，它可以利用分类或回归任务上一系列性能良好的模型的功能，并做出比集合中的任何单个模型都有更好性能的预测。

      在本教程中，您将发现堆叠的泛型集成或Python中的堆叠。 完成本教程后，您将知道：

堆叠是一种集成的机器学习算法，可学习如何最佳地组合来自多个性能良好的机器学习模型的预测。 

scikit-learn库提供了Python中堆栈集成的标准实现。

如何使用堆叠集成进行回归和分类预测建模。 

教程概述

      本教程分为四个部分。 他们是：

堆叠概括
堆叠Scikit-Learn API
堆叠分类
堆叠回归

堆叠概括

      堆叠通用化或简称“堆叠”是一种集成的机器学习算法。它涉及在同一数据集上组合来自多个机器学习模型的预测，例如装袋和提升。堆叠解决了这个问题：给定多个熟练解决问题的机器学习模型，但是以不同的方式，您如何选择要使用的模型（信任）？解决此问题的方法是使用另一个机器学习模型，该模型学习何时使用或信任集合中的每个模型。

与Bagging不同，在堆叠中，模型通常是不同的（例如，并非所有决策树）并且适合于同一数据集（例如，而不是训练数据集的样本）。
与Boosting不同，在堆叠中，使用单个模型来学习如何最佳地组合来自贡献模型的预测（例如，而不是校正先前模型的预测的一系列模型）。

        堆栈模型的体系结构涉及两个或多个基本模型（通常称为0级模型）和一个将基本模型的预测结合在一起的元模型（称为1级模型）。

0级模型（基本模型）：模型适合训练数据，并会编译其预测。
1级模型（元模型）：学习如何最好地组合基础模型的预测的模型。

      元模型是根据基本模型对样本外数据所做的预测进行训练的。也就是说，将不用于训练基本模型的数据馈送到基本模型，进行预测，并且这些预测与预期输出一起提供用于拟合元模型的训练数据集的输入和输出对。来自基本模型的输出（用作元模型的输入）在回归的情况下可以是真实值，而在概率分类的情况下，概率值，类似概率的值或类别标签可以是真实值。为元模型准备训练数据集的最常见方法是通过基本模型的k折交叉验证，其中不合时宜的预测用作元模型训练数据集的基础。
       元模型的训练数据还可以包括基本模型的输入，例如基本模型的输入。训练数据的输入元素。这可以向元模型提供关于如何最佳地组合来自元模型的预测的附加上下文。一旦为元模型准备了训练数据集，就可以在该数据集上单独训练元模型，并且可以在整个原始训练数据集上训练基本模型。
       当多个不同的机器学习模型在数据集上具有技能但以不同的方式具有技能时，堆叠是合适的。另一种说法是，模型做出的预测或模型做出的预测中的误差不相关或具有较低的相关性。基本模型通常是复杂而多样的。因此，通常最好使用一系列关于如何解决预测建模任务的不同假设的模型，例如线性模型，决策树，支持向量机，神经网络等。其他集成算法也可以用作基本模型，例如随机森林。基本模型：使用各种模型，这些模型对预测任务有不同的假设。元模型通常很简单，可以对基本模型做出的预测进行平滑的解释。这样，线性模型通常用作元模型，例如用于回归任务的线性回归（预测数值）和用于分类任务的逻辑回归（预测类标签）。尽管这很普遍，但这不是必需的。

回归元模型：线性回归。
分类元模型：逻辑回归。

      使用简单的线性模型作为元模型通常会堆叠口语名称“ blending”。与预测中一样，是基础模型所做的预测的加权平均或混合。超级学习者可以被认为是一种特殊的堆叠方式。堆栈旨在提高建模性能，尽管不能保证在所有情况下都能改进。实现性能上的改进取决于问题的复杂性，以及培训数据是否足够好地表示问题以及是否足够复杂，以至于可以通过组合预测来学习更多。它还取决于基本模型的选择以及它们在预测（或错误）方面是否足够熟练和足够不相关。如果基本模型的性能优于或优于堆叠集成，则应使用基本模型，因为它的复杂度较低（例如，描述，训练和维护更简单）。

堆叠Scikit-Learn API

     堆叠可以从头开始实现，尽管这对初学者可能具有挑战性。有关在Python中从头开始实现堆栈的示例，请参见教程：

                                                                                                      如何从头开始使用Python实现堆栈泛化（Stacking）
        有关从头开始实现堆栈以进行深度学习的示例，请参见教程：

                                                                                                    如何使用Python开发深度学习神经网络的堆栈集成
       scikit-learn Python机器学习库提供了用于机器学习的堆栈实现。它在库的0.22版和更高版本中可用。首先，通过运行以下脚本来确认您正在使用现代版本的库：

# check scikit-learn version
import sklearn
print(sklearn.__version__)

         运行脚本将打印您的scikit-learn版本。 您的版本应该相同或更高。 如果不是，则必须升级scikit-learn库的版本。

0.22.1

         堆栈是通过StackingRegressor和StackingClassifier类提供的。 两种模型以相同的方式操作并采用相同的参数。 使用模型要求您指定一个估算器列表（0级模型）和一个最终估算器（1级或元模型）。 级别0模型或基本模型的列表通过“ estimators”参数提供。 这是一个Python列表，其中列表中的每个元素都是一个具有模型名称和配置的模型实例的元组。 例如，下面定义了两个0级模型：

models = [('lr',LogisticRegression()),('svm',SVC())
stacking = StackingClassifier(estimators=models)

       列表中的每个模型也可以是管道，包括在将模型拟合到训练数据集之前模型所需的任何数据准备。 例如：

models = [('lr',LogisticRegression()),('svm',make_pipeline(StandardScaler(),SVC()))
stacking = StackingClassifier(estimators=models)

        通过“ final_estimator”参数提供1级模型或元模型。 默认情况下，将其设置为用于回归的LinearRegression和用于分类的LogisticRegression，并且这些是您可能不希望更改的明智的默认值。 使用交叉验证准备元模型的数据集。 默认情况下，使用5折交叉验证，尽管可以通过“ cv”自变量进行更改，并将其设置为数字（例如10折交叉验证为10）或交叉验证对象（例如StratifiedKFold） 。 有时，如果为元模型准备的数据集还包含0级模型的输入（例如， 输入的训练数据。 这可以通过将“ passthrough”参数设置为True来实现，并且默认情况下未启用。 现在，我们已经熟悉了scikit-learn中的stacking API，下面让我们来看一些可行的示例。

堆叠分类

      在本节中，我们将研究使用堆叠解决分类问题。 首先，我们可以使用make_classification（）函数创建具有1,000个示例和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=1)
# summarize the dataset
print(X.shape, y.shape)

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

(1000, 20) (1000,)

      接下来，我们可以在数据集上评估一套不同的机器学习模型。

      具体来说，我们将评估以下五种算法：

逻辑回归。
k最近邻居。
决策树。
支持向量机。
天真贝叶斯。

       每种算法将使用默认模型超参数进行评估。 下面的函数get_models（）创建我们要评估的模型。

# get a list of models to evaluate
def get_models():
	models = dict()
	models['lr'] = LogisticRegression()
	models['knn'] = KNeighborsClassifier()
	models['cart'] = DecisionTreeClassifier()
	models['svm'] = SVC()
	models['bayes'] = GaussianNB()
	return models

      每个模型将使用重复的k倍交叉验证进行评估。 下面的valuate_model（）函数采用一个模型实例，并从分层的10倍交叉验证的三个重复中返回分数列表。

# evaluate a given model using cross-validation
def evaluate_model(model, X, y):
	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, error_score='raise')
	return scores

       然后，我们可以报告每种算法的平均性能，还可以创建箱形图和晶须图，以比较每种算法的准确性得分的分布。 结合在一起，下面列出了完整的示例。

# compare standalone models for binary classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from matplotlib import pyplot

# get the dataset
def get_dataset():
	X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
	return X, y

# get a list of models to evaluate
def get_models():
	models = dict()
	models['lr'] = LogisticRegression()
	models['knn'] = KNeighborsClassifier()
	models['cart'] = DecisionTreeClassifier()
	models['svm'] = SVC()
	models['bayes'] = GaussianNB()
	return models

# evaluate a given model using cross-validation
def evaluate_model(model, X, y):
	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, error_score='raise')
	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, X, y)
	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()

      首先运行示例将报告每个模型的均值和标准差准确性。 注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 我们可以看到，在这种情况下，SVM以约95.7％的平均准确度表现最佳。

>lr 0.866 (0.029)
>knn 0.931 (0.025)
>cart 0.821 (0.050)
>svm 0.957 (0.020)
>bayes 0.833 (0.031)

     首先运行示例将报告每个模型的均值和标准差准确性。 注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 我们可以看到，在这种情况下，SVM以约95.7％的平均准确度表现最佳。

       在这里，我们有五种不同的算法运行良好，大概在此数据集上的表现方式不同。 接下来，我们可以尝试使用堆栈将这五个模型合并为一个整体模型。 我们可以使用逻辑回归模型来学习如何最好地结合来自五个单独模型的预测。 下面的get_stacking（）函数通过首先为五个基本模型定义一个元组列表，然后定义逻辑回归元模型以使用5倍交叉验证组合来自基本模型的预测来定义StackingClassifier模型。

# get a stacking ensemble of models
def get_stacking():
	# define the base models
	level0 = list()
	level0.append(('lr', LogisticRegression()))
	level0.append(('knn', KNeighborsClassifier()))
	level0.append(('cart', DecisionTreeClassifier()))
	level0.append(('svm', SVC()))
	level0.append(('bayes', GaussianNB()))
	# define meta learner model
	level1 = LogisticRegression()
	# define the stacking ensemble
	model = StackingClassifier(estimators=level0, final_estimator=level1, cv=5)
	return model

        我们可以将堆栈集成与独立模型一起包括在要评估的模型列表中。

# get a list of models to evaluate
def get_models():
	models = dict()
	models['lr'] = LogisticRegression()
	models['knn'] = KNeighborsClassifier()
	models['cart'] = DecisionTreeClassifier()
	models['svm'] = SVC()
	models['bayes'] = GaussianNB()
	models['stacking'] = get_stacking()
	return models

       我们的期望是，堆叠集成的性能将优于任何单个基本模型。 并非总是如此，如果不是这种情况，则应使用基础模型，以支持集成模型。 下面列出了评估堆叠集成模型和独立模型的完整示例。

# compare ensemble to each baseline classifier
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import StackingClassifier
from matplotlib import pyplot

# get the dataset
def get_dataset():
	X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
	return X, y

# get a stacking ensemble of models
def get_stacking():
	# define the base models
	level0 = list()
	level0.append(('lr', LogisticRegression()))
	level0.append(('knn', KNeighborsClassifier()))
	level0.append(('cart', DecisionTreeClassifier()))
	level0.append(('svm', SVC()))
	level0.append(('bayes', GaussianNB()))
	# define meta learner model
	level1 = LogisticRegression()
	# define the stacking ensemble
	model = StackingClassifier(estimators=level0, final_estimator=level1, cv=5)
	return model

# get a list of models to evaluate
def get_models():
	models = dict()
	models['lr'] = LogisticRegression()
	models['knn'] = KNeighborsClassifier()
	models['cart'] = DecisionTreeClassifier()
	models['svm'] = SVC()
	models['bayes'] = GaussianNB()
	models['stacking'] = get_stacking()
	return models

# evaluate a give model using cross-validation
def evaluate_model(model, X, y):
	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, error_score='raise')
	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, X, y)
	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()

      首先运行示例将报告每个模型的性能。 这包括每个基本模型的性能，然后是堆叠合奏。

      注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 在这种情况下，我们可以看到堆叠集成的平均性能似乎比任何单个模型都要好，达到了约96.4％的精度。

>lr 0.866 (0.029)
>knn 0.931 (0.025)
>cart 0.820 (0.044)
>svm 0.957 (0.020)
>bayes 0.833 (0.031)
>stacking 0.964 (0.019)

       将创建一个箱形图，以显示模型分类精度的分布。 在这里，我们可以看到堆叠模型的均值和中值准确性比SVM模型要高一些。

       如果我们选择堆叠集成作为最终模型，则可以像其他任何模型一样拟合并使用它对新数据进行预测。 首先，将堆栈集合适合所有可用数据，然后可以调用predict（）函数对新数据进行预测。 下面的示例在我们的二进制分类数据集中展示了这一点。

# make a prediction with a stacking ensemble
from sklearn.datasets import make_classification
from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# define the base models
level0 = list()
level0.append(('lr', LogisticRegression()))
level0.append(('knn', KNeighborsClassifier()))
level0.append(('cart', DecisionTreeClassifier()))
level0.append(('svm', SVC()))
level0.append(('bayes', GaussianNB()))
# define meta learner model
level1 = LogisticRegression()
# define the stacking ensemble
model = StackingClassifier(estimators=level0, final_estimator=level1, cv=5)
# fit the model on all available data
model.fit(X, y)
# make a prediction for one example
data = [[2.47475454,0.40165523,1.68081787,2.88940715,0.91704519,-3.07950644,4.39961206,0.72464273,-4.86563631,-6.06338084,-1.22209949,-0.4699618,1.01222748,-0.6899355,-0.53000581,6.86966784,-3.27211075,-6.59044146,-2.21290585,-3.139579]]
yhat = model.predict(data)
print('Predicted Class: %d' % (yhat))

         运行示例适合整个数据集上的堆叠集成模型，然后像在应用程序中使用模型一样，将其用于对新数据行进行预测。

Predicted Class: 0

堆叠回归

      在本节中，我们将研究如何使用堆叠来解决回归问题。 首先，我们可以使用make_regression（）函数创建具有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=1)
# summarize the dataset
print(X.shape, y.shape)

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

(1000, 20) (1000,)

      接下来，我们可以在数据集上评估一套不同的机器学习模型。

     具体来说，我们将评估以下三种算法：

k近邻
决策树
支持向量回归

       注意：可以使用线性回归模型对测试数据集进行简单求解，因为该数据集是在封面下使用线性模型创建的。 因此，我们将把该模型放在示例之外，以便我们可以证明堆叠集成方法的好处。

      每种算法将使用默认的模型超参数进行评估。 下面的函数get_models（）创建我们要评估的模型。

# get a list of models to evaluate
def get_models():
	models = dict()
	models['knn'] = KNeighborsRegressor()
	models['cart'] = DecisionTreeRegressor()
	models['svm'] = SVR()
	return models

          每个模型将使用重复的k倍交叉验证进行评估。 下面的valuate_model（）函数采用一个模型实例，并从三个重复的10倍交叉验证中返回分数列表。

# evaluate a given model using cross-validation
def evaluate_model(model, X, y):
	cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
	scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
	return scores

        然后，我们可以报告每种算法的平均性能，还可以创建箱形图和晶须图，以比较每种算法的准确性得分的分布。 在这种情况下，将使用平均绝对误差（MAE）报告模型性能。 scikit-learn库会将此错误的符号反转以使其最大化，从-infinity到0以获取最佳分数。 结合在一起，下面列出了完整的示例。

# compare machine learning models for regression
from numpy import mean
from numpy import std
from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
from matplotlib import pyplot

# get the dataset
def get_dataset():
	X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
	return X, y

# get a list of models to evaluate
def get_models():
	models = dict()
	models['knn'] = KNeighborsRegressor()
	models['cart'] = DecisionTreeRegressor()
	models['svm'] = SVR()
	return models

# evaluate a given model using cross-validation
def evaluate_model(model, X, y):
	cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
	scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
	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, X, y)
	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()

       首先运行示例，报告每个模型的均值和标准差MAE。 注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 我们可以看到，在这种情况下，KNN的最佳表现为平均负MAE约为-100。

>knn -101.019 (7.161)
>cart -148.100 (11.039)
>svm -162.419 (12.565)

       然后创建箱须图，比较每个模型的分布负MAE得分。

      在这里，我们有三种不同的算法可以很好地运行，大概在此数据集上以不同的方式运行。

       接下来，我们可以尝试使用堆栈将这三个模型合并为一个整体模型。

       我们可以使用线性回归模型来学习如何最佳地组合来自三个模型的预测。

      下面的get_stacking（）函数通过首先为三个基本模型定义一个元组列表，然后定义线性回归元模型以使用5倍交叉验证组合来自基本模型的预测来定义StackingRegressor模型。

# get a stacking ensemble of models
def get_stacking():
	# define the base models
	level0 = list()
	level0.append(('knn', KNeighborsRegressor()))
	level0.append(('cart', DecisionTreeRegressor()))
	level0.append(('svm', SVR()))
	# define meta learner model
	level1 = LinearRegression()
	# define the stacking ensemble
	model = StackingRegressor(estimators=level0, final_estimator=level1, cv=5)
	return model

       我们可以将堆栈集成与独立模型一起包括在要评估的模型列表中

# get a list of models to evaluate
def get_models():
	models = dict()
	models['knn'] = KNeighborsRegressor()
	models['cart'] = DecisionTreeRegressor()
	models['svm'] = SVR()
	models['stacking'] = get_stacking()
	return models

         我们的期望是，堆叠集成的性能将优于任何单个基本模型。 情况并非总是如此，如果不是这种情况，则应使用基础模型以支持集成模型。 下面列出了评估堆叠集成模型和独立模型的完整示例。

# compare ensemble to each standalone models for regression
from numpy import mean
from numpy import std
from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
from sklearn.ensemble import StackingRegressor
from matplotlib import pyplot

# get the dataset
def get_dataset():
	X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
	return X, y

# get a stacking ensemble of models
def get_stacking():
	# define the base models
	level0 = list()
	level0.append(('knn', KNeighborsRegressor()))
	level0.append(('cart', DecisionTreeRegressor()))
	level0.append(('svm', SVR()))
	# define meta learner model
	level1 = LinearRegression()
	# define the stacking ensemble
	model = StackingRegressor(estimators=level0, final_estimator=level1, cv=5)
	return model

# get a list of models to evaluate
def get_models():
	models = dict()
	models['knn'] = KNeighborsRegressor()
	models['cart'] = DecisionTreeRegressor()
	models['svm'] = SVR()
	models['stacking'] = get_stacking()
	return models

# evaluate a given model using cross-validation
def evaluate_model(model, X, y):
	cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
	scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
	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, X, y)
	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()

       首先运行示例将报告每个模型的性能。 这包括每个基本模型的性能，然后是堆叠合奏。 注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 在这种情况下，我们可以看到堆叠集成的平均表现要好于任何单个模型，平均负MAE约为-56。

>knn -101.019 (7.161)
>cart -148.017 (10.635)
>svm -162.419 (12.565)
>stacking -56.893 (5.253)

      将创建一个箱形图，以显示模型错误分数的分布。 在这里，我们可以看到堆叠模型的平均得分和中位数得分远高于任何单个模型。

      如果我们选择堆叠集成作为最终模型，则可以像其他任何模型一样拟合并使用它对新数据进行预测。 首先，将堆栈集合适合所有可用数据，然后可以调用predict（）函数对新数据进行预测。 下面的示例在我们的回归数据集中展示了这一点。

# make a prediction with a stacking ensemble
from sklearn.datasets import make_regression
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
from sklearn.ensemble import StackingRegressor
# define dataset
X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
# define the base models
level0 = list()
level0.append(('knn', KNeighborsRegressor()))
level0.append(('cart', DecisionTreeRegressor()))
level0.append(('svm', SVR()))
# define meta learner model
level1 = LinearRegression()
# define the stacking ensemble
model = StackingRegressor(estimators=level0, final_estimator=level1, cv=5)
# fit the model on all available data
model.fit(X, y)
# make a prediction for one example
data = [[0.59332206,-0.56637507,1.34808718,-0.57054047,-0.72480487,1.05648449,0.77744852,0.07361796,0.88398267,2.02843157,1.01902732,0.11227799,0.94218853,0.26741783,0.91458143,-0.72759572,1.08842814,-0.61450942,-0.69387293,1.69169009]]
yhat = model.predict(data)
print('Predicted Value: %.3f' % (yhat))

       运行示例适合整个数据集上的堆叠集成模型，然后像在应用程序中使用模型一样，将其用于对新数据行进行预测。

Predicted Value: 556.264

 

相关教程

如何使用Python从头开始实现堆栈泛化（Stacking）
如何使用Keras开发Python深度学习神经网络的堆栈集成
如何用Python开发超级学习者集成
如何在机器学习中使用不合时宜的预测
K折叠交叉验证的简要介绍