使用 scikit-learn 在 Python 中实现集成机器学习算法

作者： Jason Brownlee 于 2020 年 8 月 28 日发表在 Python 机器学习 164

集成模型可以提高您数据集上的准确率。

在本帖中，您将了解如何使用 scikit-learn 在 Python 中创建一些最强大的集成模型。

本案例研究将引导您完成 Bagging（装袋）、Boosting（提升）和 Majority Voting（多数投票），并展示如何不断提高模型在您自己数据集上的准确率。

立即开始您的项目，阅读我的新书《Python 机器学习精通》，其中包含分步教程和所有示例的Python 源代码文件。

让我们开始吧。

2017年1月更新：更新以反映 scikit-learn 0.18 版本中的 API 变化。
**2018 年 3 月更新**：添加了下载数据集的备用链接，因为原始链接似乎已被删除。

Ensemble Machine Learning Algorithms in Python with scikit-learn

使用 scikit-learn 在 Python 中实现集成机器学习算法
图片来源：美国陆军乐队，部分权利保留。

将模型预测组合成集成预测

组合不同模型预测的三种最流行的方法是：

Bagging（装袋）。从训练数据集的不同子集中构建多个模型（通常是相同类型的模型）。
Boosting（提升）。构建多个模型（通常是相同类型的模型），每个模型都学习纠正链中前一个模型的预测错误。
Voting（投票）。构建多个模型（通常是不同类型的模型），并使用简单的统计方法（如计算平均值）来组合预测。

本帖不解释每种方法。

它假定您对机器学习算法和集成方法有普遍的了解，并且您正在寻找如何在 Python 中创建集成模型的信息。

需要 Python 机器学习方面的帮助吗？

参加我为期 2 周的免费电子邮件课程，探索数据准备、算法等等（附带代码）。

立即点击注册，还将免费获得本课程的 PDF 电子书版本。

关于食谱

本帖中的每个食谱都设计成独立的。这样您可以将它们复制粘贴到您的项目中并立即开始使用。

用于演示每种集成算法的标准分类问题是 Pima 印第安人糖尿病发病率数据集。这是一个二分类问题，其中所有输入变量都是数值型的，并且具有不同的尺度。

你可以在此处了解更多关于此数据集的信息：

每种集成算法都使用 10 折交叉验证进行演示，这是一种用于估计任何机器学习算法在未见数据上性能的标准技术。

Bagging 算法

Bootstrap Aggregation 或 Bagging 涉及从训练数据集中提取多个样本（有放回），并为每个样本训练一个模型。

最终的输出预测是所有子模型预测的平均值。

本节介绍三种 Bagging 模型：

装袋决策树
随机森林
额外树

1. 装袋决策树

Bagging 对高方差算法效果最好。一个流行的例子是决策树，通常在没有剪枝的情况下构建。

在下面的示例中，您将看到使用 BaggingClassifier 和分类回归树算法（DecisionTreeClassifier）的示例。总共创建了 100 棵树。

# Bagged Decision Trees for Classification
import pandas
from sklearn import model_selection
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
seed = 7
kfold = model_selection.KFold(n_splits=10, random_state=seed)
cart = DecisionTreeClassifier()
num_trees = 100
model = BaggingClassifier(base_estimator=cart, n_estimators=num_trees, random_state=seed)
results = model_selection.cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

# 用于分类的装袋决策树

import pandas

from sklearn import model_selection

from sklearn.ensemble import BaggingClassifier

from sklearn.tree import DecisionTreeClassifier

url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"

names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']

dataframe = pandas.read_csv(url, names=names)

array = dataframe.values

X = array[:,0:8]

Y = array[:,8]

seed = 7

kfold = model_selection.KFold(n_splits=10, random_state=seed)

cart = DecisionTreeClassifier()

num_trees = 100

model = BaggingClassifier(base_estimator=cart, n_estimators=num_trees, random_state=seed)

results = model_selection.cross_val_score(model, X, Y, cv=kfold)

print(results.mean())

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

运行示例，我们获得了对模型准确率的稳健估计。

0.770745044429

1	0.770745044429

2. 随机森林

随机森林是装袋决策树的扩展。

从训练数据集中提取有放回的样本，但构建树的方式可以减少单个分类器之间的相关性。具体来说，在构建树时，不是贪婪地选择最佳分裂点，而是仅考虑每个分裂的随机特征子集。

您可以使用 RandomForestClassifier 类为分类问题构建随机森林模型。

下面的示例展示了用于分类的随机森林，其中有 100 棵树，分裂点是从 3 个随机特征中选择的。

# Random Forest Classification
import pandas
from sklearn import model_selection
from sklearn.ensemble import RandomForestClassifier
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
seed = 7
num_trees = 100
max_features = 3
kfold = model_selection.KFold(n_splits=10, random_state=seed)
model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)
results = model_selection.cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

# 随机森林分类

import pandas

from sklearn import model_selection

from sklearn.ensemble import RandomForestClassifier

url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"

names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']

dataframe = pandas.read_csv(url, names=names)

array = dataframe.values

X = array[:,0:8]

Y = array[:,8]

seed = 7

num_trees = 100

max_features = 3

kfold = model_selection.KFold(n_splits=10, random_state=seed)

model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)

results = model_selection.cross_val_score(model, X, Y, cv=kfold)

print(results.mean())

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

运行示例将提供分类准确率的平均估计。

0.770727956254

1	0.770727956254

3. Extra Trees

Extra Trees 是 Bagging 的另一种变体，其中从训练数据集中创建随机树。

您可以使用 ExtraTreesClassifier 类为分类问题构建 Extra Trees 模型。

下面的示例展示了 Extra Trees 的用法，其中树的数量设置为 100，分裂点是从 7 个随机特征中选择的。

# Extra Trees Classification
import pandas
from sklearn import model_selection
from sklearn.ensemble import ExtraTreesClassifier
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
seed = 7
num_trees = 100
max_features = 7
kfold = model_selection.KFold(n_splits=10, random_state=seed)
model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)
results = model_selection.cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

# Extra Trees 分类

import pandas

from sklearn import model_selection

from sklearn.ensemble import ExtraTreesClassifier

url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"

names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']

dataframe = pandas.read_csv(url, names=names)

array = dataframe.values

X = array[:,0:8]

Y = array[:,8]

seed = 7

num_trees = 100

max_features = 7

kfold = model_selection.KFold(n_splits=10, random_state=seed)

model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)

results = model_selection.cross_val_score(model, X, Y, cv=kfold)

print(results.mean())

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

运行示例将提供分类准确率的平均估计。

0.760269993165

1	0.760269993165

Boosting 算法

Boosting 集成算法创建一系列模型，这些模型试图纠正序列中先前模型的错误。

创建后，模型会进行预测，这些预测可能会根据其已证明的准确率进行加权，并将结果组合起来以创建最终的输出预测。

最常见的两种 Boosting 集成机器学习算法是：

AdaBoost
随机梯度提升

1. AdaBoost

AdaBoost 可能是第一个成功的 Boosting 集成算法。它通常通过根据数据实例的分类难度对其进行加权来工作，从而允许算法在构建后续模型时给予它们更多或更少的关注。

您可以使用 AdaBoostClassifier 类为分类问题构建 AdaBoost 模型。

下面的示例展示了使用 AdaBoost 算法顺序构建 30 棵决策树。

# AdaBoost Classification
import pandas
from sklearn import model_selection
from sklearn.ensemble import AdaBoostClassifier
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
seed = 7
num_trees = 30
kfold = model_selection.KFold(n_splits=10, random_state=seed)
model = AdaBoostClassifier(n_estimators=num_trees, random_state=seed)
results = model_selection.cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

# AdaBoost 分类

import pandas

from sklearn import model_selection

from sklearn.ensemble import AdaBoostClassifier

url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"

names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']

dataframe = pandas.read_csv(url, names=names)

array = dataframe.values

X = array[:,0:8]

Y = array[:,8]

seed = 7

num_trees = 30

kfold = model_selection.KFold(n_splits=10, random_state=seed)

model = AdaBoostClassifier(n_estimators=num_trees, random_state=seed)

results = model_selection.cross_val_score(model, X, Y, cv=kfold)

print(results.mean())

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

运行示例将提供分类准确率的平均估计。

0.76045796309

1	0.76045796309

2. Stochastic Gradient Boosting（随机梯度提升）

Stochastic Gradient Boosting（也称为 Gradient Boosting Machines，梯度提升机）是最复杂的一种集成技术。它也是一种通过集成来提高性能的最佳技术。

您可以使用 GradientBoostingClassifier 类为分类问题构建梯度提升模型。

下面的示例展示了用于分类的 Stochastic Gradient Boosting，其中包含 100 棵树。

# Stochastic Gradient Boosting Classification
import pandas
from sklearn import model_selection
from sklearn.ensemble import GradientBoostingClassifier
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
seed = 7
num_trees = 100
kfold = model_selection.KFold(n_splits=10, random_state=seed)
model = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)
results = model_selection.cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

