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

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

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

如何用 Python 开发加权平均集成

原文：machinelearningmastery.com/weighted-av…

最后更新于 2021 年 5 月 8 日

加权平均集成假设集成中的一些模型比其他模型具有更多的技能，并在进行预测时给予它们更多的贡献。

加权平均或加权和集成是对投票集成的扩展，投票集成假设所有模型都同样熟练，并且对集成做出的预测做出相同的比例贡献。

每个模型都分配有一个固定的权重，该权重乘以模型所做的预测，并用于总和或平均预测计算。这种集成的挑战是如何计算、分配或搜索模型权重，从而获得比任何贡献模型和使用相同模型权重的集成更好的表现。

在本教程中，您将发现如何开发用于分类和回归的加权平均集成。

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

• 加权平均集成是投票集成的扩展，其中模型投票与模型表现成比例。
• 如何使用 Sklearn 的投票集成开发加权平均集成？
• 如何评估加权平均集成进行分类和回归，并确认模型是熟练的。

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

我们开始吧。

• 2021 年 5 月更新:加权平均的固定定义。

如何用 Python 开发加权平均集成 图片由 Alaina McDavid 提供，保留部分权利。

教程概述

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

1. 加权平均集成
2. 开发加权平均集成
3. 分类的加权平均集成
4. 回归的加权平均集成

加权平均集成

加权平均或加权和集成是一种集成机器学习方法，它结合了来自多个模型的预测，其中每个模型的贡献与其能力或技能成比例地加权。

加权平均集合与投票集合相关。

投票集成由多个机器学习模型组成，其中来自每个模型的预测被直接平均。对于回归，这包括计算集成成员所做预测的算术平均值。对于分类，这可能涉及计算统计模式(最常见的类别标签)或类似的投票方案，或者对每个类别的预测概率进行求和，并选择具有最大求和概率的类别。

有关投票集成的更多信息，请参见教程:

• 如何用 Python 开发投票集成

投票集成技术的一个限制是，它假设集成中的所有模型都同等有效。情况可能并非如此，因为有些模型可能比其他模型更好，尤其是如果使用不同的机器学习算法来训练每个模型集成成员。

投票的另一种选择是假设全体成员的能力并不完全相同，相反，一些模特比其他模特更优秀，在做预测时应该得到更多的选票或更多的席位。这为加权和或加权平均集成方法提供了动机。

在回归中，使用算术平均值计算平均预测，例如预测之和除以总预测。例如，如果一个集成有三个集成成员，则缩减可能是:

• 型号 1 : 97.2
• 型号 2 : 100.0
• 型号 3 : 95.8

平均预测计算如下:

• yhat = (97.2 + 100.0 + 95.8) / 3
• yhat = 293 / 3
• yhat = 97，666

加权平均预测包括首先给每个集成成员分配一个固定的权重系数。这可能是一个介于 0 和 1 之间的浮点值，代表权重的百分比。它也可以是从 1 开始的整数，代表给每个模型的投票数。

例如，集成成员的固定权重可能为 0.84、0.87、0.75。这些权重可用于计算加权平均值，方法是将每个预测乘以模型的权重，得出加权总和，然后将该值除以权重总和。例如:

• yhat =((97.2 * 0.84)+(100.0 * 0.87)+(95.8 * 0.75))/(0.84+0.87+0.75)
• yhat =(81 648+87+71.85)/(0.84+0.87+0.75)
• yhat = 240 498/2.46
• yhat = 97，763

我们可以看到，只要分数有相同的尺度，权重有相同的尺度并且是最大化的(意味着权重越大越好)，加权和就会产生一个可感知的值，反过来，加权平均也是可感知的，意味着结果的尺度与分数的尺度相匹配。

这种相同的方法可以用于计算每个清晰类别标签的加权投票和或分类问题上每个类别标签的加权概率和。

使用加权平均集成的挑战性方面是如何为每个集成成员选择相对权重。

有许多方法可以使用。例如，可以基于每个模型的技能来选择权重，例如分类准确率或负误差，其中大的权重意味着表现更好的模型。表现可以在用于训练的数据集或保持数据集上计算，后者可能更相关。

每个模型的分数可以直接使用，也可以转换成不同的值，例如每个模型的相对排名。另一种方法可能是使用搜索算法来测试不同的权重组合。

现在我们已经熟悉了加权平均集成方法，让我们看看如何开发和评估它们。

开发加权平均集成

在本节中，我们将开发、评估和使用加权平均或加权和集合模型。

我们可以手动实现加权平均集成，尽管这不是必需的，因为我们可以使用 Sklearn 库中的投票集成来实现期望的效果。具体来说，voting revolutionor和 VotingClassifier 类可以分别用于回归和分类，并且两者都提供了“权重”参数，该参数指定了每个集成成员在进行预测时的相对贡献。

基本模型列表通过“估计量参数提供。这是一个 Python 列表，其中列表中的每个元素都是一个元组，具有模型的名称和配置的模型实例。列表中的每个模型必须有唯一的名称。

例如，我们可以用两个集成成员定义一个加权平均集成进行分类，如下所示:

...
# define the models in the ensemble
models = [('lr',LogisticRegression()),('svm',SVC())]
# define the weight of each model in the ensemble
weights = [0.7, 0.9]
# create a weighted sum ensemble
ensemble = VotingClassifier(estimators=models, weights=weights)

