本文主要是介绍基于Python的Blending集成机器学习实践，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
【翻译自 ： Blending Ensemble Machine Learning With Python】
【说明：Jason Brownlee PhD大神的文章个人很喜欢，所以闲暇时间里会做一点翻译和学习实践的工作，这里是相应工作的实践记录，希望能帮到有需要的人！】
Blending是一种集成的机器学习算法。 它是堆叠概括或堆叠集成的通俗名称，在该模型中，元模型不适合基本模型做出的失叠预测，而是适合于对保留数据集做出的预测。 Blending用于描述堆叠模型，该模型将竞争对手在100万美元的Netflix机器学习竞赛中融合了数百种预测模型，因此，在竞争性机器学习圈子（例如Kaggle社区）中，堆叠仍然是一种流行的技术和名称。 在本教程中，您将发现如何在python中开发和评估混合合奏。
完成本教程后，您将知道：
Blending集成是一种堆叠类型，其中使用保留验证数据集上的预测而不是失叠预测来拟合元模型。 如何开发Blending集成，包括用于训练模型和对新数据进行预测的功能。 如何评估Blending集成的分类和回归预测建模问题。教程概述
本教程分为四个部分。 他们是：
Blending集成
实践Blending集成
Blending集成进行分类
Blending集成进行回归Blending集成
Blending是一种集成的机器学习技术，它使用机器学习模型来学习如何最佳地组合来自多个贡献的集成成员模型的预测。因此，混合与广义上的堆叠概括（称为堆叠）相同。 通常，混合和堆叠可在同一篇论文或模型说明中互换使用。栈模型的体系结构涉及两个或多个基本模型（通常称为0级模型）和一个将基本模型的预测结合在一起的元模型（称为1级模型）。 元模型是根据基本模型对样本外数据所做的预测进行训练的。
0级模型（基本模型）：模型适合训练数据，并会编译其预测。
1级模型（元模型）：学习如何最好地组合基础模型的预测的模型。但是，Blending对于如何构建堆叠集成模型具有特定的含义。Blending可能会建议开发一个堆叠集成，其中基本模型是任何类型的机器学习模型，而元模型是线性模型，可以“融合”基本模型的预测。例如，当预测数值时的线性回归模型或在预测类别标签时的逻辑回归模型将计算由基础模型做出的预测的加权和，并被视为预测的Blending。
Blending集成：使用线性模型（例如线性回归或逻辑回归）作为堆叠集成中的元模型。
Blending是该术语在2009年Netflix获奖期间通常用于堆叠合奏的术语。该奖项涉及寻求表现优于本地Netflix算法的电影推荐预测的团队，并且将性能提高10％的团队获得了100万美元的奖金。 。
因此，Blending是使用堆叠式架构模型进行集成学习的通俗术语。 除了与竞争性机器学习有关的内容外，很少在教科书或学术论文中使用过它。最常见的是，Blending用于描述堆叠的特定应用，在该应用中，元模型是根据基本模型在保留验证数据集上进行的预测来训练元模型的。 在这种情况下，堆栈是为元模型保留的，该元模型在交叉验证过程中根据失叠预测进行训练。
Blending：堆叠型集合，其中元模型根据对保持数据集所做的预测进行训练。
Stacking：堆叠型集合，其中元模型根据k倍交叉验证过程中做出的失叠预测进行训练。开发一个Blending集成实例
在撰写本文时，scikit-learn库本身不支持混合。 相反，我们可以使用scikit-learn模型自己实现它。 首先，我们需要创建许多基本模型。 这些可以是我们希望用于回归或分类问题的任何模型。 我们可以定义一个函数get_models（），该函数返回模型列表，其中每个模型都定义为具有名称和配置的分类器或回归对象的元组。 例如，对于分类问题，我们可以使用逻辑回归，kNN，决策树，SVM和朴素贝叶斯模型。
# get a list of base models
def get_models():models = list()models.append(('lr', LogisticRegression()))models.append(('knn', KNeighborsClassifier()))models.append(('cart', DecisionTreeClassifier()))models.append(('svm', SVC(probability=True)))models.append(('bayes', GaussianNB()))return models接下来，我们需要拟合Blending模型。 回想一下，基本模型适合于训练数据集。 元模型适合每个基本模型在保留数据集上做出的预测。 首先，我们可以枚举模型列表，然后依次将它们拟合到训练数据集上。 同样在此循环中，我们可以使用拟合模型对保留（验证）数据集进行预测，并存储预测以供以后使用。
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:# fit in training setmodel.fit(X_train, y_train)# predict on hold out setyhat = model.predict(X_val)# reshape predictions into a matrix with one columnyhat = yhat.reshape(len(yhat), 1)# store predictions as input for blendingmeta_X.append(yhat)现在，我们有了“ meta_X”，它表示可用于训练元模型的输入数据。 每列或每个要素代表一个基本模型的输出。 每行代表保留数据集中的一个样本。 我们可以使用hstack（）函数来确保此数据集是机器学习模型所期望的2D numpy数组。
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)现在，我们可以训练我们的元模型。 这可以是我们喜欢的任何机器学习模型，例如用于分类的逻辑回归。
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)我们可以将所有这些都绑定到一个名为fit_ensemble（）的函数中，该函数使用训练数据集和保持验证数据集来训练混合模型。
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):# fit all models on the training set and predict on hold out setmeta_X = list()for name, model in models:# fit in training setmodel.fit(X_train, y_train)# predict on hold out setyhat = model.predict(X_val)# reshape predictions into a matrix with one columnyhat = yhat.reshape(len(yhat), 1)# store predictions as input for blendingmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# define blending modelblender = LogisticRegression()# fit on predictions from base modelsblender.fit(meta_X, y_val)return blender下一步是使用Blending集成对新数据进行预测。
这是一个两步过程。 第一步是使用每个基本模型进行预测。 然后将这些预测收集在一起，并用作混合模型的输入以进行最终预测。
我们可以使用与训练模型时相同的循环结构。 也就是说，我们可以将来自每个基本模型的预测收集到训练数据集中，将预测堆叠在一起，然后使用此元级数据集在Blender模型上调用predict（）。
下面的predict_ensemble（）函数实现了这一点。 给定拟合基础模型的列表，拟合混合器集合和数据集（例如测试数据集或新数据），它将返回该数据集的一组预测。
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):# make predictions with base modelsmeta_X = list()for name, model in models:# predict with base modelyhat = model.predict(X_test)# reshape predictions into a matrix with one columnyhat = yhat.reshape(len(yhat), 1)# store predictionmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# predictreturn blender.predict(meta_X)现在，我们拥有实现分类或回归预测建模问题的融合集合所需的所有元素。
Blending集成进行分类
在本节中，我们将研究使用混合解决分类问题。 首先，我们可以使用make_classification（）函数创建具有10,000个示例和20个输入功能的综合二进制分类问题。 下面列出了完整的示例。
# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# summarize the dataset
print(X.shape, y.shape)运行示例将创建数据集并总结输入和输出组件的形状。
(10000, 20) (10000,)接下来，我们需要将数据集分解，首先分为训练集和测试集，然后将训练集分为用于训练基本模型的子集和用于训练元模型的子集。 在这种情况下，我们将对训练和测试集使用50-50的比例，然后对训练和验证集使用67-33的比例。
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))之后，我们可以使用上一部分中的get_models（）函数来创建集合中使用的分类模型。
然后可以调用fit_ensemble（）函数以将Blending集成拟合到训练数据集和验证数据集上，然后predict_ensemble（）函数可以用于对保持数据集进行预测。
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)最后，我们可以通过在测试数据集上报告分类准确性来评估Blending模型的性能。
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Blending Accuracy: %.3f' % score)综上所述，下面列出了评估综合二元分类问题中的Blending集成的完整示例。
# blending ensemble for classification using hard voting
from numpy import hstack
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
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# get the dataset
def get_dataset():X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)return X, y# get a list of base models
def get_models():models = list()models.append(('lr', LogisticRegression()))models.append(('knn', KNeighborsClassifier()))models.append(('cart', DecisionTreeClassifier()))models.append(('svm', SVC()))models.append(('bayes', GaussianNB()))return models# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):# fit all models on the training set and predict on hold out setmeta_X = list()for name, model in models:# fit in training setmodel.fit(X_train, y_train)# predict on hold out setyhat = model.predict(X_val)# reshape predictions into a matrix with one columnyhat = yhat.reshape(len(yhat), 1)# store predictions as input for blendingmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# define blending modelblender = LogisticRegression()# fit on predictions from base modelsblender.fit(meta_X, y_val)return blender# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):# make predictions with base modelsmeta_X = list()for name, model in models:# predict with base modelyhat = model.predict(X_test)# reshape predictions into a matrix with one columnyhat = yhat.reshape(len(yhat), 1)# store predictionmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# predictreturn blender.predict(meta_X)# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Blending Accuracy: %.3f' % (score*100))运行示例将首先报告训练，验证和测试数据集的形状，然后报告测试数据集上集合的准确性。
注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。
在这种情况下，我们可以看到Blending集成达到了约97.900％的分类精度。
Train: (3350, 20), Val: (1650, 20), Test: (5000, 20)
Blending Accuracy: 97.900在前面的示例中，使用集成模型组合了清晰的类别标签预测。 这是一种硬投票。
一种替代方法是让每个模型预测类概率并使用元模型来混合概率。 这是一种软投票，在某些情况下可以提高性能。
首先，我们必须配置模型以返回概率，例如SVM模型。
# get a list of base models
def get_models():models = list()models.append(('lr', LogisticRegression()))models.append(('knn', KNeighborsClassifier()))models.append(('cart', DecisionTreeClassifier()))models.append(('svm', SVC(probability=True)))models.append(('bayes', GaussianNB()))return models接下来，我们必须更改基本模型以预测概率，而不是清晰的类标签。 拟合基础模型时，可以通过在fit_ensemble（）函数中调用predict_proba（）函数来实现。
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:# fit in training setmodel.fit(X_train, y_train)# predict on hold out setyhat = model.predict_proba(X_val)# store predictions as input for blendingmeta_X.append(yhat)这意味着用于训练元模型的元数据集每个分类器将有n列，其中n是预测问题中的类数，在我们的情况下为2。 当使用Blending模型对新数据进行预测时，我们还需要更改基本模型做出的预测。
# make predictions with base models
meta_X = list()
for name, model in models:# predict with base modelyhat = model.predict_proba(X_test)# store predictionmeta_X.append(yhat)综上所述，下面列出了针对合成的二元分类问题在预测类概率上使用Blending的完整示例。
# blending ensemble for classification using soft voting
from numpy import hstack
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
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# get the dataset
def get_dataset():X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)return X, y# get a list of base models
def get_models():models = list()models.append(('lr', LogisticRegression()))models.append(('knn', KNeighborsClassifier()))models.append(('cart', DecisionTreeClassifier()))models.append(('svm', SVC(probability=True)))models.append(('bayes', GaussianNB()))return models# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):# fit all models on the training set and predict on hold out setmeta_X = list()for name, model in models:# fit in training setmodel.fit(X_train, y_train)# predict on hold out setyhat = model.predict_proba(X_val)# store predictions as input for blendingmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# define blending modelblender = LogisticRegression()# fit on predictions from base modelsblender.fit(meta_X, y_val)return blender# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):# make predictions with base modelsmeta_X = list()for name, model in models:# predict with base modelyhat = model.predict_proba(X_test)# store predictionmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# predictreturn blender.predict(meta_X)# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Blending Accuracy: %.3f' % (score*100))运行示例将首先报告训练，验证和测试数据集的形状，然后报告测试数据集上集合的准确性。 注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 在这种情况下，我们可以看到，混合类别概率导致分类准确性提高到约98.240％。
Train: (3350, 20), Val: (1650, 20), Test: (5000, 20)
Blending Accuracy: 98.240Blending集成只有能够胜过任何单个贡献模型时才有效。 我们可以通过单独评估每个基本模型来确认这一点。 每个基础模型都可以适合整个训练数据集（与混合合奏不同），并可以在测试数据集上进行评估（就像混合合奏一样）。 下面的示例演示了这一点，并单独评估了每个基本模型。
# evaluate base models on the entire training dataset
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
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# get the dataset
def get_dataset():X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)return X, y# get a list of base models
def get_models():models = list()models.append(('lr', LogisticRegression()))models.append(('knn', KNeighborsClassifier()))models.append(('cart', DecisionTreeClassifier()))models.append(('svm', SVC(probability=True)))models.append(('bayes', GaussianNB()))return models# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# summarize data split
print('Train: %s, Test: %s' % (X_train_full.shape, X_test.shape))
# create the base models
models = get_models()
# evaluate standalone model
for name, model in models:# fit the model on the training datasetmodel.fit(X_train_full, y_train_full)# make a prediction on the test datasetyhat = model.predict(X_test)# evaluate the predictionsscore = accuracy_score(y_test, yhat)# report the scoreprint('>%s Accuracy: %.3f' % (name, score*100))运行示例将首先报告完整训练和测试数据集的形状，然后报告测试数据集上每个基础模型的准确性。 注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 在这种情况下，我们可以看到所有模型的性能都比混合集成差。 有趣的是，我们可以看到，与混合系统实现的98.240相比，SVM的精度非常接近98.200％。
Train: (5000, 20), Test: (5000, 20)
>lr Accuracy: 87.800
>knn Accuracy: 97.380
>cart Accuracy: 88.200
>svm Accuracy: 98.200
>bayes Accuracy: 87.300我们可能选择使用Blending集成作为最终模型。
这涉及将整体拟合到整个训练数据集上，并对新示例进行预测。 具体来说，将整个训练数据集分为训练集和验证集以分别训练基本模型和元模型，然后可以使用集成进行预测。
下面列出了使用Blending集成对新数据进行预测的完整示例。
# example of making a prediction with a blending ensemble for classification
from numpy import hstack
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
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# get the dataset
def get_dataset():X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)return X, y# get a list of base models
def get_models():models = list()models.append(('lr', LogisticRegression()))models.append(('knn', KNeighborsClassifier()))models.append(('cart', DecisionTreeClassifier()))models.append(('svm', SVC(probability=True)))models.append(('bayes', GaussianNB()))return models# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):# fit all models on the training set and predict on hold out setmeta_X = list()for _, model in models:# fit in training setmodel.fit(X_train, y_train)# predict on hold out setyhat = model.predict_proba(X_val)# store predictions as input for blendingmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# define blending modelblender = LogisticRegression()# fit on predictions from base modelsblender.fit(meta_X, y_val)return blender# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):# make predictions with base modelsmeta_X = list()for _, model in models:# predict with base modelyhat = model.predict_proba(X_test)# store predictionmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# predictreturn blender.predict(meta_X)# define dataset
X, y = get_dataset()
# split dataset set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s' % (X_train.shape, X_val.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make a prediction on a new row of data
row = [-0.30335011, 2.68066314, 2.07794281, 1.15253537, -2.0583897, -2.51936601, 0.67513028, -3.20651939, -1.60345385, 3.68820714, 0.05370913, 1.35804433, 0.42011397, 1.4732839, 2.89997622, 1.61119399, 7.72630965, -2.84089477, -1.83977415, 1.34381989]
yhat = predict_ensemble(models, blender, [row])
# summarize prediction
print('Predicted Class: %d' % (yhat))运行示例使Blending集成模型适合数据集，然后用于对新数据行进行预测，就像我们在应用程序中使用模型时一样。
Train: (6700, 20), Val: (3300, 20)
Predicted Class: 1Blending集成进行回归
在本节中，我们将研究如何使用堆叠来解决回归问题。首先，我们可以使用make_regression（）函数创建具有10,000个示例和20个输入要素的综合回归问题。下面列出了完整的示例。
# test regression dataset
from sklearn.datasets import make_regression
# define dataset
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
# summarize the dataset
print(X.shape, y.shape)运行示例将创建数据集并总结输入和输出组件的形状。
(10000, 20) (10000,)接下来，我们可以定义用作基础模型的回归模型列表。 在这种情况下，我们将使用线性回归，kNN，决策树和SVM模型。
# get a list of base models
def get_models():models = list()models.append(('lr', LinearRegression()))models.append(('knn', KNeighborsRegressor()))models.append(('cart', DecisionTreeRegressor()))models.append(('svm', SVR()))return models除了分类所使用的模型必须更改为回归模型以外，用于训练Blending集成的fit_ensemble（）函数在分类上未发生变化。在这种情况下，我们将使用线性回归模型。
# define blending model
blender = LinearRegression()考虑到这是一个回归问题，我们将使用误差度量（在这种情况下为平均绝对误差或简称MAE）评估模型的性能。
# evaluate predictions
score = mean_absolute_error(y_test, yhat)
print('Blending MAE: %.3f' % score)结合在一起，下面列出了用于综合回归预测建模问题的Blending集成的完整示例。
# evaluate blending ensemble for regression
from numpy import hstack
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR# get the dataset
def get_dataset():X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)return X, y# get a list of base models
def get_models():models = list()models.append(('lr', LinearRegression()))models.append(('knn', KNeighborsRegressor()))models.append(('cart', DecisionTreeRegressor()))models.append(('svm', SVR()))return models# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):# fit all models on the training set and predict on hold out setmeta_X = list()for name, model in models:# fit in training setmodel.fit(X_train, y_train)# predict on hold out setyhat = model.predict(X_val)# reshape predictions into a matrix with one columnyhat = yhat.reshape(len(yhat), 1)# store predictions as input for blendingmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# define blending modelblender = LinearRegression()# fit on predictions from base modelsblender.fit(meta_X, y_val)return blender# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):# make predictions with base modelsmeta_X = list()for name, model in models:# predict with base modelyhat = model.predict(X_test)# reshape predictions into a matrix with one columnyhat = yhat.reshape(len(yhat), 1)# store predictionmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# predictreturn blender.predict(meta_X)# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
# evaluate predictions
score = mean_absolute_error(y_test, yhat)
print('Blending MAE: %.3f' % score) 运行示例首先报告训练，验证和测试数据集的形状，然后报告测试数据集上的MAE。
注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。
在这种情况下，我们可以看到Blending集成在测试数据集上实现了约0.237的MAE。
Train: (3350, 20), Val: (1650, 20), Test: (5000, 20)
Blending MAE: 0.237 与分类一样，Blending集成仅在其性能优于构成该集成的任何基本模型的情况下才有用。
我们可以通过首先对整个基础数据集进行拟合（与混合合奏不同）并在测试数据集上进行预测（如Blending集成）来单独评估每个基本模型，从而进行检查。
下面的示例在综合回归预测建模数据集上单独评估每个基本模型。
# evaluate base models in isolation on the regression dataset
from numpy import hstack
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR# get the dataset
def get_dataset():X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)return X, y# get a list of base models
def get_models():models = list()models.append(('lr', LinearRegression()))models.append(('knn', KNeighborsRegressor()))models.append(('cart', DecisionTreeRegressor()))models.append(('svm', SVR()))return models# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# summarize data split
print('Train: %s, Test: %s' % (X_train_full.shape, X_test.shape))
# create the base models
models = get_models()
# evaluate standalone model
for name, model in models:# fit the model on the training datasetmodel.fit(X_train_full, y_train_full)# make a prediction on the test datasetyhat = model.predict(X_test)# evaluate the predictionsscore = mean_absolute_error(y_test, yhat)# report the scoreprint('>%s MAE: %.3f' % (name, score))运行示例将首先报告完整训练和测试数据集的形状，然后报告测试数据集上每个基础模型的MAE。 注意：由于算法或评估程序的随机性，或者数值精度的差异，您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 在这种情况下，我们可以看到线性回归模型的确比混合集成稍好一些，MAE为0.236，而集成集成为0.237。 这可能是由于合成数据集的构建方式所致。 不过，在这种情况下，我们将选择直接对这个问题使用线性回归模型。 这突出了在采用集
Train: (5000, 20), Test: (5000, 20)
>lr MAE: 0.236
>knn MAE: 100.169
>cart MAE: 133.744
>svm MAE: 138.195 同样，我们可以选择使用Blending集成作为我们最终的回归模型。
这涉及将整个数据集拆分为训练集和验证集，以分别适合基础模型和元模型，然后可以使用集成对新的数据行进行预测。
下面列出了使用Blending集成对回归进行新数据预测的完整示例。
# example of making a prediction with a blending ensemble for regression
from numpy import hstack
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR# get the dataset
def get_dataset():X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)return X, y# get a list of base models
def get_models():models = list()models.append(('lr', LinearRegression()))models.append(('knn', KNeighborsRegressor()))models.append(('cart', DecisionTreeRegressor()))models.append(('svm', SVR()))return models# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):# fit all models on the training set and predict on hold out setmeta_X = list()for _, model in models:# fit in training setmodel.fit(X_train, y_train)# predict on hold out setyhat = model.predict(X_val)# reshape predictions into a matrix with one columnyhat = yhat.reshape(len(yhat), 1)# store predictions as input for blendingmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# define blending modelblender = LinearRegression()# fit on predictions from base modelsblender.fit(meta_X, y_val)return blender# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):# make predictions with base modelsmeta_X = list()for _, model in models:# predict with base modelyhat = model.predict(X_test)# reshape predictions into a matrix with one columnyhat = yhat.reshape(len(yhat), 1)# store predictionmeta_X.append(yhat)# create 2d array from predictions, each set is an input featuremeta_X = hstack(meta_X)# predictreturn blender.predict(meta_X)# define dataset
X, y = get_dataset()
# split dataset set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s' % (X_train.shape, X_val.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make a prediction on a new row of data
row = [-0.24038754, 0.55423865, -0.48979221, 1.56074459, -1.16007611, 1.10049103, 1.18385406, -1.57344162, 0.97862519, -0.03166643, 1.77099821, 1.98645499, 0.86780193, 2.01534177, 2.51509494, -1.04609004, -0.19428148, -0.05967386, -2.67168985, 1.07182911]
yhat = predict_ensemble(models, blender, [row])
# summarize prediction
print('Predicted: %.3f' % (yhat[0]))运行示例使Blending集成模型适合数据集，然后用于对新数据行进行预测，就像我们在应用程序中使用模型时一样。
Train: (6700, 20), Val: (3300, 20)
Predicted: 359.986
这篇关于基于Python的Blending集成机器学习实践的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