# Stochastic Gradient Boosting 分类

import pandas

from sklearn import model_selection

from sklearn.ensemble import GradientBoostingClassifier

url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"

names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']

dataframe = pandas.read_csv(url, names=names)

array = dataframe.values

X = array[:,0:8]

Y = array[:,8]

seed = 7

num_trees = 100

kfold = model_selection.KFold(n_splits=10, random_state=seed)

model = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)

results = model_selection.cross_val_score(model, X, Y, cv=kfold)

print(results.mean())

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

运行示例将提供分类准确率的平均估计。

0.764285714286

1	0.764285714286

Voting Ensemble（投票集成）

Voting 是组合多个机器学习算法预测的最简单方法之一。

它的工作原理是首先从训练数据集中创建两个或多个独立模型。然后，可以使用 Voting Classifier 来包装这些模型，并在需要为新数据进行预测时对子模型的预测进行平均。

子模型的预测可以加权，但手动或甚至是启发式地指定分类器的权重非常困难。更高级的方法可以学习如何最好地加权子模型的预测，但这被称为堆叠（stacking）（堆叠泛化），并且目前在 scikit-learn 中未提供。

您可以使用 VotingClassifier 类为分类问题创建投票集成模型。

下面的代码示例了将逻辑回归、分类回归树和支持向量机这几个模型的预测组合起来用于分类问题。

# Voting Ensemble for Classification
import pandas
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
seed = 7
kfold = model_selection.KFold(n_splits=10, random_state=seed)
# create the sub models
estimators = []
model1 = LogisticRegression()
estimators.append(('logistic', model1))
model2 = DecisionTreeClassifier()
estimators.append(('cart', model2))
model3 = SVC()
estimators.append(('svm', model3))
# create the ensemble model
ensemble = VotingClassifier(estimators)
results = model_selection.cross_val_score(ensemble, X, Y, cv=kfold)
print(results.mean())

# 分类的投票集成

import pandas

from sklearn import model_selection

from sklearn.linear_model import LogisticRegression

from sklearn.tree import DecisionTreeClassifier

from sklearn.svm import SVC

from sklearn.ensemble import VotingClassifier

url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"

names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']

dataframe = pandas.read_csv(url, names=names)

array = dataframe.values

X = array[:,0:8]

Y = array[:,8]

seed = 7

kfold = model_selection.KFold(n_splits=10, random_state=seed)

# 创建子模型

estimators = []

model1 = LogisticRegression()

estimators.append(('logistic', model1))

model2 = DecisionTreeClassifier()

estimators.append(('cart', model2))

model3 = SVC()

estimators.append(('svm', model3))

# 创建集成模型

ensemble = VotingClassifier(estimators)

results = model_selection.cross_val_score(ensemble, X, Y, cv=kfold)

print(results.mean())

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

运行示例将提供分类准确率的平均估计。

0.712166780588

1	0.712166780588

总结

在本帖中，您了解了用于提高模型在您的问题上的性能的集成机器学习算法。

您了解了：

Bagging 集成，包括装袋决策树、随机森林和 Extra Trees。
Boosting 集成，包括 AdaBoost 和 Stochastic Gradient Boosting。
Voting 集成，用于平均任意模型的预测。

您对集成机器学习算法或 scikit-learn 中的集成有任何疑问吗？请在评论中提问，我将尽力回答。

关于此主题的更多信息

使用 Keras 深度学习库的多类分类教程

使用 Python 和 scikit-learn 中的管道自动化机器学习工作流

Python 和 scikit-learn 集成机器学习算法的 164 条回复

Vishal 2016 年 6 月 9 日上午 7:37 #

信息丰富的帖子。

一旦您确定并最终确定了最佳集成模型，如何用该模型对未来的样本进行评分？我指的是模型在数据库中的生产化。

您会使用类似 pickle 包的东西吗？或者是否有办法写出评分算法（决策树的 IF-ELSE 规则，或逻辑回归的实际公式）并为未来的评分目的使用该公式？

回复
- Jason Brownlee 2016 年 6 月 14 日上午 8:21 #
  
  在您确定模型后，您可以将其集成到服务应用程序中。
  
  模型将直接使用。
  
  它将接收输入模式并进行预测，您可以以某种操作方式使用这些预测。
  
  回复
- Sarra 2018 年 2 月 4 日上午 5:01 #
  
  嗨，Jason，
  
  我写了下面的代码。然而，在您的代码片段中，我看到您没有在 AdaBoostClassifier 中指定“base_estimator”。有什么特别的原因吗？这个参数有默认值吗（CART？？）
  
  # Boosting – AdaBoost 算法
  num_trees4 = 30
  cart2 = DecisionTreeClassifier()
  model4 = AdaBoostClassifier(base_estimator=cart2, n_estimators=num_trees4,random_state=seed)
  results4 = cross_val_score(model4, X, Y, cv=kfold, scoring=scoring)
  print(‘AdaBoost – Accuracy: %f’)%(results4.mean())
  
  非常感谢！
  Sarra
  
  回复
  - Jason Brownlee 2018 年 2 月 4 日上午 5:12 #
    
    默认是 DecisionTreeClassifier，请参见
    https://scikit-learn.cn/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html
    
    回复
Christos Chatzoglou 2016 年 7 月 26 日晚上 10:38 #

写得非常好的帖子！我们能否通过电子邮件向您发送一些关于集成方法的问题？

回复
- Jason Brownlee 2016 年 7 月 27 日上午 5:26 #
  
  谢谢 Christos。
  
  您可以在这里直接联系我
  https://machinelearning.org.cn/contact/
  
  回复
Kamagne 2016 年 9 月 19 日晚上 11:24 #

嗨 Jason，
我复制并粘贴了您的随机森林，结果是
0.766814764183.
我们的结果不一样，您能告诉我为什么吗？
谢谢

回复
- Jason Brownlee 2016 年 9 月 20 日上午 8:33 #
  
  我尝试修复随机数种子 Kamagne，但有时还是会发生。
  
  任何机器学习算法的性能都是随机的，我们估计的是性能范围。最佳实践是多次运行给定的配置，然后取平均值和标准差——报告在未见数据上的预期性能范围。
  
  这有帮助吗？
  
  回复
Natheer Alabsi 2016 年 11 月 18 日下午 1:26 #

集成模型给出的准确率低于单个模型。这是否奇怪？

回复
- Jason Brownlee 2016 年 11 月 19 日上午 8:41 #
  
  这可能会发生。集成模型并非总能提高性能。
  
  回复
Marido 2016 年 12 月 20 日晚上 11:06 #

在您的 Bagging Classifier 中，您使用了 Decision Tree Classifier 作为基础估计器。我想知道还有哪些其他算法可以用作基础估计器？

回复
- Jason Brownlee 2016 年 12 月 21 日上午 8:38 #
  
  好问题 Marido，
  
  对于 Bagging，目标是使用一种在不同数据上训练时具有高方差的方法。
  
  未剪枝的决策树可以做到这一点（并且可以做得更好——参见随机森林）。
  另一个想法可能是使用小 k 值进行 KNN。
  
  事实上，选择您喜欢的算法并将其配置为具有高方差，然后进行 Bagging。
  
  希望这能有所帮助。
  
  回复
Natheer Alabsi 2017 年 1 月 26 日晚上 9:00 #

嗨，Jason，

非常感谢您富有洞察力的回复。

我的理解是，如果集成模型犯的错误不同，它们就会提高结果。
在我下面两个模型的运行结果中。第一个模型在一个类别上表现良好，而第二个模型在另一个类别上表现良好。当我将它们集成时，我得到的准确率较低。这是可能的，还是我做错了什么？

GBC
[[922035 266]

[ 2 5]]

cart
[[895914 26387]

[ 0 7]]

这是我的做法。
estimators = []
model1 = GradientBoostingClassifier()
estimators.append((‘GBC’, model1))
model2 = DecisionTreeClassifier()
estimators.append((‘cart’, model2))

ensemble = VotingClassifier(estimators)
ensemble.fit(X_train, Y_train)
predictions = ensemble.predict(X_test)
accuracy1 = accuracy_score(Y_test, predictions)

回复
- Jason Brownlee 2017 年 1 月 27 日下午 12:04 #
  
  你好 Natheer，
  
  集成模型不保证能提高性能。
  
  也许您可以尝试一种更复杂的组合预测的方法，或者尝试更多或不同的子模型。
  
  回复
Djib 2017 年 1 月 27 日上午 8:41 #

你好 Jason，

非常感谢您的帖子。在 AdaBoost 模型中是否可以包含两个不同的基础估计器（例如，决策树、KNN）？

谢谢你。

回复
- Jason Brownlee 2017 年 1 月 27 日下午 12:27 #
  
  据我所知，在 Python 中不行 Djib。
  
  理论上没有什么不行。您可以开发自己的实现，看看效果如何。
  
  回复
  - Djib 2017 年 1 月 28 日上午 4:49 #
    
    谢谢你，Jason。
    
    回复