此外，用于分类的投票集成提供了“投票”参数，该参数在计算用于预测的加权和时，支持用于组合清晰类标签的硬投票(‘T0’硬【T1’)和用于组合类概率的软投票(‘T2’软【T3’)；例如:

...
# define the models in the ensemble
models = [('lr',LogisticRegression()),('svm',SVC())]
# define the weight of each model in the ensemble
weights = [0.7, 0.9]
# create a weighted sum ensemble
ensemble = VotingClassifier(estimators=models, weights=weights, voting='soft')

如果贡献模型支持预测类概率，软投票通常是首选，因为它通常会带来更好的表现。预测概率的加权和也是如此。

现在我们已经熟悉了如何使用投票集成 API 来开发加权平均集成，让我们来看看一些工作示例。

分类的加权平均集成

在这一节中，我们将研究使用加权平均集成来解决分类问题。

首先，我们可以使用 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 分割的训练集和测试集。然后，我们将整个训练集分成训练模型的子集和验证的子集。

...
# 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.50, random_state=1)
# split the full train 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)

接下来，我们将定义一个函数来创建一个在集合中使用的模型列表。在这种情况下，我们将使用不同的分类模型集合，包括逻辑回归、决策树和朴素贝叶斯。

# get a list of base models
def get_models():
	models = list()
	models.append(('lr', LogisticRegression()))
	models.append(('cart', DecisionTreeClassifier()))
	models.append(('bayes', GaussianNB()))
	return models

接下来，我们需要权衡每个集成成员。

在这种情况下，我们将使用训练数据集上每个集成模型的表现作为模型在进行预测时的相对权重。表现将使用分类准确率作为 0 到 1 之间正确预测的百分比来计算，值越大意味着模型越好，进而对预测的贡献越大。

每个集成模型将首先适合训练集，然后在验证集上进行评估。验证集的准确性将用作模型权重。

下面的 evaluate_models() 函数实现了这一点，返回每个模型的表现。

# evaluate each base model
def evaluate_models(models, X_train, X_val, y_train, y_val):
	# fit and evaluate the models
	scores = list()
	for name, model in models:
		# fit the model
		model.fit(X_train, y_train)
		# evaluate the model
		yhat = model.predict(X_val)
		acc = accuracy_score(y_val, yhat)
		# store the performance
		scores.append(acc)
		# report model performance
	return scores

然后，我们可以调用这个函数来获得分数，并将它们用作集合的权重。

...
# fit and evaluate each model
scores = evaluate_models(models, X_train, X_val, y_train, y_val)
# create the ensemble
ensemble = VotingClassifier(estimators=models, voting='soft', weights=scores)

然后，我们可以在完整的训练数据集上拟合集合，并在保持测试集上对其进行评估。

