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

àì夳堔傛蜴生んèń 2022-10-17 00:43 134阅读 0赞

【翻译自 ： H[ow to Develop a Weighted Average Ensemble With Python][]】

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

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

加权平均或加权和集成是对投票集成的扩展，它假设所有模型都具有同等的技能，并对集成的预测做出相同的比例贡献。

每个模型都分配了一个固定的权重，该权重乘以模型所做的预测并用于总和或平均预测计算。此类集成的挑战在于如何计算、分配或搜索导致性能优于任何贡献模型和使用相同模型权重的集成的模型权重。

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

加权平均集成是投票集成的扩展，其中模型投票与模型性能成正比。
    如何使用来自 scikit-learn 的投票集成开发加权平均集成。
    如何评估加权平均集成以进行分类和回归，以及如何确定模型是否熟练。

# 教程概述 #

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

加权平均集成
    开发加权平均集成
    用于分类的加权平均集成
    回归的加权平均集成

## 加权平均集成 ##

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

加权平均集成与投票集成相关。投票集成由多个机器学习模型组成，其中每个模型的预测直接平均。对于回归，这涉及计算集成成员所做预测的算术平均值。对于分类，这可能涉及计算统计模式（最常见的类别标签）或类似的投票方案，或对每个类别的预测概率求和并选择总和概率最大的类别。

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

[如何使用 Python 开发投票集成][Python]  
投票集成技术的一个限制是它假设集成中的所有模型都同样有效。情况可能并非如此，因为某些模型可能比其他模型更好，尤其是当使用不同的机器学习算法来训练每个模型集成成员时。投票的另一种选择是假设集成成员的能力并不完全相同，相反，某些模型比其他模型更好，并且在进行预测时应该获得更多选票或更多席位。这为加权总和或加权平均集成方法提供了动机。

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

Model 1: 97.2
    Model 2: 100.0
    Model 3: 95.8

平均预测将计算如下：

yhat = (97.2 + 100.0 + 95.8) / 3
    yhat = 293 / 3
    yhat = 97.666

加权平均预测涉及首先为每个集成成员分配一个固定的权重系数。 这可能是一个介于 0 和 1 之间的浮点值，表示权重的百分比。 它也可以是一个从 1 开始的整数，代表给每个模型的投票数。例如，我们可能将 ensemble 成员的固定权重设为 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

我们可以看到，只要分数具有相同的尺度，并且权重具有相同的尺度并且正在最大化（意味着更大的权重更好），加权和会产生一个合理的值，反过来，加权平均值是也是明智的，这意味着结果的量表与分数的量表相匹配。

同样的方法可用于计算每个清晰类别标签的加权投票总和或每个类别标签在分类问题上的加权概率总和。使用加权平均集成的挑战在于如何为每个集成成员选择相对权重。

有很多方法可以使用。例如，可以根据每个模型的技能选择权重，例如分类准确率或负误差，其中权重大意味着模型性能更好。可以在用于训练的数据集或保留数据集上计算性能，后者可能更相关。每个模型的分数可以直接使用，也可以转换为不同的值，例如每个模型的相对排名。另一种方法可能是使用搜索算法来测试权重的不同组合。现在我们熟悉了加权平均集成方法，让我们看看如何开发和评估它们。

## 开发加权平均集成 ##

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

我们可以手动实现加权平均集成，尽管这不是必需的，因为我们可以使用 scikit-learn 库中的投票集成来达到预期的效果。 具体来说，VotingRegressor 和 VotingClassifier 类可以分别用于回归和分类，并且都提供了一个“权重”参数，用于指定每个集成成员在进行预测时的相对贡献。基础模型列表通过“estimators”参数提供。 这是一个 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)

此外，分类投票集成提供了“投票”参数，支持硬投票（‘hard’）用于组合清晰的类标签，软投票（‘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\_regression() 函数创建一个包含 1,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,)

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

首先，我们可以将数据集拆分为训练集和测试集，然后进一步将训练集拆分为训练集和验证集，以便我们可以估计每个贡献模型的性能。

我们可以定义在集成中使用的模型列表。 在这种情况下，我们将使用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() 函数来计算hold out 验证数据集上每个集成成员的平均绝对误差(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 以给出原始数组中数据的排名。要了解如何，\[1, 2, 0\] 的 argsort 将指示索引 2 是最小值，然后是索引 0 并以索引 1 结尾。因此，\[1, 2, 0\] 的 argsort 是 \[2, 0, 1\]。换句话说，\[300，100，200\]的argsort的argsort是\[2，0，1\]，如果值按升序排序，则这是数组中每个值的相对排名。那是：

300：有等级 2
    100：有等级 0
    200：排名第一

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

# 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 的 argsort。结果与我们的手动计算相符。

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

我们可以使用模型分数的 argsort 的 argsort 来计算每个 ensemble 成 员的相对排名。 如果负均值绝对误差按升序排序，那么最好的模型将具有最大的负误差，进而具有最高的排名。 表现最差的模型的负误差最小，反过来，排名最低。同样，我们可以用一个可行的例子来证实这一点。

# 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

[ow to Develop a Weighted Average Ensemble With Python]: https://machinelearningmastery.com/weighted-average-ensemble-with-python/
[Python]: https://machinelearningmastery.com/voting-ensembles-with-python/