Adnan Ardhian 2017 年 3 月 13 日下午 2:06 #

你好 Jason，

为什么 max_features 是 3？它具体是什么意思？谢谢 😀

回复
- Jason Brownlee 2017 年 3 月 14 日上午 8:13 #
  
  仅用于演示目的。它将选定的特征数量限制为 3。
  
  回复
Paige 2017 年 4 月 4 日上午 8:56 #

我发现了一个小失误。在投票集成代码中，我注意到在第 22 和 23 行是

model3 = SVC()
estimators.append((‘svm’, model2))

我认为它应该写成 model3 而不是 model2，因为 model 3 是 SVM 相关的内容。

回复
- Jason Brownlee 2017 年 4 月 4 日上午 9:18 #
  
  谢谢，已修正。
  
  回复
Sam 2017 年 5 月 15 日晚上 11:46 #

嗨！感谢您提供如此出色的帖子。

我想使用投票和 SVM，就像您一样，但是数据缩放对 SVM 能带来更好的结果，而且速度更快。由此产生了一个问题：如何只为 SVM 等算法缩放部分数据，而将未缩放的数据保留给 XGB/随机森林，并在其之上使用集成？我尝试使用 Pipeline 先为 SVM 缩放数据，然后使用投票，但似乎不起作用。任何评论都将有所帮助。

回复
- Jason Brownlee 2017 年 5 月 16 日上午 8:47 #
  
  很好的问题。
  
  您可以抛开 Pipeline，自己将各个部分组合起来，为 SVM 使用缩放版本的数据，为其他方法使用未缩放的数据。
  
  回复
Sayak Paul 2017 年 6 月 15 日晚上 10:02 #

我们能否更进一步，使用 Keras 构建神经网络模型，并将其用于基于投票的集成学习？（在将神经网络模型包装成 Scikit Learn 分类器之后）

回复
- Jason Brownlee 2017 年 6 月 16 日上午 7:54 #
  
  当然，试试看，然后告诉我结果。
  
  回复
Sanga 2017 年 6 月 16 日上午 5:20 #

嗨 Jason… 感谢这篇精彩的帖子。是否有办法对神经网络回归进行 Bagging？如果能提供示例代码或示例将不胜感激。谢谢。

回复
- Jason Brownlee 2017年6月16日上午8:07 #
  
  是的。它可能表现得相当好。抱歉，我没有示例。
  
  回复
Peter 2017年8月21日下午4:15 #

嗨，Jason！

感谢这篇精彩的文章！

我想为卷积神经网络和GRU循环神经网络做软投票，但我遇到了两个问题。

1：我有两个不同的训练数据集来训练我的网络：韵律数据的向量和文本数据的词嵌入。这两个训练集存储在两个不同的np.arrays中，维度不同。是否有任何方法可以让VotingClassifier接受X1和X2，而不是单个X？（y对X1和X2是相同的，而且长度自然也是相同的）

2：在哪里编译我的网络？

ensemble = VotingClassifier(estimators)
ensemble.compile()
?

如果您能提供任何帮助，我将不胜感激。
谢谢！

回复
- Jason Brownlee 2017年8月21日下午4:28 #
  
  你有几种选择。
  
  你可以让每个模型生成预测，将它们保存到文件中，然后让另一个模型学习如何组合预测，可能包含或不包含原始输入。
  
  如果原始输入是高维的（图像和序列），你可以尝试训练一个神经网络，在训练每个子模型的同时组合预测。如果你的子模型也是在Keras中开发的，你可以使用Keras中的Merge层来合并每个网络。
  
  希望这些能作为一个开始有所帮助。
  
  回复
  - Peter 2017年8月22日下午1:05 #
    
    感谢您的快速回复！我已经尝试过层合并。它有效，但效果不佳，因为我的一个特征集产生的识别准确率明显优于另一个。
    
    但第一个解决方案看起来不错！我会尝试实现它！
    
    感谢您的帮助！
    
    回复
    - Jason Brownlee 2017年8月23日上午6:39 #
      
      干得好，Peter！
      
      回复
  - Ruthra 2020年3月29日下午10:29 #
    
    我有一个疑问。上述结果是用于训练模型的准确性。如何找到bagging分类器的测试模型准确性？
    
    from sklearn import model_selection
    from sklearn.ensemble import BaggingClassifier
    from sklearn.tree import DecisionTreeClassifier
    kfold=model_selection.KFold(n_splits=10)
    dt=DecisionTreeClassifier()
    model=BaggingClassifier(base_estimator=dt,n_estimators=10,random_state=5)
    result=model_selection.cross_val_score(model,x,y,cv=kfold)
    
    print(result.mean())
    
    我正在获得训练模型的准确性。但当我尝试获取模型的测试准确性时。我尝试了以下模型。但我遇到了错误。请更正。
    
    from sklearn.metrics import classification_report,confusion_matrix
    from sklearn.metrics import accuracy_score
    print(classification_report(ytest,result.predict(xtest)))
    
    回复
    - Jason Brownlee 2020年3月30日上午5:33 #
      
      不，它使用交叉验证来评估模型。
      https://machinelearning.org.cn/k-fold-cross-validation/
      
      回复
Mehmood 2017年8月25日下午10:14 #

我可以在Bagging和adaboost中使用多个基本估计器吗？例如Bagging（Knn、Logistic Regression等）？

回复
- Jason Brownlee 2017年8月26日上午6:46 #
  
  你可以做任何事情，但实际上这只在bagging中是实用的。
  
  你想选择偏差低/方差高的基本估计器，比如k=1的kNN、不剪枝的决策树或决策桩等。
  
  回复
amar 2017年9月2日下午6:07 #

这里的seed是什么意思？你能解释一下seed的重要性以及seed的一些变化会如何影响模型吗？谢谢

回复
- Jason Brownlee 2017年9月3日上午5:41 #
  
  Seed使示例可重现，这样你就能得到与我相同的结果。
  
  机器学习算法是随机的，这意味着它们每次运行时都会给出不同的结果。这是一个特性，而不是一个bug。有关更多详细信息，请参阅此帖子。
  https://machinelearning.org.cn/randomness-in-machine-learning/
  
  这有帮助吗？
  
  回复
sajana 2017年9月26日下午7:57 #

嗨，先生

我无法在我的数据集上运行梯度提升代码。

请帮帮我。

请看我的参数。

AGE Haemoglobin RBC Hct Mcv Mch Mchc Platelets WBC Granuls Lymphocytes Monocytes disese
3 9.6 4.2 28.2 67 22.7 33.9 3.75 5800 44 50 6 Positive
11 12.1 4.3 33.7 78 28.2 36 2.22 6100 73 23 4 Positive
2 9.5 4.1 27.9 67 22.8 34 3.64 5100 64 32 4 Positive
4 9.9 3.9 27.8 71 25.3 35.6 2.06 4900 65 32 3 Positive
14 10.7 4.4 31.2 70 24.2 34.4 3 7600 50 44 6 Negative
7 9.8 4.2 28 66 23.2 35.1 1.95 3800 28 63 9 Negative
8 14.6 5 39.2 77 28.7 37.2 3.06 4400 58 36 6 Negative
4 12 4.5 33.3 74 26.5 35.9 5.28 9500 40 54 6 Negative
2 11.2 4.6 32.7 70 24.1 34.3 2.98 8800 38 58 4 Negative
1 9.1 4 27.2 67 22.4 33.3 3.6 5300 40 55 5 Negative
11 14.8 5.8 42.5 72 25.1 34.8 4.51 17200 75 20 5 Negative

回复
- Jason Brownlee 2017年9月27日上午5:40 #
  
  问题是什么？
  
  回复
sajana 2017年9月29日上午10:46 #

您好，先生，

问题是，我首先想用SMOTE算法平衡数据集，但它不起作用。

请看我的代码并提供帮助。

import pandas
import matplotlib.pyplot as plt
import seaborn as sns
从 sklearn.datasets 导入 make_classification
from sklearn.decomposition import PCA

from imblearn.over_sampling import SMOTE

print(__doc__)

sns.set()

# 定义绘图的一些颜色
almost_black = ‘#262626’
palette = sns.color_palette()
data = (‘mdata.csv’)
dataframe = pandas.read_csv(data)
array = dataframe.values
X = array[:,0:12]
y = array[:,12]

#print (X_train, Y_train)

# 生成数据集
#X, y = make_classification(n_classes=2, class_sep=2, weights=[0.1, 0.9],
# n_informative=3, n_redundant=1, flip_y=0,
# n_features=10, n_clusters_per_class=1,
# n_samples=500, random_state=10)
print (X, y)
plt.show()

# 实例化一个PCA对象以便于可视化
pca = PCA(n_components=2)
# 对x进行拟合和转换，以便在2D特征空间内可视化
X_vis = pca.fit_transform(X)

# 应用常规SMOTE
sm = SMOTE(kind=’regular’)
X_resampled, y_resampled = sm.fit_sample(X, y)
X_res_vis = pca.transform(X_resampled)