...
# fit the ensemble on the training dataset
ensemble.fit(X_train, y_train)
# make predictions on test set
yhat = ensemble.predict(X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Weighted Avg Accuracy: %.3f' % (score*100))

将这些联系在一起，完整的示例如下所示。

# evaluate a weighted average ensemble for classification
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.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import VotingClassifier

# get a list of base models
def get_models():
	models = list()
	models.append(('lr', LogisticRegression()))
	models.append(('cart', DecisionTreeClassifier()))
	models.append(('bayes', GaussianNB()))
	return models

# evaluate each base model
def evaluate_models(models, X_train, X_val, y_train, y_val):
	# fit and evaluate the models
	scores = list()
	for name, model in models:
		# fit the model
		model.fit(X_train, y_train)
		# evaluate the model
		yhat = model.predict(X_val)
		acc = accuracy_score(y_val, yhat)
		# store the performance
		scores.append(acc)
		# report model performance
	return scores

# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# 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.50, random_state=1)
# split the full train 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)
# create the base models
models = get_models()
# fit and evaluate each model
scores = evaluate_models(models, X_train, X_val, y_train, y_val)
print(scores)
# create the ensemble
ensemble = VotingClassifier(estimators=models, voting='soft', weights=scores)
# fit the ensemble on the training dataset
ensemble.fit(X_train_full, y_train_full)
# make predictions on test set
yhat = ensemble.predict(X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Weighted Avg Accuracy: %.3f' % (score*100))

运行该示例首先评估每个独立模型，并报告将用作模型权重的准确度分数。最后，在报告表现的测试上拟合和评估加权平均集成。

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

在这种情况下，我们可以看到投票集成实现了大约 90.960%的分类准确率。

[0.8896969696969697, 0.8575757575757575, 0.8812121212121212]
Weighted Avg Accuracy: 90.960

我们的期望是，这个乐团将会比任何一个有贡献的乐团成员表现得更好。问题是用作权重的模型的准确度分数不能直接与集成的表现进行比较，因为成员是在训练子集上评估的，而集成是在测试数据集上评估的。

我们可以更新示例，并添加对每个独立模型的评估，以便进行比较。

...
# evaluate each standalone model
scores = evaluate_models(models, X_train_full, X_test, y_train_full, y_test)
for i in range(len(models)):
	print('>%s: %.3f' % (models[i][0], scores[i]*100))

我们还期望加权平均集成比同等加权的投票集成表现得更好。

这也可以通过显式评估投票集合来检查。

...
# evaluate equal weighting
ensemble = VotingClassifier(estimators=models, voting='soft')
ensemble.fit(X_train_full, y_train_full)
yhat = ensemble.predict(X_test)
score = accuracy_score(y_test, yhat)
print('Voting Accuracy: %.3f' % (score*100))

将这些联系在一起，完整的示例如下所示。

# evaluate a weighted average ensemble for classification compared to base model
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.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import VotingClassifier

# get a list of base models
def get_models():
	models = list()
	models.append(('lr', LogisticRegression()))
	models.append(('cart', DecisionTreeClassifier()))
	models.append(('bayes', GaussianNB()))
	return models

# evaluate each base model
def evaluate_models(models, X_train, X_val, y_train, y_val):
	# fit and evaluate the models
	scores = list()
	for name, model in models:
		# fit the model
		model.fit(X_train, y_train)
		# evaluate the model
		yhat = model.predict(X_val)
		acc = accuracy_score(y_val, yhat)
		# store the performance
		scores.append(acc)
		# report model performance
	return scores

# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# 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.50, random_state=1)
# split the full train 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)
# create the base models
models = get_models()
# fit and evaluate each model
scores = evaluate_models(models, X_train, X_val, y_train, y_val)
print(scores)
# create the ensemble
ensemble = VotingClassifier(estimators=models, voting='soft', weights=scores)
# fit the ensemble on the training dataset
ensemble.fit(X_train_full, y_train_full)
# make predictions on test set
yhat = ensemble.predict(X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Weighted Avg Accuracy: %.3f' % (score*100))
# evaluate each standalone model
scores = evaluate_models(models, X_train_full, X_test, y_train_full, y_test)
for i in range(len(models)):
	print('>%s: %.3f' % (models[i][0], scores[i]*100))
# evaluate equal weighting
ensemble = VotingClassifier(estimators=models, voting='soft')
ensemble.fit(X_train_full, y_train_full)
yhat = ensemble.predict(X_test)
score = accuracy_score(y_test, yhat)
print('Voting Accuracy: %.3f' % (score*100))

运行该示例首先像以前一样准备和评估加权平均集成，然后报告单独评估的每个贡献模型的表现，最后是对贡献模型使用相同权重的投票集成。

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

在这种情况下，我们可以看到加权平均集成比任何贡献的集成成员表现得更好。

我们还可以看到，等权重集成(投票)获得了大约 90.620%的准确率，这低于获得略高的 90.760%准确率的加权集成。

[0.8896969696969697, 0.8703030303030304, 0.8812121212121212]
Weighted Avg Accuracy: 90.760
>lr: 87.800
>cart: 88.180
>bayes: 87.300
Voting Accuracy: 90.620

接下来，让我们看看如何开发和评估用于回归的加权平均集成。

回归的加权平均集成

在这一节中，我们将研究使用加权平均集成来解决回归问题。

首先，我们可以使用make _ revolution()函数创建一个包含 1000 个示例和 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,)

接下来，我们可以在这个数据集上评估加权平均集成模型。

首先，我们可以将数据集分割成训练集和测试集，然后进一步将训练集分割成训练集和验证集，这样我们就可以估计每个贡献模型的表现。

...
# 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.50, random_state=1)
# split the full train 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)

我们可以定义在集合中使用的模型列表。在这种情况下，我们将使用 k 近邻、决策树和支持向量回归。

# get a list of base models
def get_models():
	models = list()
	models.append(('knn', KNeighborsRegressor()))
	models.append(('cart', DecisionTreeRegressor()))
	models.append(('svm', SVR()))
	return models

接下来，我们可以更新 evaluate_models() 函数来计算等待验证数据集上每个集成成员的平均绝对误差(MAE)。

我们将使用负的 MAE 分数作为权重，其中接近零的大误差值表示更好的模型表现。

# evaluate each base model
def evaluate_models(models, X_train, X_val, y_train, y_val):
	# fit and evaluate the models
	scores = list()
	for name, model in models:
		# fit the model
		model.fit(X_train, y_train)
		# evaluate the model
		yhat = model.predict(X_val)
		mae = mean_absolute_error(y_val, yhat)
		# store the performance
		scores.append(-mae)
		# report model performance
	return scores

然后，我们可以调用这个函数来获得分数，并使用它们来定义回归的加权平均集合。

...
# fit and evaluate each model
scores = evaluate_models(models, X_train, X_val, y_train, y_val)
print(scores)
# create the ensemble
ensemble = VotingRegressor(estimators=models, weights=scores)

然后，我们可以在整个训练数据集上拟合集合，并在保持测试数据集上评估表现。

...
# fit the ensemble on the training dataset
ensemble.fit(X_train_full, y_train_full)
# make predictions on test set
yhat = ensemble.predict(X_test)
# evaluate predictions
score = mean_absolute_error(y_test, yhat)
print('Weighted Avg MAE: %.3f' % (score))

我们期望集成比任何贡献的集成成员表现得更好，这可以通过独立评估完整列车和测试集上的每个成员模型来直接检查。

...
# evaluate each standalone model
scores = evaluate_models(models, X_train_full, X_test, y_train_full, y_test)
for i in range(len(models)):
	print('>%s: %.3f' % (models[i][0], scores[i]))

最后，我们还期望加权平均集成比具有相同权重的相同集成表现得更好。这也是可以证实的。

...
# evaluate equal weighting
ensemble = VotingRegressor(estimators=models)
ensemble.fit(X_train_full, y_train_full)
yhat = ensemble.predict(X_test)
score = mean_absolute_error(y_test, yhat)
print('Voting MAE: %.3f' % (score))

将这些联系在一起，下面列出了评估回归的加权平均集合的完整示例。

# evaluate a weighted average ensemble for regression
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
from sklearn.ensemble import VotingRegressor

# get a list of base models
def get_models():
	models = list()
	models.append(('knn', KNeighborsRegressor()))
	models.append(('cart', DecisionTreeRegressor()))
	models.append(('svm', SVR()))
	return models

# evaluate each base model
def evaluate_models(models, X_train, X_val, y_train, y_val):
	# fit and evaluate the models
	scores = list()
	for name, model in models:
		# fit the model
		model.fit(X_train, y_train)
		# evaluate the model
		yhat = model.predict(X_val)
		mae = mean_absolute_error(y_val, yhat)
		# store the performance
		scores.append(-mae)
		# report model performance
	return scores

# define dataset
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
# 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.50, random_state=1)
# split the full train 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)
# create the base models
models = get_models()
# fit and evaluate each model
scores = evaluate_models(models, X_train, X_val, y_train, y_val)
print(scores)
# create the ensemble
ensemble = VotingRegressor(estimators=models, weights=scores)
# fit the ensemble on the training dataset
ensemble.fit(X_train_full, y_train_full)
# make predictions on test set
yhat = ensemble.predict(X_test)
# evaluate predictions
score = mean_absolute_error(y_test, yhat)
print('Weighted Avg MAE: %.3f' % (score))
# evaluate each standalone model
scores = evaluate_models(models, X_train_full, X_test, y_train_full, y_test)
for i in range(len(models)):
	print('>%s: %.3f' % (models[i][0], scores[i]))
# evaluate equal weighting
ensemble = VotingRegressor(estimators=models)
ensemble.fit(X_train_full, y_train_full)
yhat = ensemble.predict(X_test)
score = mean_absolute_error(y_test, yhat)
print('Voting MAE: %.3f' % (score))

运行该示例首先报告将用作分数的每个集成成员的负 MAE，然后是加权平均集成的表现。最后，报告每个独立模型的表现以及具有相同权重的集合的表现。

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

在这种情况下，我们可以看到加权平均集成实现了大约 105.158 的平均绝对误差，这比实现了大约 100.169 的误差的独立 kNN 模型更差(大误差)。我们还可以看到，假设每个模型权重相等的投票集成也比加权平均集成表现更好，误差约为 102.706。

[-101.97000126284476, -142.26014983127837, -153.9765827528269]
Weighted Avg MAE: 105.158
>knn: -100.169
>cart: -134.487
>svm: -138.195
Voting MAE: 102.706

加权平均集成的表现比预期的差可能与模型加权方式的选择有关。

另一种加权策略是使用排名来表示每个集合在加权平均值中的票数。

例如，在三个集成成员的情况下，表现最差的模型有 1 票，第二差的有 2 票，最佳模型有 3 票。

这可以使用 argsort() numpy 函数来实现。

argsort 函数返回数组中已排序的值的索引。所以，如果我们有数组[300，100，200]，最小值的索引是 1，下一个最大值的索引是 2，下一个最大值的索引是 0。

因此，[300，100，200]的 argsort 为[1，2，0]。

然后，我们可以对 argsort 的结果进行 argsort，以给出原始数组中数据的排名。要了解如何操作，argsort，2，0]将指示索引 2 是最小值，后跟索引 0 并以索引 1 结束。

因此，[1，2，0]的 argsort 为[2，0，1]。换句话说，[300，100，200]的 argsort 的 argsort 是[2，0，1]，这是如果值按升序排序，数组中每个值的相对排名。那就是:

• 300:排名第二
• 100:等级为 0
• 200:排名第 1

我们可以用下面列出的一个小例子来说明这一点。

# demonstrate argsort
from numpy import argsort
# data
x = [300, 100, 200]
print(x)
# argsort of data
print(argsort(x))
# arg sort of argsort of data
print(argsort(argsort(x)))

运行该示例首先报告原始数据，然后报告原始数据的 argsort 和原始数据的 argsort。

结果与我们的手动计算相匹配。

[300, 100, 200]
[1 2 0]
[2 0 1]

我们可以使用模型得分的 argsort 的 argsort 来计算每个集成成员的相对排名。如果负平均绝对误差按升序排序，那么最佳模型将具有最大的负误差，进而具有最高的等级。表现最差的模型将具有最小的负误差，并且依次具有最低的等级。

同样，我们可以用一个工作实例来证实这一点。

# demonstrate argsort with negative scores
from numpy import argsort
# data
x = [-10, -100, -80]
print(x)
# argsort of data
print(argsort(x))
# arg sort of argsort of data
print(argsort(argsort(x)))

运行示例，我们可以看到第一个模型的得分最好(-10)，第二个模型的得分最差(-100)。

得分的 argsort 的 argsort 显示最佳模型获得最高等级(最多票数)值为 2，最差模型获得最低等级(最少票数)值为 0。

[-10, -100, -80]
[1 2 0]
[2 0 1]

实际上，我们不希望任何一个模特获得零票，因为它会被排除在集成之外。因此，我们可以给所有排名加 1。

在计算分数之后，我们可以计算模型分数的 argsort 的 argsort 来给出排名。然后使用模型排名作为加权平均集成的模型权重。

...
# fit and evaluate each model
scores = evaluate_models(models, X_train, X_val, y_train, y_val)
print(scores)
ranking = 1 + argsort(argsort(scores))
print(ranking)
# create the ensemble
ensemble = VotingRegressor(estimators=models, weights=ranking)

将这些联系在一起，下面列出了用于回归的加权平均集合的完整示例，模型排名用作模型权重。

# evaluate a weighted average ensemble for regression with rankings for model weights
from numpy import argsort
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
from sklearn.ensemble import VotingRegressor

# get a list of base models
def get_models():
	models = list()
	models.append(('knn', KNeighborsRegressor()))
	models.append(('cart', DecisionTreeRegressor()))
	models.append(('svm', SVR()))
	return models

# evaluate each base model
def evaluate_models(models, X_train, X_val, y_train, y_val):
	# fit and evaluate the models
	scores = list()
	for name, model in models:
		# fit the model
		model.fit(X_train, y_train)
		# evaluate the model
		yhat = model.predict(X_val)
		mae = mean_absolute_error(y_val, yhat)
		# store the performance
		scores.append(-mae)
		# report model performance
	return scores

# define dataset
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
# 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.50, random_state=1)
# split the full train 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)
# create the base models
models = get_models()
# fit and evaluate each model
scores = evaluate_models(models, X_train, X_val, y_train, y_val)
print(scores)
ranking = 1 + argsort(argsort(scores))
print(ranking)
# create the ensemble
ensemble = VotingRegressor(estimators=models, weights=ranking)
# fit the ensemble on the training dataset
ensemble.fit(X_train_full, y_train_full)
# make predictions on test set
yhat = ensemble.predict(X_test)
# evaluate predictions
score = mean_absolute_error(y_test, yhat)
print('Weighted Avg MAE: %.3f' % (score))
# evaluate each standalone model
scores = evaluate_models(models, X_train_full, X_test, y_train_full, y_test)
for i in range(len(models)):
	print('>%s: %.3f' % (models[i][0], scores[i]))
# evaluate equal weighting
ensemble = VotingRegressor(estimators=models)
ensemble.fit(X_train_full, y_train_full)
yhat = ensemble.predict(X_test)
score = mean_absolute_error(y_test, yhat)
print('Voting MAE: %.3f' % (score))

运行该示例首先对每个模型进行评分，然后将评分转换为排名。然后评估使用排序的加权平均集成，并与每个独立模型和具有同等加权模型的集成的表现进行比较。

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

在这种情况下，我们可以看到排名如预期的那样进行，得分为 101 的表现最好的成员 kNN 被分配了 3 的排名，其他模型也相应地进行了排名。我们可以看到，加权平均集成实现了约 96.692 的 MAE，优于任何单个模型和未加权投票集成。

这突出了探索在集合中选择模型权重的替代方法的重要性。

[-101.97000126284476, -141.51998518020065, -153.9765827528269]
[3 2 1]
Weighted Avg MAE: 96.692
>knn: -100.169
>cart: -132.976
>svm: -138.195
Voting MAE: 102.832

进一步阅读

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

相关教程

• 如何为深度学习神经网络开发加权平均集成
• 如何用 Python 开发投票集成

蜜蜂

• num py . argsort API。
• 硬化。一起。投票分类器 API 。
• 硬化。一起。投票输入 API 。

文章

• 加权算术平均值，维基百科。
• 集成平均(机器学习)，维基百科。

摘要

在本教程中，您发现了如何开发用于分类和回归的加权平均集成。

具体来说，您了解到:

• 加权平均集成是投票集成的扩展，其中模型投票与模型表现成比例。
• 如何使用 Sklearn 的投票集成开发加权平均集成？
• 如何评估加权平均集成进行分类和回归，并确认模型是熟练的。

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

集成学习入门

原文：machinelearningmastery.com/what-is-ens…

最后更新于 2021 年 4 月 27 日

我们在生活中做出的许多决定都是基于多个他人的意见。

这包括根据评论选择一本书来阅读，根据多名医生的建议选择行动方案，以及确定是否有罪。

通常，由一群人做出的决定比由群体中的任何一个成员做出的决定都有更好的结果。这一般被称为人群的智慧。

对于回归和分类预测建模问题，我们可以通过组合多个机器学习模型的预测来获得类似的结果。这一般被称为集成机器学习，或简称为集成学习。

在这篇文章中，你会发现一个关于集成学习的温和介绍。

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

• 我们做出的许多决定都涉及到其他人的意见或投票。
• 群体做出比个人更好决定的能力被称为群体智慧。
• 集成机器学习包括组合来自多个熟练模型的预测。

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

我们开始吧。

文工团学习介绍 图片由土地管理局提供，版权所有。

概观

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

1. 做出重要决定
2. 人群的智慧
3. 集成机器学习

做出重要决定

考虑你在生活中做出的重要决定。

例如:

• 下一步买什么书看。
• 上什么大学。

候选书是那些听起来有趣的书，但是我们购买的书可能会有最有利的评论。候选大学是那些提供我们感兴趣的课程的大学，但我们可能会根据有第一手经验的朋友和熟人的反馈来选择一所。

我们可能会相信评论和明星评分，因为每个贡献评论的人(希望)都与这本书无关，并且独立于其他留下评论的人。当事实并非如此时，对结果的信任是值得怀疑的，对系统的信任是动摇的，这就是为什么亚马逊努力删除书籍的虚假评论。

此外，考虑我们个人做出的重要决定。

例如，疾病的医疗。

我们接受专家的建议，但我们寻求第二、第三甚至更多的意见来确认我们采取了最好的行动。

来自第二和第三种意见的建议可能与第一种意见相匹配，也可能不匹配，但我们对它进行了权衡，因为它是冷静、客观和独立提供的。如果医生在他们的意见上串通一气，那么我们会觉得寻求第二和第三种意见的过程失败了。

……每当我们面临做出具有重要影响的决定时，我们通常会寻求不同“专家”的意见来帮助我们做出决定……

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

最后，考虑我们作为一个社会所做的决定。

例如:

• 谁应该在政府中代表一个地理区域。
• 某人是否有罪。

代表的民主选举(以某种形式)基于公民的独立投票。

根据多人或专家的意见做出决定是人类文明的普遍做法，也是民主社会的基础。

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

一个人是否犯有严重罪行可能由一个独立同行组成的陪审团来决定，该陪审团通常被隔离，以加强其解释的独立性。案件也可以在多个层面上诉，提供第二、第三和更多关于结果的意见。

许多国家的司法系统，无论是基于同行陪审团还是法官小组，也是基于集体决策。

—第 1-2 页，集成机器学习，2012。

这些都是通过结合较低层次的意见、投票或决定而达成的结果的例子。

……基于集成的决策对我们来说并不新鲜；作为人类，我们在日常生活中经常使用这样的系统，这可能是我们的第二天性。

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

在每种情况下，我们都可以看到较低层次的决策的一些属性，这些属性对于结果的有用性至关重要，例如相信它们的独立性，以及每个决策本身都有一些有效性。

这种决策方法非常普遍，它有一个名字。

人群的智慧

这种利用人类做出低级决策的决策方法通常被称为“群体智慧”

它指的是从一群人的集合中计算出来的意见通常比群体中任何个人的意见更准确、更有用或更正确的情况。

100 多年前的一个著名案例经常被引用，那就是在英国普利茅斯的一个集市上，一场估计一头牛体重的竞赛。个人做出猜测，猜测最接近实际体重的人赢得了肉。

统计学家弗朗西斯·高尔顿随后收集了所有的猜测，并计算出猜测的平均值。

…他把所有参赛选手的估计数加起来，计算出小组猜测的平均值。你可以说，这个数字代表了普利茅斯人民的集体智慧。如果人群中只有一个人，那就能猜到这头牛有多重。

—第十三页，人群的智慧，2004。

他发现参赛选手的猜测平均值与实际体重非常接近。也就是说，取 800 名参与者所有数值权重的平均值是确定真实权重的一种准确方式。

群众猜测这头牛在被宰杀和穿好衣服后，将有 1197 磅重。这头牛被宰杀并穿好衣服后，重 1198 磅。换句话说，人群的判断基本上是完美的。

—第十三页，人群的智慧，2004。

詹姆斯·苏洛维耶茨基 2004 年出版的名为《T2:人群的智慧》一书的开头给出了这个例子，该书探讨了人类群体做出决策和预测的能力，这些决策和预测往往比群体成员更好。

这种智慧，或者我称之为“群体的智慧”，在世界上以许多不同的形式发挥着作用。

——第十四页，人群的智慧，2004。

这本书激发了人们在做出一些重要决定时平均猜测、投票和群体意见的偏好，而不是寻找和咨询一个专家。

……我们觉得有必要“追逐专家。”这本书的论点是，追逐专家是一个错误，而且代价高昂。我们应该停止狩猎，问问人群(当然包括天才和其他人)。很有可能，它知道。

—第十五页，人群的智慧，2004。

这本书接着强调了任何基于人群做出决策的系统的许多属性，在 Lior roach 2010 年出版的名为《使用集成方法的模式分类》(第 22 页)的书中有很好的总结，如:

• 观点的多样性:每个成员都应该有私人信息，哪怕只是对已知事实的古怪解读。
• 独立性:成员的意见不是由周围人的意见决定的。
• 去中心化:成员能够根据本地知识进行专门化并得出结论。
• 聚合:将私人判断转化为集体决策的机制是存在的。

作为一个决策系统，这种方法并不总是最有效的(例如股市泡沫、时尚等)。)，但在结果很重要的一系列不同领域都可能有效。