# 两个子图，立即解压坐标轴数组
f, (ax1, ax2) = plt.subplots(1, 2)

ax1.scatter(X_vis[y == 0, 0], X_vis[y == 0, 1], label=”Class #0″, alpha=0.5,
edgecolor=almost_black, facecolor=palette[0], linewidth=0.15)
ax1.scatter(X_vis[y == 1, 0], X_vis[y == 1, 1], label=”Class #1″, alpha=0.5,
edgecolor=almost_black, facecolor=palette[2], linewidth=0.15)
ax1.set_title(‘Original set’)

ax2.scatter(X_res_vis[y_resampled == 0, 0], X_res_vis[y_resampled == 0, 1],
label=”Class #0″, alpha=.5, edgecolor=almost_black,
facecolor=palette[0], linewidth=0.15)
ax2.scatter(X_res_vis[y_resampled == 1, 0], X_res_vis[y_resampled == 1, 1],
label=”Class #1″, alpha=.5, edgecolor=almost_black,
facecolor=palette[2], linewidth=0.15)
ax2.set_title(‘SMOTE ALGORITHM – Malaria regular’)
"""
重采样后的数据
"""
print (X_resampled, y_resampled)
plt.show()

回复
- Jason Brownlee 2017年9月30日上午7:32 #
  
  抱歉，我无法为您调试代码。也许您可以将您的代码发布到stackoverflow上？
  
  回复
sajana 2017年9月29日上午10:55 #

我遇到了错误

File “/usr/local/lib/python2.7/dist-packages/imblearn/over_sampling/smote.py”, line 360, in _sample_regular
nns = self.nn_k_.kneighbors(X_class, return_distance=False)[:, 1:]
File “/home/sajana/.local/lib/python2.7/site-packages/sklearn/neighbors/base.py”, line 347, in kneighbors
(train_size, n_neighbors)
ValueError: Expected n_neighbors <= n_samples, but n_samples = 5, n_neighbors = 6

回复
- Jason Brownlee 2017年9月30日上午7:33 #
  
  看来您的k大于一个类中的实例数。您需要减小k或增加最少代表类的实例数。
  
  希望这能有所帮助。
  
  回复
sajana 2017年10月5日下午7:43 #

我已清除错误，先生。

但是当我处理Gradientboosting时，它不起作用，即使我的数据集包含2个类，如以上讨论所示。

错误：二项式偏差需要2个类

以及代码
import pandas
import matplotlib.pyplot as plt
from sklearn import model_selection
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score
data = (‘dataset160.csv’)
dataframe = pandas.read_csv(data)
array = dataframe.values
X = array[:,0:12]
Y = array[:,12]
print (X, Y)
plt.show()
seed = 7
num_trees = 100
kfold = model_selection.KFold(n_splits=10, random_state=seed)
model = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)
results = model_selection.cross_val_score(model, X, Y, cv=kfold)
print(results.mean())
print(results)

回复
- Jason Brownlee 2017年10月6日上午5:37 #
  
  也许你需要将你的类变量从数字转换为标签。
  
  sklearn有一个你可以使用的标签编码器。
  https://scikit-learn.cn/stable/modules/generated/sklearn.preprocessing.LabelEncoder.html
  
  回复
sajana 2017年10月6日上午11:30 #

先生，我的数据集已经标记了。

我无法在我的数据集上运行梯度提升代码。

请帮帮我。

请看我的参数。

AGE Haemoglobin RBC Hct Mcv Mch Mchc Platelets WBC Granuls Lymphocytes Monocytes disese
3 9.6 4.2 28.2 67 22.7 33.9 3.75 5800 44 50 6 Positive
11 12.1 4.3 33.7 78 28.2 36 2.22 6100 73 23 4 Positive
2 9.5 4.1 27.9 67 22.8 34 3.64 5100 64 32 4 Positive
4 9.9 3.9 27.8 71 25.3 35.6 2.06 4900 65 32 3 Positive
14 10.7 4.4 31.2 70 24.2 34.4 3 7600 50 44 6 Negative
7 9.8 4.2 28 66 23.2 35.1 1.95 3800 28 63 9 Negative
8 14.6 5 39.2 77 28.7 37.2 3.06 4400 58 36 6 Negative
4 12 4.5 33.3 74 26.5 35.9 5.28 9500 40 54 6 Negative
2 11.2 4.6 32.7 70 24.1 34.3 2.98 8800 38 58 4 Negative
1 9.1 4 27.2 67 22.4 33.3 3.6 5300 40 55 5 Negative
11 14.8 5.8 42.5 72 25.1 34.8 4.51 17200 75 20 5 Negative

回复
- Jason Brownlee 2017年10月7日上午5:46 #
  
  也许这个教程可以帮助您入门。
  https://machinelearning.org.cn/machine-learning-in-python-step-by-step/
  
  回复
sajana 2017年10月12日下午7:04 #

谢谢您，先生。
先生，我有一个小疑问。

XGBoost算法是最好的，还是SMOTEBoost算法是处理倾斜数据的最好方法？

回复
- Jason Brownlee 2017年10月13日上午5:45 #
  
  尝试这两种方法在您的特定数据集上，看看哪种效果最好。
  
  回复
sajana 2017年10月19日下午7:27 #

非常感谢您，先生。

最后我有一个疑问，先生。
当我运行adaboost的预测代码时，我的预测准确率为0.0%。

对于代码

model = AdaBoostClassifier(n_estimators=num_trees, random_state=seed)
results = model_selection.cross_val_score(model, X, Y, cv=kfold)
model.fit(X, Y)
print(‘learning accuracy’)
print(results.mean())
predictions = model.predict(A)
print(predictions)
accuracy1 = accuracy_score(B, predictions)
print(“Accuracy % is “)
print(accuracy1*100)

代码有什么问题吗？对于任何集成方法，如boosting、bagging，我总是得到0.0%的准确率、精确率和召回率。
请纠正，先生。

回复
- Jason Brownlee 2017年10月20日上午5:31 #
  
  不清楚。也许可以尝试一系列算法，看看哪种最适合您的问题。我推荐这个过程。
  https://machinelearning.org.cn/machine-learning-performance-improvement-cheat-sheet/
  
  回复
Amos Bunde 2017年11月6日下午8:35 #

Jason博士，您在机器学习方面做得非常棒！

回复
- Jason Brownlee 2017年11月7日上午9:48 #
  
  谢谢 Amos，我真的很感谢您的支持！
  
  回复
Rohith R Nair 2017年11月25日上午1:20 #

嗨，Jason，

非常感谢您写了这篇很棒的文章。您是我的榜样。

有没有办法衡量不同集成方法对性能的影响？

对我来说，VotingClassifier 比其他方法花费的时间更多。如果存在一个度量标准，您能否帮助我识别哪种方法更快，并且在处理大型数据集时对性能的影响最小？

回复
- Jason Brownlee 2017年11月25日上午10:21 #
  
  是的，我推荐一个健壮的测试平台，例如重复交叉验证，请看这里。
  https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
  
  回复
sajana 2017年12月7日上午5:58 #

您能否展示一下如何在数据集上使用CostSensitiveRandomForestClassifier()？
我无法运行代码，先生。

回复
- Jason Brownlee 2017年12月7日上午8:08 #
  
  感谢您的建议。
  
  回复
T.SAJANA 2017年12月11日上午6:31 #

您是否有关于成本敏感集成方法的示例代码？

回复
- Jason Brownlee 2017年12月11日下午4:50 #
  
  目前没有，谢谢您的建议。
  
  回复
Aniket Saxena 2018年1月3日下午4:54 #

嗨，Jason，

我有以下问题：

1.由于bagging方法仅适用于高方差，您不认为在使用bagging时我们实际上在减少过拟合，因为当我们的模型具有低偏差和高方差时就会发生过拟合吗？

2.由于随机森林用于降低bagging方法中个体分类器之间的相关性，那么它是否也通过降低相关性来减少我们模型的过拟合？

3.您能否推荐一种方法来深入研究堆叠聚合（stack aggregation）？

提前感谢。

回复
- Jason Brownlee 2018年1月4日上午8:06 #
  
  Bagging可以减少过拟合。
  
  RF通常比bagging表现更好。
  
  这是一篇关于堆叠的帖子。
  https://machinelearning.org.cn/implementing-stacking-scratch-python/
  
  回复
Max 2018年1月5日上午10:18 #

非常感谢 Jason！一如既往地内容精彩！

我有几个问题

1) 像堆叠（Stacking）这样能够学习如何最佳地加权子模型预测的更高级方法，是否总是比更简单的集成技术能取得更好的结果？

2) 我在您关于堆叠的帖子中读到，如果子模型的预测弱相关，效果会更好。这是否意味着最好从不同的模型家族中训练子模型？（例如：一个SVM模型、一个RF和一个神经网络）
我能否使用XGBoost、LigthGBM、GBM来构建一个使用堆叠的聚合模型？

谢谢！