我们可以在应用机器学习中使用这种方法进行决策。

集成机器学习

应用机器学习通常涉及在数据集上拟合和评估模型。

鉴于我们无法事先知道哪个模型在数据集上表现最佳，这可能需要大量的反复试验，直到我们找到一个表现良好或最适合我们项目的模型。

这类似于用一个专家做决定。也许是我们能找到的最好的专家。

一种互补的方法是准备多个不同的模型，然后组合它们的预测。这被称为集成机器学习模型，或简称为集成，而寻找表现良好的集成模型的过程被称为“集成学习”。

集成方法学模仿我们的第二天性，在做出关键决定之前寻求几种意见。

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

这类似于利用多个专家的意见做出决定。

最常见的集成类型包括以确保每个集成成员不同的方式训练同一机器学习模型的多个版本(例如，决策树适合训练数据集的不同子样本)，然后使用平均或投票组合预测。

一种不太常见但同样有效的方法是对相同的数据(例如决策树、支持向量机和神经网络)训练不同的算法，并结合它们的预测。

就像在人群中组合人类的意见一样，集合的有效性依赖于每个模型具有某种技能(比随机的更好)和与其他模型的某种独立性。后一点通常被解释为意味着该模型在不同于集合中其他模型的方面是熟练的。

希望这个集成能产生一个比其他成员更好的表演模式。

核心原则是对几个单独的模式分类器进行加权，并对它们进行组合，以达到比它们各自单独获得的分类更好的分类。

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

在最坏的情况下，集合通过减少预测的方差来限制预测的最坏情况。模型表现会随着训练数据(以及某些情况下学习算法的随机性质)而变化，从而导致任何特定模型的表现更好或更差。

…集成系统的目标是创建几个具有相对固定(或相似)偏差的分类器，然后组合它们的输出，例如通过平均，以减少方差。

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

一个团队可以消除这种情况，并确保所做的预测更接近贡献成员的平均表现。此外，减少预测中的差异通常会提升整体的技能。这是以拟合和维护多个模型而不是单个模型的额外计算成本为代价的。

尽管集合预测具有较低的方差，但不能保证它们比任何单个贡献成员具有更好的表现。

…计算智能和机器学习领域的研究人员已经研究了共享这种联合决策过程的方案。这些方案通常被称为集成学习，众所周知，集成学习可以降低分类器的方差，提高决策系统的鲁棒性和准确性。

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

有时，表现最好的模型，例如最好的专家，与其他模型相比足够优越，将其预测与其他模型相结合会导致更差的表现。

因此，选择模型，甚至是集合模型，仍然需要在健壮的测试工具上进行仔细控制的实验。