回复
- Jason Brownlee 2018年1月5日上午11:38 #
  
  不，集成不总是更好，但如果谨慎使用，通常会更好。
  
  是的，不同的模型家族、不同的输入特征等。
  
  当然，你可以尝试任何东西，只要确保你有一个健壮的测试平台。
  
  回复
Max 2018年1月7日上午7:14 #

Jason，谢谢你的回答。我还有两个问题。

1) 我可以使用哪种测试来确保我的集成模型的鲁棒性？

2) 在这种情况下，如何处理不平衡的类？

提前感谢。

回复
- Jason Brownlee 2018年1月8日上午5:39 #
  
  重复交叉验证是评估模型技能的好方法。
  https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
  
  我在这里有一些关于处理不平衡数据的想法。
  https://machinelearning.org.cn/tactics-to-combat-imbalanced-classes-in-your-machine-learning-dataset/
  
  回复
Janio 2018年1月12日上午7:57 #

嗨，Jason，

我有一个关于AdaBoostClassifier特定超参数“base_estimator”的问题。我能否将多个模型（例如：DecisionTreeClassifier、KNeighborsClassifier和SVC）集成到base_estimator超参数中？因为我看到大多数人只实现一个模型，但AdaBoostClassifiers的主要概念是训练不同的分类器集成，通过使用bagging，为分类错误的模型和正确预测的模型赋予更高的权重。基本上，我想知道这是否可以将多个分类器添加到base_estimator超参数中。感谢您的帮助和精彩的帖子！

回复
- Jason Brownlee 2018年1月12日上午11:50 #
  
  也许吧，但我认为不行。我更推荐堆叠或投票。
  
  回复
Magnus 2018年2月14日下午8:51 #

亲爱的 Jason,

我正在使用简单的反向传播神经网络，并带有时间延迟来进行时间序列预测。我的数据严重倾斜，只有少数极端值。当我运行例如20个相同的模型（不是集成），每次运行权重都不同时，我选择验证误差最低的模型。但是问题是，该模型在测试集上的误差可能不是最低的。

所以我认为集成可能会有帮助，但对于神经网络来说，最好的方法是什么？也许您已经在某个地方回答过这个问题了。我想我可以通过平均值或中位数或其他一些度量来处理我的20个模型，但这算集成吗？

感谢分享您的知识！

回复
- Jason Brownlee 2018年2月15日上午8:42 #
  
  您可能需要一种更健壮的模型选择方法，以更好地捕捉模型在样本外数据上的技能。
  
  我这里有一些想法
  https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
  
  回复
harry 2018年3月8日下午5:38 #

我刚在鸢尾花数据集上试用了该分类器，准确率为1.00。我不认为它分类得当。
希望你能帮助我。

回复
- Jason Brownlee 2018年3月9日上午6:20 #
  
  也许可以尝试运行几次示例。这些算法是随机的，有时可能会达到100%的准确率。
  
  回复
Akramou 2018年3月20日上午8:37 #

感谢 Jason 提供有用的教程。
我有一个关于投票集成的问题，我的意思是，平均投票和多数投票（我知道它是如何工作的）有什么区别？但我想要知道在什么情况下我们应用多数投票，对于平均投票也是一样。
另一个问题：通过应用多数投票，是否必须在同一训练集上训练分类器？我正在通过在每次迭代中选择相关特征来更新训练数据集，以提高模型的预测准确性。

回复
- Jason Brownlee 2018年3月20日下午2:42 #
  
  平均值用于回归问题，多数（统计众数）用于分类。
  
  最终，尝试这两种方法，看看哪种最适合您特定的问题和模型。
  
  回复
Jeremy 2018年3月21日上午5:28 #

嗨 Jason，

如果我们有一个依赖于相同输入数据的分类问题和回归问题，是否有可能成功地构建一个同时提供分类和回归输出的神经网络？

如果可能，组合输出的损失和准确性函数如何构建？我们是否必须将损失和准确性函数都加起来？

谢谢你，Jason。

回复
- Jason Brownlee 2018年3月21日上午6:42 #
  
  是的，请看这篇文章
  https://machinelearning.org.cn/keras-functional-api-deep-learning/
  
  回复
  - Jeremy 2018年3月21日下午6:36 #
    
    谢谢你，Jason！我一定会仔细研究的。
    
    回复
pavitra 2018年3月21日下午4:38 #

你好，先生，感谢您写了这篇很棒的帖子。我想知道，在构建了集成分类器之后，如何用新的测试数据对其进行测试？程序是什么？

回复
- Jason Brownlee 2018年3月22日上午6:18 #
  
  请看这篇文章
  https://machinelearning.org.cn/train-final-machine-learning-model/
  
  回复
Saeed Ullah 2018年4月4日下午12:14 #

你好，Jason。谢谢你做得这么好，我正在进行我的硕士研究项目，我正在使用Sklearn的Random Forest，但我必须引用这篇论文“1. Breiman, L., “Random Forests”, Machine Learning. Vol. 45, No. 1, pp. 5–32, 2001。”，即Random Forest的基石论文，他使用了投票方法，但在sklearn文档中，他们给出“与原始出版物[B2001]不同，scikit-learn实现通过平均其概率预测来组合分类器，而不是让每个分类器投票给单个类。”我已经在我的程序中实现了RandomForestClassifier()，并且效果很好。
现在，我的问题是，由于我需要在我的研究论文中写一些关于Random Forest的细节，并且也会解释投票方法，那么我应该使用您上面的“Voting Ensemble”方法还是简单的sklearn实现就可以了？

回复
- Jason Brownlee 2018年4月5日上午5:49 #
  
  这 really 取决于你的目标。
  
  如果你使用sklearn的方法，你必须说明它是如何工作的。
  
  回复
Fatma 2018年4月11日下午4:47 #

嗨，Jason，

我如何为回归问题使用集成机器学习算法？
例如：如何集成两个回归模型，如SVR和线性回归，以提高回归结果？

回复
- Jason Brownlee 2018年4月12日上午8:34 #
  
  与分类一样，只是输出不同。大多数集成算法都适用于回归和分类（例如，随机森林、Bagging、Stacking、投票等）。
  
  你有什么具体问题吗？
  
  回复
  - Fatma 2018年4月12日下午7:14 #
    
    我正在尝试使用 GradientBoostingRegressor 函数来组合两个机器学习算法（线性回归和 SVR 算法）的预测结果，以预测图片的受欢迎程度。据我所知，在回归情况下，它会取结果的平均值而不是投票。我写了以下代码：
    
    # coding: utf-8
    import numpy
    import pandas
    来自 keras.models import Sequential
    from keras.layers import Dense
    from keras.wrappers.scikit_learn import KerasRegressor
    from sklearn.model_selection import cross_val_score,cross_val_predict
    from sklearn.model_selection import KFold
    from sklearn.preprocessing import StandardScaler
    from sklearn.pipeline import Pipeline
    from sklearn import model_selection
    
    from sklearn import metrics
    import matplotlib
    #from matplotlib import pyplot as PLT
    matplotlib.use(‘Agg’)
    import matplotlib.pyplot
    import matplotlib.pyplot as plt
    
    import time
    import cPickle
    #from keras.utils.visualize_util import plot
    
    import os
    import theano
    from PIL import Image
    from numpy import *
    import scipy
    
    import numpy as np
    from sklearn.metrics import mean_squared_error
    from sklearn.datasets import make_friedman1
    from sklearn.ensemble import GradientBoostingRegressor
    from sklearn.linear_model import LinearRegression
    from sklearn.svm import SVR
    from sklearn.model_selection import train_test_split
    import matplotlib.pyplot as plt
    
    # 加载数据集
    dataframe = pandas.read_csv(‘/home/fatmasaid/regression_code/user_features.csv’, delim_whitespace=True, header=None)
    dataset = dataframe.values
    
    # 分割为输入 (X) 和输出 (Y) 变量
    X = dataset[:,0:5]
    Y = dataset[:,5]
    
    seed = 7
    numpy.random.seed(seed)
    kfold = model_selection.KFold(n_splits=10, random_state=seed)
    
    # Initializing models
    lr = LinearRegression()
    svr_lin = SVR(kernel=’linear’)
    
    model1 = GradientBoostingRegressor( lr ,n_estimators=100, learning_rate=0.1, max_depth=1, random_state=seed, loss=’ls’)
    result1 = model_selection.cross_val_score(model1, X, Y, cv=kfold)
    print(result1.mean())
    
    model2 = GradientBoostingRegressor( svr_lin ,n_estimators=100, learning_rate=0.1, max_depth=1, random_state=seed, loss=’ls’)
    result2 = model_selection.cross_val_score(model2, X, Y, cv=kfold)
    print(result2.mean())
    
    # Make cross validated predictions & compute Sperman
    p1 = cross_val_predict(model1, X, Y, cv=kfold)
    plt.scatter(Y, p1)
    print scipy.stats.stats.spearmanr(Y, p1)[0]
    
    p2 = cross_val_predict(model2, X, Y, cv=kfold)
    plt.scatter(Y, p2)
    print scipy.stats.stats.spearmanr(Y, p2)[0]
    
    p = np.mean([p1, p2], axis=0)
    mse = mean_squared_error(Y, p)
    print(“MSE: %.4f” % mse)
    
    我收到以下错误
    
    TypeError: __init__() got multiple values for keyword argument ‘loss’
    
    我不知道我的想法是否正确。所以，如果你们有任何例子，请上传。
    
    谢谢
    
    回复
    - Jason Brownlee 2018年4月13日上午6:38 #
      
      我很乐意提供帮助，但我不能为你调试代码。
      
      也许可以发布到 Stack Overflow？
      
      回复
      - Fatma 2018年4月13日下午6:53 #
        
        你好 Jason，
        
        我已经将代码发布到了 Stack Overflow。你可以在以下链接找到它：
        
        https://stackoverflow.com/questions/49792812/gradient-boosting-regression-algorithm
        
        谢谢