进一步阅读

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

书

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

文章

• 一起学习，维基百科。
• 一起学习，学院派。
• 人群的智慧，维基百科。
• 人群的智慧，维基百科。

摘要

在这篇文章中，你发现了一个关于集成学习的温和介绍。

具体来说，您了解到:

• 我们做出的许多决定都涉及到其他人的意见或投票。
• 群体做出比个人更好决定的能力被称为群体智慧。
• 集成机器学习包括组合来自多个熟练模型的预测。

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

为什么使用集成学习？

原文：machinelearningmastery.com/why-use-ens…

最后更新于 2021 年 4 月 27 日

集成方法对机器学习有什么好处？

集成是组合来自两个或更多其他模型的预测的预测模型。

集成学习方法很受欢迎，当预测建模项目的最佳表现是最重要的结果时，集成学习方法是首选技术。

然而，它们并不总是最适合使用的技术，应用机器学习领域的初学者期望集成或特定的集成方法总是最好的使用方法。

集成在预测建模项目中提供了两个具体的好处，了解这些好处是什么以及如何衡量它们以确保使用集成是您项目的正确决策非常重要。

在本教程中，您将发现使用集成方法进行机器学习的好处。

阅读本教程后，您将知道:

• 使用集成的最小好处是减少预测模型的平均技能的差异。
• 使用集成的一个主要好处是提高了集成中任何贡献成员的平均预测表现。
• 集成提高表现的机制通常是减少贡献模型产生的预测误差的方差分量。

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