saria 2018年9月3日上午9:58 #

感谢您的大作！
您是否有关于多标签的集成分类器帖子？

回复
- Jason Brownlee 2018年9月3日下午1:36 #
  
  抱歉，我没有多标签分类的例子。
  
  回复
Barnaby 2018年9月8日上午3:44 #

嗨，Jason，

这是一篇很棒的文章！感谢您的分享。

您使用

kfold = model_selection.KFold(n_splits=10, random_state=seed)

来为您的 cross_val_score 计算生成 cv 值。

这对于回归估计量来说真的有必要吗？因为 cross_val_score 和 cross_val_predict 默认就使用了 KFold 来处理回归和其他情况。您的 KFold 实现有什么优势吗？

祝好！

回复
- Jason Brownlee 2018年9月8日上午6:16 #
  
  谢谢。您可以使用任何一种方式。这种方法提供了更多的控制/对正在发生的事情的洞察。
  
  回复
Barnaby 2018年9月8日上午5:29 #

Jason，

另外，您是否使用 VotingClassifier 来组合回归估计量？到目前为止，它似乎只接受整数模型预测，而不是连续的。

谢谢你……

回复
- Jason Brownlee 2018年9月8日上午6:17 #
  
  不，它仅用于分类器。
  
  回复
  - Barnaby 2018年9月8日上午6:18 #
    
    感谢您回答这两个问题，Jason！继续努力。
    
    回复
Simeon Varbanov 2018年10月15日下午5:23 #

亲爱的 Jason,
非常感谢您的博客，它们非常棒。

我有一个任务，不知道如何完成：
1. 我有遗留代码，它做得不太好，看起来像这样：
clf = BaggingRegressor(svm.SVR(C=10.0), n_estimators=64, max_samples=0.9, max_features=0.8)

predicted = cross_val_predict(clf, X_standard, y_standard.ravel(), cv=10, n_jobs=10)
predicted = y_scaler.inverse_transform(predicted)
gMAE, gMRE = evaluate(j, predicted, y[i][j])

在代码中，正如您所见，该人员对 svr 模型进行了 cross_val_predict 以进行训练和预测。

我的任务是使用相同的数据，但使用 dnn 模型进行预测，并证明我的 dnn 模型更好。

鉴于我认为这个项目最初做得不好，我该怎么做？

回复
- Jason Brownlee 2018年10月16日上午6:34 #
  
  我建议开发一套不同的模型，以发现最适合您特定数据集的模型。或许可以从 MLP 开始。
  
  回复
Simeon Varbanov 2018年10月16日上午11:58 #

我有 MLP 模型（在 TF 中完成）。但是，我不知道如何比较它们，因为在我的 TF 模型中，我不使用交叉验证，为了比较结果，我需要使用相同的训练和验证集，而这些集在之前的函数中看起来是随机创建的。我不知道您是否更好地理解了我的问题。

回复
- Jason Brownlee 2018年10月16日下午2:35 #
  
  您可以使用相同的训练/测试集来评估模型。
  
  回复
Gabbiieee 2018年10月26日上午3:11 #

可以使用 decisiontree + adapboost 吗，还是只适用于 bagging？

回复
- Jason Brownlee 2018年10月26日上午5:39 #
  
  是的。
  
  回复

sai 2019年1月5日上午6:35 #

import pandas
import matplotlib.pyplot as plt
from sklearn import model_selection
#from sklearn.ensemble import TreesClassifier
#from sklearn import TreesClassifier()
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
data = ('dataset1.csv')
dataframe = pandas.read_csv(data)
array = dataframe.values

X = array[:,0:12]
Y = array[:,12]
print (X, Y)

seed = 7
num_trees = 100
max_features = 8
kfold = model_selection.KFold(n_splits=10, random_state=seed)
def __init__(self,
                 n_estimators=num_trees,
                 criterion="gini",
                 max_depth=None,
                 min_samples_split=2,
                 min_samples_leaf=1,
                 min_weight_fraction_leaf=0.,
                 max_features="auto",
                 max_leaf_nodes=None,
                 min_impurity_decrease=0.,
                 min_impurity_split=None,
                 bootstrap=False,
                 oob_score=False,
                 n_jobs=None,
                 random_state=None,
                 class_weight=None):
        super(TreesClassifier, self).__init__(
            base_estimator=TreesClassifier(),
            n_estimators=n_estimators,
            estimator_params=("criterion", "max_depth", "min_samples_split",
                              "min_samples_leaf", "min_weight_fraction_leaf",
                              "max_features", "max_leaf_nodes",
                              "min_impurity_decrease", "min_impurity_split",
                              "random_state"),
            bootstrap=bootstrap,
            oob_score=oob_score,
            n_jobs=n_jobs,
            random_state=random_state,
            verbose=verbose,
            warm_start=warm_start,
            class_weight=class_weight)

        self.criterion = criterion
        self.max_depth = max_depth
        self.min_samples_split = min_samples_split
        self.min_samples_leaf = min_samples_leaf
        self.min_weight_fraction_leaf = min_weight_fraction_leaf
        self.max_features = max_features
        self.max_leaf_nodes = max_leaf_nodes
        self.min_impurity_decrease = min_impurity_decrease
        self.min_impurity_split = min_impurity_split

model = TreesClassifier(n_estimators=num_trees)
#criterion="gini", max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0., max_features=max_features, max_leaf_nodes=None, min_impurity_decrease=0., min_impurity_split=None, bootstrap=False, oob_score=False,random_state=None, class_weight=None

#model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)
results = model_selection.cross_val_score(model, X, Y, cv=kfold)
print('cross validation results')
print(results)
print('classification accuracy')
print(results.mean())
model.fit(X, Y)

predictions = model.predict(X)
print("prediction values are ")
print(predictions)

accuracy1 = accuracy_score(Y, predictions)
print("Accuracy % is ")
print(accuracy1*100)

print('confusion matrix is ')
print(confusion_matrix(Y, predictions))
print('classification report is ')
print(classification_report(Y, predictions))

import pandas

import matplotlib.pyplot as plt

from sklearn import model_selection

#from sklearn.ensemble import TreesClassifier

#from sklearn import TreesClassifier()

from sklearn.metrics import accuracy_score

from sklearn.metrics import classification_report

from sklearn.metrics import confusion_matrix

data = 'dataset1.csv'

dataframe = pandas.read_csv(data)

array = dataframe.values

X = array[:,0:12]

Y = array[:,12]

print (X, Y)

seed = 7

num_trees = 100

max_features = 8

kfold = model_selection.KFold(n_splits=10, random_state=seed)

def __init__(self,

n_estimators=num_trees,

criterion="gini",

max_depth=None,

min_samples_split=2,

min_samples_leaf=1,

min_weight_fraction_leaf=0.,

max_features="auto",

max_leaf_nodes=None,

min_impurity_decrease=0.,

min_impurity_split=None,

bootstrap=False,

oob_score=False,

n_jobs=None,

random_state=None,

class_weight=None):

super(TreesClassifier, self).__init__(

base_estimator=TreesClassifier(),

n_estimators=n_estimators,

estimator_params=("criterion", "max_depth", "min_samples_split",

"min_samples_leaf", "min_weight_fraction_leaf",

"max_features", "max_leaf_nodes",

"min_impurity_decrease", "min_impurity_split",

"random_state"),

bootstrap=bootstrap,

oob_score=oob_score,

n_jobs=n_jobs,

random_state=random_state,

verbose=verbose,

warm_start=warm_start,

class_weight=class_weight)

self.criterion = criterion

self.max_depth = max_depth

self.min_samples_split = min_samples_split

self.min_samples_leaf = min_samples_leaf

self.min_weight_fraction_leaf = min_weight_fraction_leaf

self.max_features = max_features

self.max_leaf_nodes = max_leaf_nodes

self.min_impurity_decrease = min_impurity_decrease

self.min_impurity_split = min_impurity_split

model = TreesClassifier(n_estimators=num_trees)

#criterion="gini", max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0., max_features=max_features, max_leaf_nodes=None, min_impurity_decrease=0., min_impurity_split=None, bootstrap=False, oob_score=False,random_state=None, class_weight=None

#model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)

results = model_selection.cross_val_score(model, X, Y, cv=kfold)

print('cross validation results')

print(results)

print('classification accuracy')

print(results.mean())

model.fit(X, Y)

predictions = model.predict(X)

print("prediction values are ")

print(predictions)

accuracy1 = accuracy_score(Y, predictions)

print("Accuracy % is ")

print(accuracy1*100)

print('confusion matrix is ')

print(confusion_matrix(Y, predictions))

print('classification report is ')

print(classification_report(Y, predictions))

先生，我想将 ExtraTreesClassifier 作为用户自定义的内置函数来调用，而不是直接使用它，但它不起作用。您能否建议我如何编写或使用 ExtraTreesClassifier 作为我自己的自定义函数？

Jason Brownlee 2019年1月5日上午7:01 #

抱歉，我没有精力审查你的代码。

回复

Leen Ghannam 2019年1月6日下午11:01 #

你好 Jason，

首先，非常感谢您分享这些精彩的教程。我使用了 Pima Indians 糖尿病数据集，并应用了 MLP 神经网络模型，获得了约 73% 的准确率。现在我想通过集成来提高我的准确率，那么我应该舍弃 MLP，只依赖于树、随机森林等吗？

提前感谢。

回复
- Jason Brownlee 2019年1月7日上午6:34 #
  
  对于给定的数据集，测试一套算法以发现最有效的方法是一个好主意。
  
  回复
Leen 2019年1月6日下午11:31 #

你好 Jason，感谢您分享这些精彩的教程。

请问，在进行了集成并获得了更好的准确率之后，我们如何才能恢复在进行集成之前使用的初始模型中的准确率呢？（如果我的问题看起来很愚蠢，请原谅，我仍然是初学者）

提前感谢

回复
- Jason Brownlee 2019年1月7日上午6:35 #
  
  关键在于集成提供了比单一模型更好的性能。您使用集成来进行预测。
  
  回复
Preetham 2019年2月11日上午2:04 #

如何在 Scikit-learn Python 中使用一个以上的基估计量来进行 Bagging？你们做得很好。

回复
- Jason Brownlee 2019年2月11日上午8:00 #
  
  也许可以使用两个单独的 Bagging 模型，并通过投票来组合它们的预测？
  
  回复
Wizytor 2019年2月23日上午9:15 #

我想以这样的方式对多个二元分类模型进行集成：如果至少有一个模型给出类 1，那么汇总模型也给出 1。我该如何实现？谢谢。

回复
- Jason Brownlee 2019年2月24日上午9:04 #
  
  是的，您可以手动管理投票集成，并使用 if 语句来检查子模型的预测。
  
  回复
Haddar Nourelhouda 2019年3月4日下午8:53 #

嗨！
我需要在简单的 RNN 之后添加一个随机森林分类器，如何做到这一点？
谢谢。

回复
- Jason Brownlee 2019年3月5日上午6:37 #
  
  也许可以收集 RNN 的预测，然后将它们输入到随机森林中？
  
  例如，编写一些代码来实现这一点，而不是直接连接模型。
  
  回复
PC 2019年4月12日下午4:05 #

你好 Jason，一如既往，这篇文章激起了我对机器学习的兴趣。

在实现投票分类器时，为什么每次运行的分数都会发生变化？

回复
- Jason Brownlee 2019年4月13日上午6:21 #
  
  好问题，这是一个常见问题，我在这里回答了。
  https://machinelearning.org.cn/faq/single-faq/why-do-i-get-different-results-each-time-i-run-the-code
  
  回复
Anurag singh 2019年5月9日上午5:03 #

在应用 SMOTE 时，我收到了以下错误：

ValueError 回溯 (最近一次调用)
in
1 sm = SMOTE(random_state=2)
—-> 2 X_train_res, y_train_res = sm.fit_sample(X,y)

~\Anaconda3\lib\site-packages\imblearn\base.py in fit_resample(self, X, y)
83 self.sampling_strategy, y, self._sampling_type)
84
—> 85 output = self._fit_resample(X, y)
86
87 if binarize_y

~\Anaconda3\lib\site-packages\imblearn\over_sampling\_smote.py in _fit_resample(self, X, y)
794 def _fit_resample(self, X, y)
795 self._validate_estimator()
–> 796 return self._sample(X, y)
797
798 def _sample(self, X, y)

~\Anaconda3\lib\site-packages\imblearn\over_sampling\_smote.py in _sample(self, X, y)
810
811 self.nn_k_.fit(X_class)
–> 812 nns = self.nn_k_.kneighbors(X_class, return_distance=False)[:, 1:]
813 X_new, y_new = self._make_samples(X_class, y.dtype, class_sample,
814 X_class, nns, n_samples, 1.0)

~\Anaconda3\lib\site-packages\sklearn\neighbors\base.py in kneighbors(self, X, n_neighbors, return_distance)
414 “Expected n_neighbors 416 (train_size, n_neighbors)
417 )
418 n_samples, _ = X.shape

ValueError: Expected n_neighbors <= n_samples, but n_samples = 5, n_neighbors = 6

回复
- Jason Brownlee 2019年5月9日上午6:48 #
  
  抱歉，我无法为您调试代码。
  
  回复
Sunny 2019年5月9日下午5:00 #

如何解决这个错误？

“sampling_strategy”只能是浮点数，当目标类型为“
‘ 二进制。对于多类别，使用字典。

我该如何将我的浮点对象转换为字典？

回复
- Jason Brownlee 2019年5月10日上午8:11 #
  
  抱歉，我以前没见过这个错误。
  
  也许将您的代码和错误发布到 stackoverflow？
  
  回复
jackman_ 2019年7月29日下午6:44 #

@Anurag singh

根据您遇到的问题，您可能需要调整 SMOTE 函数中的参数：k_neighbors 以适应您的情况（例如，sm=SMOTE(k_neighbors=1)）。

希望我能帮助您解决问题。

回复
- Jason Brownlee 2019年7月30日上午6:06 #
  
  感谢分享。
  
  回复
Max 2019年9月27日下午7:08 #

写得很好，Jason。

我偶然发现了这篇文章，因为我正在尝试实现一个投票分类器。
我有三个问题，希望您有时间回答。
我对此还不太熟悉，所以如果我的问题听起来很愚蠢，请原谅。
_________________________________________________________________
===============================================================
问题 #1 - 我将集成器视为一个新分类器，其得分高于其他分类器。我尝试实现投票分类器来得到 (yhat)，但失败了。

ensemble=VotingClassifier(estimators)
results = cross_val_score (ensemble, X, y , cv=5)
print (“集成器准确率 =”,results.mean())
yhat_ensemble=ensemble.predict(x_test)

最后一步出现了以下错误：
((NotFittedError: 此 VotingClassifier 实例尚未拟合。在使用此方法之前，请调用“fit”并提供适当的参数。))
_________________________________________________________________
==============================================================
问题 #2 - 是否有任何方法可以使用集成器（通过软投票=True）找到概率？

即使用以下命令：
yhat_prob_ensemble = ensemble.predict.proba(x_test)

这也给了我与上面相同的 (NotFittedError) 错误。
_________________________________________________________________
==============================================================
问题 #3 - 分类器的交叉验证得分高于集成器是否正常？

我的逻辑回归得分是 0.8，朴素贝叶斯是 0.73，决策树是 0.71，而集成器的得分是 0.74。
_________________________________________________________________
==============================================================

回复
- Max 2019年9月27日下午7:20 #
  
  亲爱的 Jason,
  
  正如我之前所说，请原谅我愚蠢的问题，我已经通过再次拟合新的集成器解决了问题 1 和 2。我之前的理解是，拟合已经完成（与原始分类器一起），因此我们不能再次进行。缺失的一行是：
  
  ensemble = ensemble.fit(X_train, y_train)
  
  然而，问题 #3 仍然存在，我希望您能花时间回答。
  谢谢
  
  回复
  - Jason Brownlee 2019年9月28日上午6:15 #
    
    很高兴听到这个，Max。
    
    回复
- Jason Brownlee 2019年9月28日上午6:14 #
  
  这很奇怪，看起来你正在正确使用 VotingClassifier。
  
  也许尝试调试——例如，使用不同的模型，使用不同的集成，使用模型子集，等等，尝试找出错误的根源。
  
  通常，只有当集成器的性能优于任何单一模型时，您才希望采用它。否则，就继续前进。
  
  回复
- nora 2020年1月21日下午6:58 #
  
  我有 6 个特征子集，我在它们上运行了不同的机器学习技术并获得了结果。我如何使用 Python 将它们组合成一个集成模型？
  您能告诉我怎么做吗？
  
  回复
  - Jason Brownlee 2020年1月22日上午6:19 #
    
    也许可以使用硬投票或软投票。
    
    回复
shadia 2019年11月10日上午3:09 #

你好 Jason，谢谢你的帖子。
我想知道在随机森林中，为什么你没有拟合模型？