我们开始吧。

为什么使用集成学习 胡安·安东尼奥·西格尔摄，部分版权已被保留。

教程概述

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

1. 集成学习
2. 使用集成来提高健壮性
3. 偏差、方差和集成
4. 使用集成来提高表现

集成学习

集成是一种机器学习模型，它结合了来自两个或多个模型的预测。

对集合有贡献的模型，称为集合成员，可以是相同类型或不同类型，并且可以在相同的训练数据上训练或不训练。

集成成员做出的预测可以使用统计数据(如模式或平均值)进行组合，或者通过更复杂的方法进行组合，这些方法可以了解在什么条件下信任每个成员的程度。

对集成方法的研究真正开始于 20 世纪 90 年代，那十年发表了关于最流行和最广泛使用的方法的论文，如核心装袋、提升和堆叠方法。

在 21 世纪后期，集成的采用有所增加，部分原因是它们在机器学习竞赛中取得了巨大的成功，例如网飞奖和后来的卡格尔竞赛。

在过去的几十年里，多分类器系统，也称为集成系统，在计算智能和机器学习领域受到越来越多的关注。

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

集成方法大大增加了计算成本和复杂性。这一增长来自于培训和维护多个模型而不是单个模型所需的专业知识和时间。这就引出了一个问题:

• 为什么要考虑用集成？

在单个模型上使用集合有两个主要原因，它们是相关的；它们是:

1. **表现:**与任何单个贡献模型相比，集成可以做出更好的预测并获得更好的表现。
2. 稳健性:集合减少了预测和模型表现的传播或分散。

集成用于在预测建模问题上获得比单一预测模型更好的预测表现。实现这一点的方式可以理解为模型通过增加偏差来减少预测误差的方差分量(即在偏差-方差权衡的背景下)。

最初是为了减少自动化决策系统的差异，从而提高准确性而开发的…

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

集成方法的另一个重要且较少讨论的好处是提高了模型平均表现的稳健性或可靠性。

这些都是机器学习项目的重要关注点，有时我们可能更喜欢模型的一个或两个属性。

让我们仔细看看这两个属性，以便更好地理解在项目中使用集成学习的好处。

使用集成来提高健壮性

在预测建模项目中，我们通常会评估多个模型或建模管道，并选择一个表现良好或最好的模型作为我们的最终模型。

然后，算法或管道适用于所有可用数据，并用于对新数据进行预测。

从我们的测试工具中，我们知道了模型的平均表现，通常使用重复的 k 倍交叉验证作为黄金标准进行评估。问题是，平均表现可能不够。

模型的平均准确率或误差是预期表现的总结，而事实上，一些模型在不同的数据子集上表现更好，而一些模型表现更差。

标准偏差是观察值和平均值之间的平均差异，总结了数据的离差或扩散。对于模型的准确性或误差度量，它可以让您了解模型行为的传播。

查看最小和最大模型表现分数将让您了解您可能期望从模型中获得的最差和最佳表现，这对于您的应用程序来说可能是不可接受的。