回复
- Jason Brownlee 2019年11月10日上午8:23 #
  
  抱歉，我不明白。您能详细说明您的问题吗？
  
  回复
  - shadia 2019年11月10日下午9:57 #
    
    我的意思是，为什么你没有写：
    classifier.fit(X_train,y_train)
    在你的代码里？
    
    回复
    - Jason Brownlee 2019年11月11日上午6:08 #
      
      因为我们使用交叉验证对模型进行了多次评估。例如，fit 是在交叉验证过程中调用的。
      
      这有帮助吗？
      
      回复
shadia 2019年11月10日上午4:39 #

我尝试运行随机森林代码，num_trees = 50，因为如果我使用 100，程序就会停止运行。
它给了我：0.056247265097497987
我不知道错在哪里。

回复
- Jason Brownlee 2019年11月10日上午8:27 #
  
  也许这会有帮助。
  https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
  
  回复
Niharika 2019年11月13日上午1:51 #

你好，

我正在做一个机器学习项目。我的数据都是关于交易（开盘价、最高价、收盘价、最低价）等等。我根据这些列构建了一些技术指标。我的主要目标是预测市场阶段（上涨、下跌、横盘）。我有大约 15,000 行数据来训练模型。我认为这个问题属于分类问题。所以我一直在使用各种分类算法，但它们的准确率只有 40-50%。我想将它们提高到 70%。请告诉我如何提高准确率。

测试准确率约为 90%，但当我将模型应用于真实数据时，它的准确率约为 40%。

回复
- Jason Brownlee 2019年11月13日上午5:48 #
  
  看这里
  https://machinelearning.org.cn/faq/single-faq/can-you-help-me-with-machine-learning-for-finance-or-the-stock-market
  
  回复
Niharika 2019年11月14日上午1:32 #

哈哈！没关系！谢谢 🙂

回复
- Jason Brownlee 2019年11月14日上午8:05 #
  
  不客气。
  
  回复
Raju 2019年12月14日上午4:14 #

你好 Jason，我想应用带有 LSTM 的装袋，你能给我一些想法或相关链接吗？

- 提前感谢

回复
- Jason Brownlee 2019年12月14日上午6:25 #
  
  是的，请参阅此处有关集成与深度学习的教程。
  https://machinelearning.org.cn/start-here/#better
  
  回复
nora 2020年1月20日下午4:11 #

你好 Jason，如果我想应用随机子空间技术作为第一层，然后应用集成技术。您是否有任何 Python 材料可供学习？

回复
- Jason Brownlee 2020年1月21日上午7:07 #
  
  没有，抱歉。
  
  回复
Sumaiya Pathan 2020年3月10日上午4:45 #

你好 Jason，我想对集成分类器进行 K 折交叉验证，并使用动态选择 (DS) 方法。您能否为我提供一些想法或相关链接？

回复
- Jason Brownlee 2020年3月10日上午5:43 #
  
  什么是“动态选择方法”？
  
  回复
Ehsan 2020年4月19日上午1:52 #

你好 Jason，有没有办法绘制所有集成成员以及最终模型？例如，我想绘制决策树回归基模型的所有集成成员。

回复
- Jason Brownlee 2020年4月19日上午5:59 #
  
  也许可以，我没有示例，抱歉。
  
  回复
  - Ehsan 2020年4月19日下午5:58 #
    
    我不是在寻找示例，只是想知道在拟合之后（在 sklearn 中）是否可以单独访问集成成员的结果（模型）？
    
    回复
    - Jason Brownlee 2020年4月20日上午5:25 #
      
      也许可以查看 API 或准备一个原型并直接发现答案——在几分钟内。
      
      回复
Nuwan C 2020年5月5日上午5:40 #

嗨，Json，

在使用 AdaBoost 时，我遇到了以下错误：

ValueError: 未知标签类型：'continuous'

可能是什么原因？请帮帮我。

谢谢你

回复
- Jason Brownlee 2020年5月5日上午6:36 #
  
  这表明您试图预测的变量是数值型的，而不是类别标签。
  
  也许您需要在建模前准备好数据。
  
  回复
Nuwan C 2020年5月5日下午1:16 #

嗨，Jason，

我找到了，是因为分配的标签是一个连续值。

顺便说一句，通过使用 K 折交叉验证和训练-测试拆分方法得到的模型（AdaBoost）准确率给出了不同的数字。

K 折交叉验证 – ~90%
训练-测试拆分 – 过拟合 100%（测试准确率 ~ 98%）

对此有什么看法？请帮助。

谢谢你。
Nuwan C

回复
- Jason Brownlee 2020年5月5日下午1:37 #
  
  是的，训练/测试拆分很可能是乐观的。
  
  对于小数据集，重复的 k 折交叉验证可以更准确地估计模型性能。
  
  回复
Nuwan C 2020年5月5日下午2:41 #

感谢您的回复，Jason。

干杯！！！

回复
- Jason Brownlee 2020年5月6日上午6:20 #
  
  不客气！
  
  回复
sarah 2020年5月28日下午9:06 #

嗨，Jason，

我想为时间序列预测问题构建一个集成模型，我应该使用这里列出的相同技术吗？

非常感谢您提供的信息丰富的网站。

回复
- Jason Brownlee 2020年5月29日上午6:29 #
  
  也许可以尝试一下，看看它们是否能提高您数据集的性能。
  
  回复
Ms.Arul 2020年10月24日下午9:19 #

尊敬的先生，
非常感谢您的教程。我将您的代码用于我的数据集。它运行良好，在实现所有分类器时都能获得 100% 的准确率。这是过拟合问题吗？请澄清。谢谢。

回复
- Jason Brownlee 2020年10月25日上午7:03 #
  
  如果您在留出数据集上获得 100%，则没有过拟合。
  
  另外，如果您在任何问题上都获得 100% 的准确率，那可能太简单了，不需要机器学习。
  
  回复
Nastaran 2021年3月17日下午3:08 #

感谢您的精彩解释。

一个问题：如果我有相同长度和标签的不同数据，并为每种数据使用各种分类器，最后想要融合它们的结果，我可以使用类似的方法吗？如果是，怎么做？您有相关文档吗？

回复
- Jason Brownlee 2021年3月18日上午5:15 #
  
  抱歉，我不明白您的问题。您能详细说明或重新表述一下吗？
  
  回复
Ankit Ganeshpurkar 2021年3月18日下午7:33 #

在 sklearn 的装袋和提升中可以使用哪些基估计量？

回复
- Jason Brownlee 2021年3月19日上午6:19 #
  
  我认为您可以装袋任何模型。提升可能只适用于树。
  
  回复
Baibhav Nag 2021年4月28日下午11:46 #

嗨 Jason
我想融合两个 mlps 和两个 cnns。但我一直无法做到。请帮忙。

回复
- Jason Brownlee 2021年4月29日上午6:28 #
  
  也许可以先尝试平均它们的预测。
  
  回复
Sal 2021年5月22日上午4:31 #

你好 Jason，你能告诉我 sklearn 的装袋分类器是如何计算最终预测得分的，以及它使用了哪种投票方法吗？

回复
- Jason Brownlee 2021年5月22日上午5:34 #
  
  好问题，请看这里：
  https://machinelearning.org.cn/bagging-ensemble-with-python/
  
  回复
Ahmad 2021年7月29日上午8:01 #

你好 Jason，感谢您的精彩教程！
我想应用 BERT、Elmo 和 ULMFit 语言模型的融合分类器，

我能以您应用的方式进行吗？

融合分类器和集成分类器是相同的吗？可以使用 votingclassifier() 还是不同？

回复
- Jason Brownlee 2021年7月30日上午6:25 #
  
  也许可以尝试一下。
  
  回复

导航

使用 scikit-learn 在 Python 中实现集成机器学习算法

将模型预测组合成集成预测

需要 Python 机器学习方面的帮助吗？

关于食谱

Bagging 算法

1. 装袋决策树

2. 随机森林

3. Extra Trees

Boosting 算法

1. AdaBoost

2. Stochastic Gradient Boosting（随机梯度提升）

Voting Ensemble（投票集成）

总结

发现 Python 中的快速机器学习！

在几分钟内开发您自己的模型

最终将机器学习带入
您自己的项目

关于此主题的更多信息

Python 和 scikit-learn 集成机器学习算法的 164 条回复

留下回复点击此处取消回复。

导航

将模型预测组合成集成预测

需要 Python 机器学习方面的帮助吗？

关于食谱

Bagging 算法

1. 装袋决策树

2. 随机森林

3. Extra Trees

Boosting 算法

1. AdaBoost

2. Stochastic Gradient Boosting（随机梯度提升）

Voting Ensemble（投票集成）

总结

发现 Python 中的快速机器学习！

在几分钟内开发您自己的模型

最终将机器学习带入您自己的项目

关于此主题的更多信息

Python 和 scikit-learn 集成机器学习算法的 164 条回复

留下回复 点击此处取消回复。

最终将机器学习带入
您自己的项目

留下回复点击此处取消回复。