最简单的集成是在训练数据集上多次拟合模型，并使用汇总统计(如回归的平均值或分类模式)组合预测。重要的是，由于随机学习算法、训练数据集组成的差异或模型本身的差异，每个模型需要略有不同。

这将减少模型预测的差异。平均表现可能大致相同，尽管最坏和最好情况下的表现会更接近平均表现。

实际上，它平滑了模型的预期表现。

我们可以称之为模型预期表现中的“稳健性”，这是使用集成方法的最小好处。

集合可能会也可能不会提高任何单个贡献成员的建模表现，这将在后面进一步讨论，但至少应该减少模型平均表现的差异。

有关此主题的更多信息，请参见教程:

• 如何减少最终机器学习模型中的方差

偏差、方差和集成

用于分类和回归的机器学习模型学习从输入到输出的映射函数。

这种映射是从问题域(即训练数据集)的示例中获得的，并在训练期间未使用的数据(即测试数据集)上进行评估。

机器学习模型产生的错误通常用两个属性来描述:偏差和方差。

偏差是模型能够捕捉输入和输出之间映射函数的程度的度量。它抓住了模型的刚性:模型关于输入和输出之间映射的功能形式的假设的强度。

模型的方差是当模型适合不同的训练数据时，模型表现的变化量。它捕捉数据细节对模型的影响。

方差是指如果我们使用不同的训练数据集进行估计，那么[模型]将会改变的量。

—第 34 页，R中应用的统计学习介绍，2014。

模型表现的偏差和方差是有联系的。

理想情况下，我们更喜欢具有低偏差和低方差的模型，尽管在实践中，这非常具有挑战性。事实上，对于给定的预测建模问题，这可以描述为应用机器学习的目标。

通过增加方差，通常可以很容易地减少偏差。相反，通过增加偏差可以很容易地降低方差。

这被称为权衡，因为很容易获得偏差极低但方差高的方法……或偏差极低但方差高的方法……

—第 36 页，R中应用的统计学习介绍，2014。

一些模型自然具有高偏差或高方差，这通常可以通过使用改变算法学习行为的超参数来放宽或增加。

集成提供了一种减少预测方差的方法；这是可归因于“方差的预测误差量。”

情况并非总是如此，但如果是这样，方差的减少反过来又会提高预测表现。

经验和理论证据表明，一些集成技术(如 bagging)充当方差减少机制，即它们减少误差的方差分量。此外，经验结果表明，其他集成技术(如 AdaBoost)减少了误差的偏差和方差部分。

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

使用集成来降低预测误差的方差特性首先会带来使用集成的主要好处:提高预测表现。

使用集成来提高表现

减少预测误差的方差元素提高了预测表现。

我们明确地使用集成学习来寻求更好的预测表现，例如更低的回归误差或更高的分类准确率。

……有一种比明智的算法选择更容易、更强大的提高模型准确率的方法:可以将模型集合成集合。

—第 2 页，数据挖掘中的集成方法，2010。

这是集成学习方法的主要用途，也是大多数机器学习竞赛(如网飞奖和卡格尔竞赛)获奖者使用集成所展示的益处。

在 Netflix 奖中，一项为期两年的竞赛将赢得 100 万美元，在该竞赛中，第一个提交模型的团队将网飞的内部推荐系统改进 10%。[……]最终优势是通过权衡多达 30 家竞争对手的车型贡献获得的。

—第 8 页，数据挖掘中的集成方法，2010。

学术竞赛也证明了这一优势，例如计算机视觉领域著名的 ImageNet 数据集的顶级解决方案。

这些剩余网的集合在 ImageNet 测试集上实现了 3.57%的误差。这一结果获得了 ILSVRC 2015 分类任务的第一名。

——图像识别的深度残差学习，2015。

当以这种方式使用时，只有当集成比集成中的任何成员平均表现更好时，才应该采用集成。如果不是这样，那么应该使用表现更好的贡献成员。

考虑由模型在测试工具上计算的预期分数的分布，例如重复的 k 倍交叉验证，正如我们在上面考虑由集合提供的“稳健性”时所做的那样。实际上，减少误差方差的集合将改变分布，而不是简单地缩小分布的范围。

与任何单一型号相比，这可以带来更好的平均表现。

并不总是这样，有这种期待是初学者常犯的错误。

集成团的表演不可能比集成团中表现最好的成员表现得更好，这是可能的，甚至是常见的。如果集成团有一个表现最好的模型，而其他成员没有提供任何好处，或者集成团不能有效地利用他们的贡献，这种情况就会发生。

一个集成团也有可能表现得比集成团中表现最好的成员差。这种情况也很常见，通常涉及一个表现最好的模型，其预测被一个或多个表现不佳的其他模型变得更糟，整个团队无法有效利用它们的贡献。

因此，测试一套集成方法并调整它们的行为是很重要的，就像我们对任何单独的机器学习模型所做的那样。

进一步阅读

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

相关教程

• 如何减少最终机器学习模型中的方差
• 如何开发水平投票深度学习集成来减少差异

书

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

文章

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

摘要

在这篇文章中，你发现了使用集成方法进行机器学习的好处。

具体来说，您了解到:

• 使用集成的最小好处是减少预测模型的平均技能的差异。
• 使用集成的一个主要好处是提高了集成中任何贡献成员的平均预测表现。
• 集成提高表现的机制通常是减少贡献模型产生的预测误差的方差分量。

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