如何组合集成学习的预测
原文：https://machinelearningmastery.com/combine-predictions-for-ensemble-learning/
最后更新于 2021 年 4 月 27 日
集合方法包括组合来自多个模型的预测。
预测的组合是集合方法的核心部分，并且在很大程度上取决于对集合有贡献的模型类型和正在建模的预测问题的类型，例如分类或回归。
尽管如此，仍有一些通用或标准的技术可用于组合预测，这些技术易于实现，通常会产生良好或最佳的预测表现。
在这篇文章中，您将发现组合集成学习预测的常用技术。
看完这篇文章，你会知道:
- 组合来自贡献模型的预测是集合模型的关键属性。
- 投票技术最常用于组合预测进行分类。
- 统计技术最常用于组合回归预测。
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
如何为集成学习组合预测
图片由 cafuego 提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 集成学习中的组合预测
- 组合分类预测
- 组合预测的类别标签
- 组合预测的类概率
- 组合回归预测
集成学习中的组合预测
集成学习方法的一个关键部分包括组合来自多个模型的预测。
正是通过这些预测的组合，实现了集成学习方法的好处，即更好的预测表现。因此，有许多方法可以组合预测，以至于它是一个完整的研究领域。
在生成一组基础学习器之后，集成方法不是试图找到最佳的单个学习器，而是求助于组合来实现强大的泛化能力，其中组合方法起着至关重要的作用。
—第 67 页，集合方法，2012。
标准的集成机器学习算法确实规定了如何组合预测；然而，出于一些原因，必须孤立地考虑这一专题，例如:
- 解释由标准集合算法做出的预测。
- 为算法手动指定自定义预测组合方法。
- 发展你自己的集成方法。
集成学习方法通常不是很复杂，开发您自己的集成方法或指定组合预测的方式是相对容易和常见的做法。
组合预测的方式取决于进行预测的模型和预测问题的类型。
该步骤中使用的策略部分取决于用作集成成员的分类器的类型。例如，一些分类器，如支持向量机，只提供离散值的标签输出。
—第 6 页，集成机器学习，2012。
例如，由模型做出的预测的形式将匹配预测问题的类型，例如用于预测数字的回归和用于预测类别标签的分类。此外，一些模型类型可能只能预测类别标签或类别概率分布，而其他模型类型可能能够支持分类任务的两者。
我们将使用这种基于问题类型的预测类型划分，作为探索用于在集合中组合来自贡献模型的预测的常用技术的基础。
在下一节中，我们将了解如何为分类预测建模任务组合预测。
组合分类预测
分类是指预测建模问题，包括预测给定输入的类别标签。
由模型做出的预测可以是直接清晰的类标签，或者可以是一个示例属于每个类的概率，称为类成员的概率。
分类问题的表现通常使用准确性或相关计数或正确预测的比率来衡量。在评估预测概率的情况下，可以通过选择截止阈值将它们转换为清晰的类别标签，或者使用专门的度量来评估，例如交叉熵。
我们将回顾分别为类别标签和概率组合分类预测。
组合预测的类别标签
预测的类标签通常被映射到对问题域有意义的东西。
例如，模型可以预测诸如“红色或“绿色的颜色”。不过，在内部，该模型预测类标签的数字表示，例如 0 代表“红色”，1 代表“绿色”，2 代表“蓝色”作为我们的颜色分类示例。
如果我们直接使用整数编码的类标签，组合类标签的方法可能更容易考虑。
也许最简单、最常见、通常也是最有效的方法是通过投票将预测结合起来。
投票是标称输出最流行和最基本的组合方法。
—第 71 页，集合方法，2012。
投票通常涉及做出预测的每个模型，为预测的类分配一个投票。计算选票，然后以某种方式使用选票或计票来选择结果。
投票有很多种类型，让我们来看看最常见的四种:
- 多数投票。
- 多数投票。
- 一致投票。
- 加权投票。
简单投票，称为多数投票，选择票数最多的班级标签。
如果两个或两个以上的班级拥有相同的票数，那么平局会被任意打破，尽管是以一致的方式，例如对有平局的班级标签进行排序并选择第一个，而不是随机选择一个。这一点很重要，这样，具有相同数据的相同模型总是做出相同的预测。
给定联系，通常会有奇数个集成成员试图自动断开联系，而偶数个集成成员可能更有可能断开联系。
从统计学的角度来看，这被称为模式或预测集合中最常见的值。
例如，考虑一个模型对三类颜色预测问题所做的三个预测:
- 模型 1 预测“绿色或 1。
- 模型 2 预测“绿色或 1。
- 模型 3 预测“红色或 0。
因此，投票结果如下:
- 红色票:1
- 绿色投票:2
- 蓝色选票:0
鉴于它拥有最多的选票，预测将是绿色的。
多数票选择得票超过半数的班级标签。如果没有一个班级拥有超过半数的选票，那么就产生了一个“无预测”。有趣的是，如果分类器是独立的，多数投票可以被证明是组合分类器的最佳方法。
如果分类器输出是独立的，那么可以证明多数投票是最优组合规则。
—第 1 页，集成机器学习，2012。
一致投票与多数投票相关，因为该方法不需要一半的票数，而是要求所有模型预测相同的值，否则不做预测。
加权投票以某种方式对每个模型做出的预测进行加权。一个例子是根据模型的平均表现(如分类准确率)对预测进行加权。
每个分类器的权重可以设置成与其在验证集上的准确性表现成比例。
—第 67 页，使用集成方法的模式分类，2010。
给分类器分配权重本身可能成为一个项目，可能涉及使用优化算法和保持数据集、线性模型，甚至完全使用另一个机器学习模型。
那么，我们如何分配权重呢？如果我们事先知道哪些分类器会更好地工作，我们只会使用那些分类器。在缺乏此类信息的情况下，一种合理且常用的策略是使用分类器在单独验证(甚至训练)数据集上的表现，作为该分类器泛化表现的估计。
—第 8 页，集成机器学习，2012。
加权投票的想法是，一些分类器比其他分类器更有可能准确，我们应该通过给他们更大份额的选票来奖励他们。
如果我们有理由相信某些分类器比其他分类器更有可能是正确的，那么与多数投票相比，对这些分类器的决策进行更重的加权可以进一步提高整体表现。
—第 7 页，集成机器学习，2012。
组合预测的类概率
概率将事件的可能性总结为 0.0 到 1.0 之间的数值。
当预测类别成员资格时，它涉及为每个类别分配的概率，加起来等于值 1.0；例如，模型可以预测:
- 红色:0.75
- 绿色:0.10
- 蓝色:0.15
我们可以看到类“红色”具有最高的概率或者是模型预测的最可能的结果，并且类之间的概率分布(0.75 + 0.10 + 0.15)总和为 1.0。
概率的组合方式取决于所需的结果。
例如，如果需要概率，则可以直接组合独立的预测概率。
也许最简单的概率组合方法是将每个类的概率相加，并通过 softmax 函数传递预测值。这确保了分数被适当地标准化，这意味着类标签上的概率总和为 1.0。
……这样的输出——经过适当的标准化(如 softmax 标准化…])——可以解释为对该类的支持程度
—第 8 页，集成机器学习，2012。
更常见的是，我们希望根据预测的概率来预测类别标签。
最常见的方法是使用投票，其中预测概率代表每个模型对每个类别的投票。然后对投票进行求和，可以使用上一节中的投票方法，例如选择具有最大求和概率或最大平均概率的标签。
- 使用平均概率投票
- 使用总和概率投票
- 使用加权和概率投票
通常，这种将概率视为选择类别标签的投票的方法被称为软投票。
如果所有的单个分类器被同等对待，简单软投票方法通过简单地平均所有的单个输出来产生组合输出…
—第 76 页，集合方法，2012。
组合回归预测
回归是指预测建模问题，包括预测给定输入的数值。
回归问题的表现通常使用平均误差来衡量，例如平均绝对误差或均方根误差。
组合数字预测通常涉及使用简单的统计方法；例如:
- 平均预测值
- 预测值中位数
两者都给出了预测分布的中心趋势。
求平均值是数字输出最流行和最基本的组合方法。
—第 68 页，集合方法，2012。
平均值也称为平均值，是预测值的归一化总和。当预测的分布是高斯或近似高斯时，平均预测值更合适。
例如，平均值计算为预测值之和除以预测总数。如果三个模型预测了以下价格:
- 型号 1: 99.00
- 型号 2: 101.00
- 型号 3: 98.00
预测的平均值计算如下:
- 平均预测= (99.00 + 101.00 + 98.00) / 3
- 平均预测= 298.00 / 3
- 平均预测= 99.33
由于简单有效，简单平均法是最常用的方法之一，在许多实际应用中是首选。
—第 69 页，集合方法，2012。
如果所有预测都是有序的，中位数是中间值，也称为第 50 个百分点。当预测的分布未知或不遵循高斯概率分布时，中值预测值更适合使用。
根据预测问题的性质，可能需要保守预测，例如最大值或最小值。此外，可以总结分布以给出不确定性的度量，例如为每个预测报告三个值:
- 最小预测值
- 预测值中位数
- 最大预测值
与分类一样，每个模型做出的预测可以通过预期的模型表现或其他值进行加权，并且可以报告预测的加权平均值。
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
书
- 使用集成方法的模式分类，2010。
- 集成方法，2012。
- 集成机器学习，2012。
- 数据挖掘中的集成方法，2010。
文章
- 一起学习，维基百科。
- 一起学习，学院派。
摘要
在这篇文章中，您发现了组合集成学习预测的常用技术。
具体来说，您了解到:
- 组合来自贡献模型的预测是集合模型的关键属性。
- 投票技术最常用于组合预测进行分类。
- 统计技术最常用于组合回归预测。
你有什么问题吗？
在下面的评论中提问，我会尽力回答。
Python 中的动态分类器选择集成
原文：https://machinelearningmastery.com/dynamic-classifier-selection-in-python/
最后更新于 2021 年 4 月 27 日
动态分类器选择是一种用于分类预测建模的集成学习算法。
该技术包括在训练数据集上拟合多个机器学习模型，然后基于要预测的示例的具体细节，选择在进行预测时预期表现最佳的模型。
这可以通过使用 k-最近邻模型来定位训练数据集中最接近要预测的新示例的示例，评估该邻域上池中的所有模型，并使用在该邻域上表现最好的模型来对新示例进行预测来实现。
因此，动态分类器选择通常可以比池中的任何单个模型表现得更好，并且提供了对来自多个模型的预测进行平均的替代方案，正如在其他集成算法中的情况一样。
在本教程中，您将发现如何在 Python 中开发动态分类器选择集成。
完成本教程后，您将知道:
- 动态分类器选择算法从许多模型中选择一个来为每个新的例子做出预测。
- 如何使用 Sklearn API 为分类任务开发和评估动态分类器选择模型。
- 如何探索动态分类器选择模型超参数对分类准确率的影响？
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
如何在 Python 中开发动态分类器选择
图片由 Jean 和 Fred 提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 动态分类器选择
- 基于 Sklearn 的动态分类器选择
- 具有整体局部准确率的集散控制系统
- 具有本地等级准确率的分布式控制系统
- 集散控制系统的超参数整定
- 在 k-最近邻中探索 k
- 探索分类器池的算法
动态分类器选择
多分类器系统是指机器学习算法的一个领域，它使用多个模型来解决分类预测建模问题。
这包括熟悉的技术，如一对其余，一对所有，和输出纠错码技术。它还包括更通用的技术，为每个需要预测的新示例选择一个动态使用的模型。
目前有几种方法被用来构建一个监控系统[……]最有前途的监控系统方法之一是动态选择，即根据每个要分类的新样本动态选择基本分类器。
——动态分类器选择:最新进展与展望，2018。
有关这些类型的多分类器系统的更多信息，请参见教程:
这些方法通常被称为:动态分类器选择，简称 DCS。
- 动态分类器选择:从众多训练好的模型中选择一个，根据输入的具体细节进行预测的算法。
考虑到分布式控制系统中使用了多个模型，它被认为是一种集成学习技术。
动态分类器选择算法通常涉及以某种方式划分输入特征空间，并分配特定的模型来负责为每个划分做出预测。有各种不同的分布式控制系统算法，研究工作主要集中在如何评估和分配分类器到输入空间的特定区域。
在训练多个个体学习器之后，分布式控制系统为每个测试实例动态选择一个学习器。[……]分布式控制系统通过使用单个学习器进行预测。
—第 93 页，集成方法:基础和算法，2012。
早期流行的方法包括首先在训练数据集上拟合一组小的、多样的分类模型。当需要预测时，首先使用 k-最近邻(kNN)算法从训练数据集中找到与该示例匹配的 k 个最相似的示例。然后，在 k 个训练示例的邻居上评估模型中的每个先前匹配的分类器，并且选择表现最好的分类器来对新示例进行预测。
这种方法被简称为“动态分类器选择局部准确率”或简称为 DCS-LA，由 Kevin Woods 等人在 1997 年发表的题为“使用局部准确率估计的多分类器组合”的论文中进行了描述
其基本思想是在未知测试样本周围的特征空间局部区域内估计每个分类器的准确率，然后使用局部准确率最高的分类器的判决。
——使用局部准确率估计的多个分类器的组合，1997。
作者描述了选择单个分类器模型来对给定输入示例进行预测的两种方法，它们是:
- 局部准确率，通常称为 LA 或整体局部准确率(OLA)。
- 类准确率，通常称为 CA 或局部类准确率(LCA)。
局部准确率 (OLA)涉及在 k 个训练示例的邻域上评估每个模型的分类准确率。然后选择在该邻域中表现最好的模型来为新示例进行预测。
每个分类器的 OLA 被计算为局部区域中样本的正确识别的百分比。
——量词的动态选择——综述，2014。
类准确率 (LCA)包括使用每个模型对新示例进行预测，并记录预测的类。然后，评估 k 个训练示例的邻居上的每个模型的准确性，并且选择对于它在新示例上预测的类具有最佳技能的模型，并且返回它的预测。
每个基本分类器的生命周期评估被估计为局部区域内正确分类的百分比，但是只考虑那些分类器给出的类与未知模式给出的类相同的例子。
——量词的动态选择——综述，2014。
在这两种情况下，如果所有拟合模型对新的输入示例进行相同的预测，则直接返回预测。
现在我们已经熟悉了 DCS 和 DCS-LA 算法，让我们看看如何在我们自己的分类预测建模项目中使用它。
基于 Sklearn 的动态分类器选择
动态集成选择库(简称 DESlib)是一个开源 Python 库，它提供了许多不同的动态分类器选择算法的实现。
DESlib 是一个易于使用的集成学习库，专注于实现动态分类器和集成选择的最新技术。
首先，我们可以使用 pip 包管理器来安装 DESlib 库。
sudo pip install deslib
安装后，我们可以通过加载库并打印已安装的版本来确认库安装正确并准备好使用。
# check deslib version
import deslib
print(deslib.__version__)
运行该脚本将打印您安装的 DESlib 库的版本。
您的版本应该相同或更高。如果没有，您必须升级您的 DESlib 库版本。
0.3
DESlib 分别通过 OLA 和 LCA 类为每个分类器选择技术提供了分布式控制系统-学习算法的实现。
每个类都可以直接用作 Sklearn 模型，允许直接使用全套 Sklearn 数据准备、建模管道和模型评估技术。
这两个类都使用 k 最近邻算法来选择默认值为 k=7 的邻居。
决策树的自举聚合(装袋)集成被用作为默认进行的每个分类考虑的分类器模型池，尽管这可以通过将“ pool_classifiers ”设置为模型列表来改变。
我们可以使用 make_classification()函数创建一个包含 10，000 个示例和 20 个输入特征的合成二进制分类问题。
# synthetic binary 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,)
现在我们已经熟悉了 DESlib API，让我们来看看如何使用每个 DCS-LA 算法。
具有整体局部准确率的集散控制系统
我们可以在合成数据集上使用整体局部准确率来评估分布式控制系统-洛杉矶模型。
在这种情况下，我们将使用默认的模型超参数，包括袋装决策树作为分类器模型池，以及一个 k=7 用于在进行预测时选择局部邻域。
我们将使用三次重复和 10 次折叠的重复分层 k 折叠交叉验证来评估模型。我们将报告所有重复和折叠的模型准确率的平均值和标准偏差。
下面列出了完整的示例。
# evaluate dynamic classifier selection DCS-LA with overall local accuracy
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from deslib.dcs.ola import OLA
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
model = OLA()
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到带有 OLA 和默认超参数的 DCS-LA 达到了大约 88.3%的分类准确率。
Mean Accuracy: 0.883 (0.012)
我们也可以用带有 OLA 的 DCS-LA 模型作为最终模型，进行分类预测。
首先，模型适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。
下面的示例在我们的二进制类别数据集上演示了这一点。
# make a prediction with DCS-LA using overall local accuracy
from sklearn.datasets import make_classification
from deslib.dcs.ola import OLA
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
model = OLA()
# fit the model on the whole dataset
model.fit(X, y)
# make a single prediction
row = [0.2929949,-4.21223056,-1.288332,-2.17849815,-0.64527665,2.58097719,0.28422388,-7.1827928,-1.91211104,2.73729512,0.81395695,3.96973717,-2.66939799,3.34692332,4.19791821,0.99990998,-0.30201875,-4.43170633,-2.82646737,0.44916808]
yhat = model.predict([row])
print('Predicted Class: %d' % yhat[0])
运行该示例使 DCS-LA 与 OLA 模型在整个数据集上匹配，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。
Predicted Class: 0
现在我们已经熟悉了将 DCS-LA 与 OLA 一起使用，让我们来看看 LCA 方法。
具有本地等级准确率的分布式控制系统
我们可以在合成数据集上使用局部类准确率来评估分布式控制系统-人工智能模型。
在这种情况下，我们将使用默认的模型超参数，包括袋装决策树作为分类器模型池，以及一个 k=7 用于在进行预测时选择局部邻域。
我们将使用三次重复和 10 次折叠的重复分层 k 折叠交叉验证来评估模型。我们将报告所有重复和折叠的模型准确率的平均值和标准偏差。
下面列出了完整的示例。
# evaluate dynamic classifier selection DCS-LA using local class accuracy
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from deslib.dcs.lca import LCA
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
model = LCA()
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到带有生命周期评估和默认超参数的分布式控制系统达到了大约 92.2%的分类准确率。
Mean Accuracy: 0.922 (0.007)
我们也可以使用带有生命周期评估的分布式控制系统-洛杉矶模型作为最终模型，并进行分类预测。
首先，模型适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。
下面的示例在我们的二进制类别数据集上演示了这一点。
# make a prediction with DCS-LA using local class accuracy
from sklearn.datasets import make_classification
from deslib.dcs.lca import LCA
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
model = LCA()
# fit the model on the whole dataset
model.fit(X, y)
# make a single prediction
row = [0.2929949,-4.21223056,-1.288332,-2.17849815,-0.64527665,2.58097719,0.28422388,-7.1827928,-1.91211104,2.73729512,0.81395695,3.96973717,-2.66939799,3.34692332,4.19791821,0.99990998,-0.30201875,-4.43170633,-2.82646737,0.44916808]
yhat = model.predict([row])
print('Predicted Class: %d' % yhat[0])
运行该示例使 DCS-LA 与 LCA 模型在整个数据集上匹配，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。
Predicted Class: 0
现在，我们已经熟悉了使用 Sklearn API 来评估和使用 DCS-LA 模型，接下来让我们看看如何配置模型。
集散控制系统的超参数整定
在本节中，我们将仔细研究一些您应该考虑为分布式控制系统-线性模型进行调整的超参数，以及它们对模型表现的影响。
对于 DCS-LA，我们可以查看许多超参数，尽管在这种情况下，我们将查看在模型的局部评估中使用的 k 最近邻模型中的 k 值，以及如何使用自定义的分类器池。
我们将使用带有 OLA 的 DCS-LA 作为这些实验的基础，尽管具体方法的选择是任意的。
在 k-最近邻中探索 k
k-最近邻算法的配置对 DCS-LA 模型至关重要，因为它定义了考虑选择每个分类器的邻域范围。
k 值控制邻域的大小，将其设置为适合数据集的值非常重要，特别是特征空间中样本的密度。太小的值意味着训练集中的相关例子可能被排除在邻域之外，而太大的值可能意味着信号被太多的例子冲掉。
下面的例子探索了 k 值从 2 到 21 的带有 OLA 的 DCS-LA 的分类准确率。
# explore k in knn for DCS-LA with overall local accuracy
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from deslib.dcs.ola import OLA
from matplotlib import pyplot
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
for n in range(2,22):
models[str(n)] = OLA(k=n)
return models
# evaluate a give model using cross-validation
def evaluate_model(model):
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
return scores
# define dataset
X, y = get_dataset()
# get the models to evaluate
models = get_models()
# evaluate the models and store results
results, names = list(), list()
for name, model in models.items():
scores = evaluate_model(model)
results.append(scores)
names.append(name)
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.show()
运行该示例首先报告每个配置的邻域大小的平均准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到准确率会随着邻域大小的增加而增加，可能会增加到 k=13 或 k=14，在这种情况下准确率会趋于平稳。
>2 0.873 (0.009)
>3 0.874 (0.013)
>4 0.880 (0.009)
>5 0.881 (0.009)
>6 0.883 (0.010)
>7 0.883 (0.011)
>8 0.884 (0.012)
>9 0.883 (0.010)
>10 0.886 (0.012)
>11 0.886 (0.011)
>12 0.885 (0.010)
>13 0.888 (0.010)
>14 0.886 (0.009)
>15 0.889 (0.010)
>16 0.885 (0.012)
>17 0.888 (0.009)
>18 0.886 (0.010)
>19 0.889 (0.012)
>20 0.889 (0.011)
>21 0.886 (0.011)
为每个配置的邻域大小的准确率分数分布创建一个方框和须图。
我们可以看到模型表现和 k 值在达到平稳之前增加的总体趋势。
分布式控制系统中 k 值准确率分布的盒式和触须图
探索分类器池的算法
分布式控制系统-人工智能池中使用的算法选择是另一个重要的超参数。
默认情况下，使用袋装决策树，因为它已被证明是一系列分类任务的有效方法。然而，可以考虑定制分类器池。
这需要首先定义一个分类器模型列表，以便在训练数据集中使用和拟合每个分类器模型。不幸的是，这意味着 Sklearn 中的自动 k-fold 交叉验证模型评估方法不能用于这种情况。相反，我们将使用训练-测试分割，这样我们就可以在训练数据集上手动调整分类器池。
然后，可以通过“池分类器”参数将拟合分类器列表指定给 OLA(或 LCA)类。在这种情况下，我们将使用包含逻辑回归、决策树和朴素贝叶斯分类器的池。
下面列出了使用 OLA 和合成数据集上的一组自定义分类器评估 DCS-LA 的完整示例。
# evaluate DCS-LA using OLA with a custom pool of algorithms
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from deslib.dcs.ola import OLA
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# split the dataset into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# define classifiers to use in the pool
classifiers = [
LogisticRegression(),
DecisionTreeClassifier(),
GaussianNB()]
# fit each classifier on the training set
for c in classifiers:
c.fit(X_train, y_train)
# define the DCS-LA model
model = OLA(pool_classifiers=classifiers)
# fit the model
model.fit(X_train, y_train)
# make predictions on the test set
yhat = model.predict(X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Accuracy: %.3f' % (score))
运行该示例首先报告带有自定义分类器池的模型的平均准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到模型达到了大约 91.2%的准确率。
Accuracy: 0.913
为了采用分布式控制系统模型，它必须比任何贡献模型表现得更好。否则，我们只会使用表现更好的贡献模型。
我们可以通过评估测试集中每个有贡献的分类器的表现来检查这一点。
...
# evaluate contributing models
for c in classifiers:
yhat = c.predict(X_test)
score = accuracy_score(y_test, yhat)
print('>%s: %.3f' % (c.__class__.__name__, score))
下面列出了 DCS-LA 的更新示例，它具有一个定制的分类器池，这些分类器也是独立评估的。
# evaluate DCS-LA using OLA with a custom pool of algorithms
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from deslib.dcs.ola import OLA
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# split the dataset into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# define classifiers to use in the pool
classifiers = [
LogisticRegression(),
DecisionTreeClassifier(),
GaussianNB()]
# fit each classifier on the training set
for c in classifiers:
c.fit(X_train, y_train)
# define the DCS-LA model
model = OLA(pool_classifiers=classifiers)
# fit the model
model.fit(X_train, y_train)
# make predictions on the test set
yhat = model.predict(X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Accuracy: %.3f' % (score))
# evaluate contributing models
for c in classifiers:
yhat = c.predict(X_test)
score = accuracy_score(y_test, yhat)
print('>%s: %.3f' % (c.__class__.__name__, score))
运行该示例首先报告带有自定义分类器池的模型的平均准确率和每个贡献模型的准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以再次看到，分布式控制系统-洛杉矶实现了约 91.3%的准确性，这优于任何贡献模型。
Accuracy: 0.913
>LogisticRegression: 0.878
>DecisionTreeClassifier: 0.884
>GaussianNB: 0.873
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
相关教程
报纸
- 使用局部准确率估计的多个分类器的组合，1997。
- 量词的动态选择——综述，2014。
- 动态分类器选择:最新进展和展望，2018。
书
- 集成方法:基础与算法，2012。
蜜蜂
摘要
在本教程中，您发现了如何在 Python 中开发动态分类器选择集成。
具体来说，您了解到:
- 动态分类器选择算法从许多模型中选择一个来为每个新的例子做出预测。
- 如何使用 Sklearn API 为分类任务开发和评估动态分类器选择模型。
- 如何探索动态分类器选择模型超参数对分类准确率的影响？
你有什么问题吗？
在下面的评论中提问，我会尽力回答。
Python 中用于分类的动态集成选择(DES)
原文：https://machinelearningmastery.com/dynamic-ensemble-selection-in-python/
最后更新于 2021 年 4 月 27 日
动态集成选择是一种集成学习技术，在进行预测时，可以及时自动选择集成成员的子集。
该技术包括在训练数据集上拟合多个机器学习模型，然后基于要预测的示例的细节，选择在对特定新示例进行预测时预期表现最佳的模型。
这可以通过使用 k-最近邻模型来定位训练数据集中最接近要预测的新示例的示例，评估该邻域上池中的所有模型，并使用邻域上表现最好的模型来对新示例进行预测来实现。
因此，动态集成选择通常可以比池中的任何单个模型表现得更好，并且比池中所有成员的平均表现得更好，这就是所谓的静态集成选择。
在本教程中，您将发现如何在 Python 中开发动态集成选择模型。
完成本教程后，您将知道:
- 动态集成选择算法在对新数据进行预测时自动选择集成成员。
- 如何使用 Sklearn API 开发和评估分类任务的动态集成选择模型。
- 如何探索动态集成选择模型超参数对分类准确率的影响？
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
Python 中的动态集成选择
图片由西蒙·哈罗德提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 动态集成选择
- k-最近邻甲骨文(KNORA)与 Sklearn
- 克诺尔-消除(克诺尔-E)
- 克诺拉联盟(克诺拉-U)
- KNORA 的超参数调谐
- 在 k-最近邻中探索 k
- 探索分类器池的算法
动态集成选择
多分类器系统是指机器学习算法的一个领域，它使用多个模型来解决分类预测建模问题。
第一类发现成功的多分类器系统被称为动态分类器选择，简称 DCS。
- 动态分类器选择:从众多训练好的模型中动态选择一个，根据输入的具体细节进行预测的算法。
动态分类器选择算法通常涉及以某种方式划分输入特征空间，并分配特定的模型来负责为每个划分做出预测。有各种不同的分布式控制系统算法，研究工作主要集中在如何评估和分配分类器到输入空间的特定区域。
在训练多个个体学习器之后，分布式控制系统为每个测试实例动态选择一个学习器。[……]分布式控制系统通过使用单个学习器进行预测。
—第 93 页，集成方法:基础和算法，2012。
分布式控制系统的一个自然扩展是动态选择一个或多个模型以进行预测的算法。也就是说，动态地选择分类器的子集或集合。这些技术被称为动态集合选择(DES)。
- 动态集成选择:根据输入的具体细节动态选择训练模型子集进行预测的算法。
动态集成选择算法的操作与分布式控制系统算法非常相似，只是预测是使用多个分类器模型的投票来进行的，而不是使用单个最佳模型。实际上，输入要素空间的每个区域都属于在该区域中表现最佳的模型子集。
……鉴于只选择一个分类器可能非常容易出错，一些研究人员决定从分类器池中选择一个子集，而不仅仅是一个基本分类器。所有获得一定能力水平的基本分类器被用于组成 EoC，并且它们的输出被聚集以预测标签…
——动态分类器选择:最新进展与展望，2018。
动态集成选择的典型方法可能是 k-最近邻甲骨文或 KNORA 算法，因为它是典型动态分类器选择算法“动态分类器选择局部准确率”或 DCS-LA 的自然扩展。
DCS-LA 包括从训练或验证数据集中为给定的新输入模式选择 k 个最近邻，然后基于其在 k 个示例的邻域中的表现选择单个最佳分类器，以对新示例进行预测。
Albert Ko 等人在 2008 年发表的题为“从动态分类器选择到动态集成选择”的论文中描述了 KNORA 它是 DCS-LA 的扩展，选择在邻域上表现良好的多个模型，然后使用多数投票对这些模型的预测进行组合，以做出最终的输出预测。
对于任何测试数据点，KNORA 只需在验证集中找到它最近的 K 个邻居，计算出哪些分类器可以正确地对验证集中的这些邻居进行分类，并将它们用作对该测试集中的给定模式进行分类的集合。
——从动态分类器选择到动态集成选择，2008。
所选的分类器模型被称为“神谕，因此在方法的名称中使用了神谕。
该集合被认为是动态的，因为成员是根据需要预测的特定输入模式及时选择的。这与静态相反，在静态中，集成成员被选择一次，例如平均来自模型中所有分类器的预测。
这是通过动态方式完成的，因为不同的模式可能需要不同的分类器集合。因此，我们称我们的方法为动态集成选择。
——从动态分类器选择到动态集成选择，2008。
描述了 KNORA 的两个版本，包括 KNORA-消除和 KNORA-联合。
- KNORA-exclude(KNORA-E):在新示例的邻域上实现完美准确率的分类器的集成，邻域大小减小，直到找到至少一个完美的分类器。
- KNORA-Union (KNORA-U) :所有分类器的集成，通过加权投票和与邻域准确度成比例的投票，对邻域做出至少一个正确的预测。
KNORA-exclude，简称 KNORA-E，包括选择在邻域中 k 个示例的邻域上实现完美预测的所有分类器。如果没有分类器达到 100%的准确率，邻域大小将减少 1，模型将被重新评估。重复这个过程，直到发现一个或多个具有完美表现的模型，然后用于对新示例进行预测。
在没有分类器能够正确分类测试模式的所有 K 个最近邻居的情况下，我们简单地降低 K 的值，直到至少有一个分类器正确分类它的邻居
——从动态分类器选择到动态集成选择，2008。
KNORA-Union ，简称 KNORA-U，包括选择在邻域中至少做出一个正确预测的所有分类器。然后使用加权平均来组合来自每个分类器的预测，其中邻域中正确预测的数量指示分配给每个分类器的票数。
分类器正确分类的邻居越多，该分类器对测试模式的投票就越多
——从动态分类器选择到动态集成选择，2008。
现在我们已经熟悉了 DES 和 KNORA 算法，让我们看看如何在我们自己的分类预测建模项目中使用它。
k-最近邻甲骨文(KNORA)与 Sklearn
动态集成库，简称 DESlib，是一个 Python 机器学习库，提供了许多不同的动态分类器和动态集成选择算法的实现。
DESlib 是一个易于使用的集成学习库，专注于实现动态分类器和集成选择的最新技术。
首先，我们可以使用 pip 包管理器安装 DESlib 库，如果它还没有安装的话。
sudo pip install deslib
安装后，我们可以通过加载库并打印安装的版本来检查库是否安装正确并准备好使用。
# check deslib version
import deslib
print(deslib.__version__)
运行该脚本将打印您安装的 DESlib 库的版本。
您的版本应该相同或更高。如果没有，您必须升级您的 DESlib 库版本。
0.3
DESlib 分别通过 KNORAE 和 KNORAU 类为 KNORA 算法提供了每种动态集成选择技术的实现。
每个类都可以直接用作 Sklearn 模型，允许直接使用全套 Sklearn 数据准备、建模管道和模型评估技术。
这两个类都使用 k 最近邻算法来选择默认值为 k=7 的邻居。
决策树的自举聚合(装袋)集成被用作为默认进行的每个分类考虑的分类器模型池，尽管这可以通过将“ pool_classifiers ”设置为模型列表来改变。
我们可以使用 make_classification()函数创建一个包含 10，000 个示例和 20 个输入特征的合成二进制分类问题。
# synthetic binary 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,)
现在我们已经熟悉了 DESlib API，让我们看看如何在我们的合成类别数据集上使用每个 KNORA 算法。
克诺尔-消除(克诺尔-E)
我们可以在合成数据集上评估 KNORA-exclude 动态集成选择算法。
在这种情况下，我们将使用默认的模型超参数，包括袋装决策树作为分类器模型池，以及一个 k=7 用于在进行预测时选择局部邻域。
我们将使用三次重复和 10 次折叠的重复分层 k 折叠交叉验证来评估模型。我们将报告所有重复和折叠的模型准确率的平均值和标准偏差。
下面列出了完整的示例。
# evaluate dynamic KNORA-E dynamic ensemble selection for binary classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from deslib.des.knora_e import KNORAE
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
model = KNORAE()
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到 KNORA-E 集成和默认超参数实现了大约 91.5%的分类准确率。
Mean Accuracy: 0.915 (0.009)
我们也可以使用 KNORA-E 集合作为最终模型，并对分类进行预测。
首先，模型适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。
下面的示例在我们的二进制类别数据集上演示了这一点。
# make a prediction with KNORA-E dynamic ensemble selection
from sklearn.datasets import make_classification
from deslib.des.knora_e import KNORAE
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
model = KNORAE()
# fit the model on the whole dataset
model.fit(X, y)
# make a single prediction
row = [0.2929949,-4.21223056,-1.288332,-2.17849815,-0.64527665,2.58097719,0.28422388,-7.1827928,-1.91211104,2.73729512,0.81395695,3.96973717,-2.66939799,3.34692332,4.19791821,0.99990998,-0.30201875,-4.43170633,-2.82646737,0.44916808]
yhat = model.predict([row])
print('Predicted Class: %d' % yhat[0])
运行该示例使 KNORA-E 动态集成选择算法适用于整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。
Predicted Class: 0
现在我们已经熟悉了 KNORA-E 的使用，让我们来看看 KNORA-Union 方法。
克诺拉联盟(克诺拉-U)
我们可以在合成数据集上评估 KNORA-Union 模型。
在这种情况下，我们将使用默认的模型超参数，包括袋装决策树作为分类器模型池，以及一个 k=7 用于在进行预测时选择局部邻域。
我们将使用三次重复和 10 次折叠的重复分层 k 折叠交叉验证来评估模型。我们将报告所有重复和折叠的模型准确率的平均值和标准偏差。
下面列出了完整的示例。
# evaluate dynamic KNORA-U dynamic ensemble selection for binary classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from deslib.des.knora_u import KNORAU
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
model = KNORAU()
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到 KNORA-U 动态集成选择模型和默认超参数实现了大约 93.3%的分类准确率。
Mean Accuracy: 0.933 (0.009)
我们也可以用 KNORA-U 模型作为最终模型，进行分类预测。
首先，模型适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。
下面的示例在我们的二进制类别数据集上演示了这一点。
# make a prediction with KNORA-U dynamic ensemble selection
from sklearn.datasets import make_classification
from deslib.des.knora_u import KNORAU
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
model = KNORAU()
# fit the model on the whole dataset
model.fit(X, y)
# make a single prediction
row = [0.2929949,-4.21223056,-1.288332,-2.17849815,-0.64527665,2.58097719,0.28422388,-7.1827928,-1.91211104,2.73729512,0.81395695,3.96973717,-2.66939799,3.34692332,4.19791821,0.99990998,-0.30201875,-4.43170633,-2.82646737,0.44916808]
yhat = model.predict([row])
print('Predicted Class: %d' % yhat[0])
运行该示例使 KNORA-U 模型适合整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用该模型时可能做的那样。
Predicted Class: 0
既然我们已经熟悉了使用 Sklearn API 来评估和使用 KNORA 模型，那么让我们来看看如何配置模型。
KNORA 的超参数调谐
在本节中，我们将仔细研究一些您应该考虑为 KNORA 模型进行调整的超参数，以及它们对模型表现的影响。
对于 KNORA，我们可以查看许多超参数，尽管在这种情况下，我们将查看在模型的局部评估中使用的 k 最近邻模型中 k 的值，以及如何使用自定义的分类器池。
我们将使用 KNORA-Union 作为这些实验的基础，尽管具体方法的选择是任意的。
在 k 近邻中探索 k
k-最近邻算法的配置对于 KNORA 模型至关重要，因为它定义了考虑选择每个集成的邻域范围。
k 值控制邻域的大小，重要的是将其设置为适合数据集的值，特别是特征空间中样本的密度。太小的值意味着训练集中的相关例子可能被排除在邻域之外，而太大的值可能意味着信号被太多的例子冲掉。
下面的代码示例探讨了 k 值从 2 到 21 的 KNORA-U 算法的分类准确率。
# explore k in knn for KNORA-U dynamic ensemble selection
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from deslib.des.knora_u import KNORAU
from matplotlib import pyplot
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
for n in range(2,22):
models[str(n)] = KNORAU(k=n)
return models
# evaluate a give model using cross-validation
def evaluate_model(model):
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
return scores
# define dataset
X, y = get_dataset()
# get the models to evaluate
models = get_models()
# evaluate the models and store results
results, names = list(), list()
for name, model in models.items():
scores = evaluate_model(model)
results.append(scores)
names.append(name)
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.show()
运行该示例首先报告每个配置的邻域大小的平均准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到准确率会随着邻域大小的增加而增加，可能会增加到 k=10，此时准确率会趋于平稳。
>2 0.933 (0.008)
>3 0.933 (0.010)
>4 0.935 (0.011)
>5 0.935 (0.007)
>6 0.937 (0.009)
>7 0.935 (0.011)
>8 0.937 (0.010)
>9 0.936 (0.009)
>10 0.938 (0.007)
>11 0.935 (0.010)
>12 0.936 (0.009)
>13 0.934 (0.009)
>14 0.937 (0.009)
>15 0.938 (0.009)
>16 0.935 (0.010)
>17 0.938 (0.008)
>18 0.936 (0.007)
>19 0.934 (0.007)
>20 0.935 (0.007)
>21 0.936 (0.009)
为每个配置的邻域大小的准确率分数分布创建一个方框和须图。
我们可以看到模型表现和 k 值在达到平稳之前增加的总体趋势。
KNORA-U 中 k 值准确率分布的方框图和触须图
探索分类器池的算法
KNORA 池中使用的算法选择是另一个重要的超参数。
默认情况下，使用袋装决策树，因为它已被证明是一系列分类任务的有效方法。然而，可以考虑定制分类器池。
在大多数 DS 出版物中，分类器池是使用众所周知的集成生成方法(如 Bagging)或使用异构分类器生成的。
——动态分类器选择:最新进展与展望，2018。
这需要首先定义一个分类器模型列表，以便在训练数据集中使用和拟合每个分类器模型。不幸的是，这意味着 Sklearn 中的自动 k-fold 交叉验证模型评估方法不能用于这种情况。相反，我们将使用训练-测试分割，这样我们就可以在训练数据集上手动调整分类器池。
然后，可以通过“池分类器”参数将拟合分类器列表指定给 KNORA-Union(或 KNORA-exclude)类。在这种情况下，我们将使用包含逻辑回归、决策树和朴素贝叶斯分类器的池。
下面列出了在合成数据集上评估 KNORA 集成和一组自定义分类器的完整示例。
# evaluate KNORA-U dynamic ensemble selection with a custom pool of algorithms
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from deslib.des.knora_u import KNORAU
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# split the dataset into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# define classifiers to use in the pool
classifiers = [
LogisticRegression(),
DecisionTreeClassifier(),
GaussianNB()]
# fit each classifier on the training set
for c in classifiers:
c.fit(X_train, y_train)
# define the KNORA-U model
model = KNORAU(pool_classifiers=classifiers)
# fit the model
model.fit(X_train, y_train)
# make predictions on the test set
yhat = model.predict(X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Accuracy: %.3f' % (score))
运行该示例首先报告具有自定义分类器池的模型的平均准确度。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到模型达到了大约 91.3%的准确率。
Accuracy: 0.913
为了采用 KNORA 模型，它必须比任何贡献模型表现得更好。否则，我们只会使用表现更好的贡献模型。
我们可以通过评估测试集中每个有贡献的分类器的表现来检查这一点。
...
# evaluate contributing models
for c in classifiers:
yhat = c.predict(X_test)
score = accuracy_score(y_test, yhat)
print('>%s: %.3f' % (c.__class__.__name__, score))
下面列出了 KNORA 的更新示例，该示例具有一个自定义的分类器池，这些分类器也是独立评估的。
# evaluate KNORA-U dynamic ensemble selection with a custom pool of algorithms
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from deslib.des.knora_u import KNORAU
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# split the dataset into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# define classifiers to use in the pool
classifiers = [
LogisticRegression(),
DecisionTreeClassifier(),
GaussianNB()]
# fit each classifier on the training set
for c in classifiers:
c.fit(X_train, y_train)
# define the KNORA-U model
model = KNORAU(pool_classifiers=classifiers)
# fit the model
model.fit(X_train, y_train)
# make predictions on the test set
yhat = model.predict(X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Accuracy: %.3f' % (score))
# evaluate contributing models
for c in classifiers:
yhat = c.predict(X_test)
score = accuracy_score(y_test, yhat)
print('>%s: %.3f' % (c.__class__.__name__, score))
运行该示例首先报告带有自定义分类器池的模型的平均准确率和每个贡献模型的准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以再次看到 KNORAU 达到了大约 91.3%的准确率，这比任何贡献模型都好。
Accuracy: 0.913
>LogisticRegression: 0.878
>DecisionTreeClassifier: 0.885
>GaussianNB: 0.873
代替指定分类器池，也可以从 Sklearn 库中指定单个集成算法，KNORA 算法将自动使用内部集成成员作为分类器。
例如，我们可以使用具有 1，000 个成员的随机森林集成作为基本分类器，在 KNORA 中考虑如下:
...
# define classifiers to use in the pool
pool = RandomForestClassifier(n_estimators=1000)
# fit the classifiers on the training set
pool.fit(X_train, y_train)
# define the KNORA-U model
model = KNORAU(pool_classifiers=pool)
将这些联系在一起，下面列出了以随机森林集成成员作为分类器的完整 KNORA-U 示例。
# evaluate KNORA-U with a random forest ensemble as the classifier pool
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from deslib.des.knora_u import KNORAU
from sklearn.ensemble import RandomForestClassifier
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# split the dataset into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# define classifiers to use in the pool
pool = RandomForestClassifier(n_estimators=1000)
# fit the classifiers on the training set
pool.fit(X_train, y_train)
# define the KNORA-U model
model = KNORAU(pool_classifiers=pool)
# fit the model
model.fit(X_train, y_train)
# make predictions on the test set
yhat = model.predict(X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Accuracy: %.3f' % (score))
# evaluate the standalone model
yhat = pool.predict(X_test)
score = accuracy_score(y_test, yhat)
print('>%s: %.3f' % (pool.__class__.__name__, score))
运行该示例首先报告带有自定义分类器池的模型的平均准确率和随机森林模型的准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到，具有动态选择的集成成员的 KNORA 模型比具有静态选择的(完全集合)集成成员的随机森林表现更好。
Accuracy: 0.968
>RandomForestClassifier: 0.967
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
相关教程
报纸
- 从动态分类器选择到动态集成选择，2008。
- 量词的动态选择——综述，2014。
- 动态分类器选择:最新进展和展望，2018。
书
- 集成方法:基础与算法，2012。
蜜蜂
摘要
在本教程中，您发现了如何在 Python 中开发动态集成选择模型。
具体来说，您了解到:
- 动态集成选择算法在对新数据进行预测时自动选择集成成员。
- 如何使用 Sklearn API 开发和评估分类任务的动态集成选择模型。
- 如何探索动态集成选择模型超参数对分类准确率的影响？
你有什么问题吗？
在下面的评论中提问，我会尽力回答。
机器学习集成多样性的温和介绍
原文：https://machinelearningmastery.com/ensemble-diversity-for-machine-learning/
集成学习将来自机器学习模型的预测结合起来用于分类和回归。
我们追求使用集成方法来实现改进的预测表现，正是这种对任何贡献模型的改进定义了集成是否良好。
好的集合中存在的一个特性是贡献模型所做预测的多样性。多样性是一个模糊的概念，因为它没有被精确地定义；然而，它为设计好的集成模型提供了一个有用的实用启发。
在这篇文章中，你将在机器学习中发现集成多样性。
看完这篇文章，你会知道:
- 一个好的集成团比任何有贡献的模型都有更好的表现。
- 集合多样性是一个好的集合的属性，其中贡献模型对相同的输入产生不同的误差。
- 寻求独立的模型和不相关的预测为思考和将多样性引入集合模型提供了指导。
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
机器学习集成多样性简介
图片由贝恩德·泰勒提供，版权所有。
教程概述
本教程分为三个部分；它们是:
- 什么是好的集成
- 什么是群体多样性
- 增加多样性的方法
什么是好的集成
集成是一种机器学习模型，它结合了来自多个其他模型的预测。
这往往具有减少预测误差和提高模型泛化能力的效果。但情况并非总是如此。
有时候，这个集成团的表现并不比这个集成团中一个表现出色的成员好。更糟糕的是，有时候一个集成团的表现会比任何一个参与的成员都差。
这就提出了一个问题，什么是好的集成。
好的集成团是比任何贡献成员表现更好的集成团。也就是说，它是对于回归具有较低预测误差或者对于分类具有较高准确率的模型。
- 好的集合:比任何单一贡献模型表现更好的模型。
这可以使用训练和测试集或重采样技术(如 k 倍交叉验证)根据经验进行评估。可以类似地为每个有贡献的模型估计结果，并将结果直接进行比较，以查看是否满足“好的集合的定义。
一个好的集成有哪些特性使其区别于其他集成，这些集成的表现与任何贡献成员一样好或更差？
这是一个被广泛研究的问题，有很多想法。一致性就是好的集成有多样性。
什么是群体多样性
集合多样性指的是由集合成员做出的决定或预测的差异。
集成多样性，即个体学习器之间的差异，是集成方法中的一个基本问题。
—第 99 页，集合方法，2012。
做出相同预测的两个集成成员被认为是不多样的。
在所有情况下做出完全不同预测的集合是最大程度多样化的，尽管这是最不可能的。
在任何给定的样本上产生不同的误差在基于集合的系统中是至关重要的。毕竟，如果所有的集成成员都提供相同的输出，那么他们的组合就不会有什么收获。
—第 5 页，集成机器学习，2012。
因此，为了构建一个好的集合，在预测中需要或者甚至需要某种程度的多样性。在讨论中，这通常被简化为对不同集合成员的期望，例如模型本身，这反过来将产生不同的预测，尽管预测的多样性确实是我们所寻求的。
理想情况下，多样性意味着每个集成成员做出的预测是独立且不相关的。
…分类器输出应该是独立的，或者最好是负相关的。
—第 5 页，集成机器学习，2012。
独立性是概率论中的一个术语，指的是一个事件不影响另一个事件发生的概率的情况。事件可以以许多不同的方式相互影响。如果一个集成试图修正它所做的预测，它可能会影响另一个集成。
因此，根据集合类型，模型可以是自然相关的或独立的。
- 独立性:一个事件的发生是否影响后续事件发生的概率。
相关性是统计学中的一个术语，指的是两个一起变化的变量。通常计算-1.0 和 1.0 之间的归一化相关分数，其中分数 0.0 表示不相关，例如不相关。得分为 1.0 或-1.0 一分别表示完全正相关和负相关，并表示两个模型总是预测相同(或相反)的结果。
……如果学习器是独立的，即[相关性] = 0，则集成将获得比单个学习器更小的误差因子 T；如果学习器完全相关，即[相关性] = 1，则不能从组合中获得任何收益。
—第 99 页，集合方法，2012。
在实践中，集成在它们的预测中经常表现出弱的或适度的正相关。
- 相关性:变量一起变化的程度。
因此，集合模型是从组成模型构建的，这些组成模型在所做的决策或预测之间可能具有或不具有某种依赖性和某种相关性。构建良好的集成是一项具有挑战性的任务。
例如，组合一堆表现最好的模型可能会导致整体效果不佳，因为模型做出的预测高度相关。非直觉地，你最好将一些表现最好的单个模型的预测与一些较弱模型的预测结合起来。
因此，希望学习器个体准确、多样。只结合准确的学习器往往比结合一些准确的学习器和一些相对较弱的学习器更糟糕，因为互补性比纯粹的准确性更重要。
—第 100 页，集合方法，2012 年。
可悲的是，没有一个普遍认同的集合多样性的衡量标准，独立性和相关性的想法只是思考好的集合的属性的指南或代理。
不幸的是，尽管多样性至关重要，但我们仍然没有对多样性有一个清晰的认识；例如，目前还没有公认的多样性的正式定义。
—第 100 页，集合方法，2012 年。
然而，作为指导，它们是有用的，因为我们可以设计出试图减少模型之间相关性的技术。
增加多样性的方法
发展良好集成的目标是通过增加集成成员的多样性来考虑的。
如果集合中的模型共享用于训练模型的相同算法和/或用于训练模型的相同数据集，则它们可能更加依赖。出于同样的一般原因，集合中的模型在它们的预测之间可能具有更高的相关性。
因此，使模型和/或训练数据更加不同的方法是期望的。
多样性可以通过输入数据的不同呈现来获得，如装袋、学习器设计的变化，或者通过在输出中添加惩罚来鼓励多样性。
—第 93 页，使用集成方法的模式分类，2010。
有一个框架来思考管理集成多样性的技术可能会有所帮助，而且有很多可以选择。
例如，周志华在他 2012 年出版的《集成方法:基础和算法》一书的第五章中提出了一个由四种方法组成的框架来产生多样性。概括来说，它们是:
- 数据采样操作:例如，针对每个模型对训练数据集进行不同的采样。
- 输入特征操作:例如，在不同组的输入特征上训练每个模型。
- 学习参数操作:比如训练不同超参数值的模型。
- 输出表示操纵:例如，训练具有不同修改目标值的模型。
也许最常见的方法是改变训练数据，即数据样本和输入特征，通常组合在一个方法中。
对于另一个用于生成多样集成的分类法的例子，在他 2010 年出版的名为《使用集成方法的模式分类》的书的第四章中，Lior Rokach 提出了一个类似的分类法，总结如下:
- 操纵诱导物，例如操纵模型的训练方式。
- 改变超参数。
- 起点不同。
- 改变优化算法。
- 操纵训练样本，例如操纵用于训练的数据。
- 重采样。
- 改变目标属性表示，例如操纵目标变量。
- 改变编码。
- 纠错码。
- 标签交换。
- 划分搜索空间，例如操纵输入特征的数量。
- 随机子空间。
- 特征选择。
- 杂交，例如改变模型类型或上述方法的混合。
混合方法在流行的集成方法中是常见的，该集成方法在单个算法中组合多种方法来产生多样性，以及简单地改变组成集成的算法(模型类型)。
将竞争模型捆绑到集成中几乎总能提高泛化能力，而使用不同的算法作为扰动算子是获得必要的组件多样性的有效方法。
—第 89 页，数据挖掘中的集成方法，2010。
这突出表明，尽管我们可以研究量化一个集合的多样性，但相反，大部分努力是在开发产生多样性的技术上。
我们可以利用这些知识来开发我们自己的集成方法，首先尝试标准且易于理解的集成学习方法，然后根据我们特定的数据集对它们进行定制，同时考虑模型独立性和预测相关性，以最大限度地利用它们。
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
书
- 使用集成方法的模式分类，2010。
- 集成方法，2012。
- 集成机器学习，2012。
- 数据挖掘中的集成方法，2010。
文章
- 一起学习，维基百科。
- 一起学习，学院派。
摘要
在这篇文章中，你发现了机器学习中的集成多样性。
具体来说，您了解到:
- 一个好的集成团比任何有贡献的模型都有更好的表现。
- 集合多样性是一个好的集合的属性，其中贡献模型对相同的输入产生不同的误差。
- 寻求独立的模型和不相关的预测为思考和将多样性引入集合模型提供了指导。
你有什么问题吗？
在下面的评论中提问，我会尽力回答。
集成学习算法复杂度和奥卡姆剃刀
原文：https://machinelearningmastery.com/ensemble-learning-and-occams-razor/
最后更新于 2021 年 4 月 27 日
奥卡姆剃刀提出，在机器学习中，我们应该更喜欢系数更少的更简单的模型，而不是像集成这样的复杂模型。
从表面上看，剃刀是一种启发，它表明更复杂的假设会做出更多的假设，而这些假设又会使假设过于狭窄，无法很好地概括。在机器学习中，它表明像集成这样的复杂模型会过度训练训练数据集，并且在新数据上表现不佳。
实际上，在预测技能是最重要的考虑因素的项目中，集合几乎是普遍选择的模型类型。此外，经验结果显示，随着集成学习模型的复杂度递增，泛化误差持续减小。这些发现与奥卡姆剃刀原则不一致。
在本教程中，您将发现如何将奥卡姆剃刀与集成机器学习相协调。
完成本教程后，您将知道:
- 奥卡姆剃刀是一种启发式方法，建议选择更简单的机器学习模型，因为它们有望更好地推广。
- 启发式可以分为两个剃刀，一个是真的，仍然是一个有用的工具，另一个是假的，应该放弃。
- 像 boosting 这样的集成学习算法提供了第二个 razor 如何失败的具体案例，增加的复杂性可以降低泛化误差。
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
集成学习算法复杂性和奥卡姆剃刀
图片由迪伦 _ 奥东内尔提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 奥卡姆模型选择剃刀
- 奥卡姆机器学习的两把剃刀
- 奥卡姆剃刀与集成学习
奥卡姆模型选择剃刀
模型选择是从预测建模项目的许多候选机器学习模型中选择一个的过程。
根据模型的预期表现选择模型通常很简单，例如选择具有最高准确率或最低预测误差的模型。
另一个重要的考虑是选择更简单的模型而不是复杂的模型。
更简单的模型通常被定义为做出更少假设或具有更少元素的模型，最常见的特征是更少的系数(例如规则、层、权重等)。).选择更简单型号的理由与奥卡姆剃刀有关。
想法是最好的科学理论是解释所有事实的最小理论。
—第 197 页，数据挖掘:实用机器学习工具与技术，2016。
奥卡姆剃刀是一种解决问题的方法，通常被用来表示如果其他条件都相同，我们应该更喜欢更简单的解决方案。
- 奥卡姆剃刀:如果其他都相等，那么最简单的解就是正确的。
它是以奥卡姆的威廉命名的，旨在对抗更复杂的哲学，而预测力却没有相应的增加。
奥卡姆著名剃刀的威廉说“努尔哈赤是必然的多元论”，大致翻译过来，意思是“实体不应该在必然之外增加”。
——奥卡姆的《两把剃刀:锋利的和钝的》，1998 年。
这不是一条规则，更多的是一种解决问题的启发式方法，在科学中通常被引用来偏爱更简单的假设，它比更复杂的假设做得更多。
科学中有一个长期的传统，即在其他条件相同的情况下，简单的理论比复杂的理论更可取。这就是以中世纪哲学家奥卡姆(或奥卡姆)的威廉命名的奥卡姆剃刀。
—第 197 页，数据挖掘:实用机器学习工具与技术，2016。
带有更多假设的复杂假设的问题在于它们可能过于具体。
它们可能包括手头上或容易获得的具体案例的细节，反过来可能不会推广到新案例。也就是说，假设越多，其应用范围就越窄。相反，更少的假设意味着更一般的假设，对更多的情况有更大的预测能力。
- 简单假设:假设少，反过来适用性广。
- 复杂假设:假设多，反过来适用性窄。
这对机器学习有影响，因为我们特别试图从具体的观察中归纳出新的看不见的情况，称为归纳推理。
如果奥卡姆剃刀认为更复杂的模型不能很好地概括，那么在应用机器学习中，它建议我们应该选择更简单的模型，因为它们对新数据的预测误差更低。
如果这是真的，那么我们如何证明使用集成机器学习算法是正确的？
根据定义，集成机器学习算法比单个机器学习模型更复杂，因为它们由许多单独的机器学习模型组成。
奥卡姆剃刀认为，集成学习算法的复杂性增加意味着它们不会像更简单的模型一样适用于同一数据集。
然而，当对新数据的预测技能是最重要的关注点时，例如机器学习竞赛，集成机器学习算法是主要的解决方案。集成已经被研究了很长时间，并且在一次又一次的研究中被证明不会过度填充训练数据集。
经验上观察到，某些集成技术通常不会过拟合模型，即使集成包含数千个分类器。
—第 40 页，使用集成方法的模式分类，2010。
如何调和这种不一致？
奥卡姆机器学习的两把剃刀
长期以来，理论上更简单的模型更好地概括与实践中更复杂的模型如集成更好地概括之间的冲突，作为一个不方便的经验发现，大多被忽视。
20 世纪 90 年代末，佩德罗·多明戈斯(Pedro Domingos)专门研究了这个问题，并发表在 1996 年 T2 获奖论文《奥卡姆剃刀在知识发现中的作用》(T7)中
在工作中，多明戈斯将这个问题定义为奥卡姆剃刀在应用机器学习中的两个具体的普遍断言的含义，他称之为“奥卡姆剃刀在机器学习中的两个含义”，它们是(摘自论文):
- 第一剃刀:给定两个具有相同泛化误差的模型，应该首选更简单的模型，因为简单本身就是可取的。
- 第二剃刀:给定两个训练集误差相同的模型，应该优先选择更简单的模型，因为它可能具有更低的泛化误差。
多明戈斯随后从机器学习的理论和实证研究中列举了支持和反对每一种剃刀的大量例子。
第一剃刀建议，如果两个模型在训练中没有看到的数据上有相同的预期表现，我们应该更喜欢更简单的模型。多明戈斯强调，这种剃刀适用于机器学习项目，并提供了很好的启发。
第二个剃刀建议，如果两个模型在训练数据集上具有相同的表现，那么应该选择更简单的模型，因为当用于对新数据进行预测时，它有望更好地推广。
**从表面上看，这似乎是明智的。
这是在机器学习项目中不采用集成算法背后的论点，因为与其他模型相比，集成算法非常复杂，预计不会一概而论。
原来这把剃刀无法得到机器学习文献证据的支持。
所有这些证据都指向这样一个结论:第二把剃刀不仅在总体上不正确；在 KDD 申请的域名类型中，这也是典型的错误。
——奥卡姆的《两把剃刀:锋利的和钝的》，1998 年。
奥卡姆剃刀与集成学习
一旦你仔细考虑了一会儿，这个发现听起来就很直观。
例如，在实践中，我们不会仅根据机器学习模型在训练数据集上的表现来选择机器学习模型。我们凭直觉，或者可能在大量的经验之后，默认训练集上的表现估计是对保持数据集上的表现的糟糕估计。
我们有这样的期望，因为模型可以过度训练数据集。
然而，不太直观的是，过拟合训练数据集可以在保持测试集上获得更好的表现。这在系统研究的实践中已经多次观察到。
一种常见的情况是，在模型的每次学习迭代中，在训练数据集和保持测试数据集上绘制模型的表现，例如支持增量学习的模型的训练时期或迭代。
如果训练数据集上的学习被设置为持续大量的训练迭代和观察到的曲线，则通常可以看到训练数据集上的表现将下降到零误差。这是意料之中的，因为我们可能会认为，在给定足够的资源和时间进行训练的情况下，模型会过度训练训练数据集。然而，测试集上的表现将继续提高，即使训练集上的表现保持固定在零误差。
……偶尔，在训练误差达到零后很长时间，泛化误差会继续改善。
—第 40 页，数据挖掘中的集成方法，2010。
这种行为可以通过像 boosting 和 bagging 这样的集成学习算法来观察，在这些算法中，随着额外的模型成员被添加到集成中，保持数据集的表现将继续提高。
一个非常令人惊讶的发现是，在组合分类器对训练数据的分类误差已经下降到零很长时间之后，执行更多的提升迭代可以减少新数据上的误差。
—第 489 页，数据挖掘:实用机器学习工具与技术，2016。
也就是说，模型的复杂度是递增的，这系统地减少了对看不见的数据的误差，例如泛化误差。额外的训练不能提高训练数据集的表现；没有可能的改进。
在不减少训练误差的情况下执行更多的提升迭代并不能更好地解释训练数据，而且它肯定会增加组合分类器的复杂性。
—第 490 页，数据挖掘:实用机器学习工具与技术，2016。
这一发现直接与第二把剃刀相矛盾，并支持多明戈斯关于放弃第二把剃刀的论点。
第一个基本上没有争议，而第二个，从字面上看，是错误的。
——奥卡姆的《两把剃刀:锋利的和钝的》，1998 年。
这个问题已经被研究过，并且通常可以通过集成算法来解释，集成算法学习对训练数据集的预测更有信心，而训练数据集会延续到保持数据。
这个矛盾可以通过考虑分类器对其预测的信心来解决。
—第 490 页，数据挖掘:实用机器学习工具与技术，2016。
第一把剃刀仍然是应用机器学习中的一个重要启发。
这把剃刀的关键方面是“T0”的谓词，所有其他的都是相等的也就是说，如果比较两个模型，必须使用它们在保持数据集上的泛化误差进行比较，或者使用 k 倍交叉验证进行估计。如果在这些情况下，它们的表现相同，那么剃须刀就可以生效，我们可以选择更简单的解决方案。
这不是选择车型的唯一方法。
我们可能会选择更简单的模型，因为它更容易解释，如果模型可解释性是比预测技能更重要的项目需求，这仍然有效。
当模型参数的数量被认为是复杂性的度量时，集成学习算法无疑是一种更复杂的模型。因此，机器学习中的一个开放问题涉及到复杂性的替代度量。
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
相关教程
报纸
- 奥卡姆的《两把剃刀:锋利的和钝的》，1998。
- 奥卡姆剃刀在知识发现中的作用，1999。
书
- 数据挖掘中的集成方法:通过组合预测来提高准确性，2010。
- 使用集成方法的模式分类，2010。
- 数据挖掘:实用机器学习工具与技术，2016。
文章
- Occam’s razor，维基百科。
- 奥卡姆的威廉，维基百科。
摘要
在本教程中，您发现了如何将奥卡姆剃刀与集成机器学习相协调。
具体来说，您了解到:
- 奥卡姆剃刀是一种启发式方法，建议选择更简单的机器学习模型，因为它们有望更好地推广。
- 启发式可以分为两种剃刀，一种是真的，仍然是有用的工具，另一种是假的，应该放弃。
- 像 boosting 这样的集成学习算法提供了第二个 razor 如何失败的具体案例，增加的复杂性可以降低泛化误差。
你有什么问题吗？
在下面的评论中提问，我会尽力回答。**
6 本集成学习书籍
原文：https://machinelearningmastery.com/ensemble-learning-books/
最后更新于 2021 年 4 月 27 日
集成学习包括组合来自多个机器学习模型的预测。
其效果可以是提高预测表现和降低模型预测的方差。
大多数关于机器学习的教科书都涵盖了集成方法；尽管如此，还是有专门针对这个话题的书籍。
在这篇文章中，你会发现关于集成机器学习主题的顶级书籍。
看完这篇文章，你会知道:
- 关于集成学习的书籍，包括它们的目录和在哪里可以了解更多。
- 最流行和最常见的机器学习教科书中关于集成学习的章节。
- 对集成学习感兴趣的机器学习从业者的书籍推荐。
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
集成学习书单
我们将介绍的关于集成学习的书籍如下:
- 有监督和无监督集成方法及其应用，2008。
- 使用集成方法的模式分类，2010。
- 集成学习，2019 年。
- 数据挖掘中的集成方法，2010。
- 集成方法，2012。
- 集成机器学习，2012。
还有一些 Packt 的书，不过我就不复习了；它们是:
- 用 R 进行动手集成学习，2018。
- Python 动手集成学习，2019 年。
- 集成机器学习秘籍，2019 年。
是不是错过了一本关于集成学习的书？
在下面的评论里告诉我。
你读过这些关于集成学习的书吗？
你怎么看？评论里告诉我。
让我们仔细看看这些书，包括它们的作者、目录，以及在哪里可以了解更多。
有监督和无监督集成方法及其应用
这本书的全名是“有监督和无监督集成方法及其应用”，由奥列格·奥肯(Oleg Okun)和乔治·瓦伦蒂诺(Giorgio Valentini)编辑，于 2008 年出版。
有监督和无监督集成方法及其应用
这本书收集了一系列不同作者关于集成学习应用的学术论文。
这本书包括九章，分为两个部分，池化了有监督和无监督集成应用的贡献。
—第八页，有监督和无监督集成方法及其应用，2008。
目录
- 第一部分:聚类方法的集成及其应用
- 第一章:聚类集成方法:从单个聚类到组合解决方案
- 第二章:用于类别数据聚类的随机子空间集成
- 第三章:基于模糊方法的集成聚类
- 第四章:面向对象图像分析的协同多策略聚类
- 第二部分:分类方法集成及其应用
- 第五章:使用多分类器系统的计算机系统中的入侵检测
- 第六章:基于基因表达的癌症分类的最近邻集合
- 第七章:通过单变量分类器的堆叠进行多变量时间序列分类
- 第八章:时间序列预测的梯度提升 GARCH 和神经网络
- 第九章:名义数据的级联 VDM 树和二进制决策树
我一般不会向机器学习从业者推荐这本书，除非这本书涵盖的应用程序之一与您当前的项目直接相关。
你可以在这里了解这本书的更多信息:
- 有监督和无监督集成方法及其应用，2008。
使用集成方法的模式分类
这本书的完整标题是“使用集成方法的模式分类”，它是由利奥·罗卡奇编写的，于 2010 年出版。
使用集成方法的模式分类
这本书提供了为学生和学者编写的集成机器学习主题的技术介绍。
整本书都特别强调例证的广泛使用。因此，除了集成理论之外，读者还可以从广泛的领域获得大量的人工和现实应用。本书中提到的数据，以及所呈现算法的大多数 Java 实现，都可以通过网络获得。
—第八页，使用集成方法的模式分类，2010。
目录
- 第一章:模式分类介绍
- 第二章:集成学习介绍
- 第三章:集合分类
- 第四章:集成多样性
- 第五章:集成选择
- 第六章:纠错输出代码
- 第七章:评估分类器的集成
我喜欢这本书的水平。它是技术性的，但并不过度，并且基于在监督预测建模项目中使用集成算法的考虑。我认为这是一个很好的实践者集成学习的教科书。
你可以在这里了解这本书的更多信息:
- 使用集成方法的模式分类，2010。
集成学习
这本书的全称是《集成学习:使用集成方法的模式分类》》，由 Lior Rokach 撰写，于 2019 年出版。
使用集成方法的集成学习模式分类
这是对《使用集成方法的模式分类》一书的直接更新，并给出了不同的标题。
这本书的第一版是十年前出版的。这本书受到机器学习和数据科学社区的好评，并被翻译成中文。[……]第二版旨在更新以前介绍的基本领域的材料，并介绍该领域的新发现；这个版本的三分之一以上是由新材料组成的。
—第七页，集成学习:使用集成方法的模式分类，2019。
目录
- 第一章:机器学习导论
- 第二章:分类和回归树
- 第三章:集成学习介绍
- 第四章:集合分类
- 第五章:梯度增压机
- 第六章:集成多样性
- 第七章:集成选择
- 第八章:纠错输出代码
- 第九章:评估集成分类器
对于学生和从业者来说，这是一本关于集成学习的优秀教科书，如果你必须在两者之间进行选择，它比“使用集成方法的模式分类”更受欢迎。
你可以在这里了解这本书的更多信息:
- 集成学习:使用集成方法的模式分类，2019。
数据挖掘中的集成方法
这本书的全称是《数据挖掘中的集成方法:通过组合预测来提高准确性
》，作者是乔瓦尼·塞尼和约翰·艾尔德，出版于 2010 年。
数据挖掘中的集成方法
这是一本关于集成的技术书籍，尽管在 r
这本书是针对新手和高级分析研究人员和从业者-特别是在工程，统计和计算机科学。那些很少接触集成的人将学习为什么以及如何使用这种突破性的方法，高级从业者将获得构建更强大模型的洞察力。贯穿全文，提供了 R 中的代码片段来说明所描述的算法，并鼓励读者尝试该技术。
—第一页，数据挖掘中的集成方法，2010。
目录
- 第一章:发现集成
- 第二章:预测学习和决策树
- 第三章:模型复杂性、模型选择和正则化
- 第四章:重要采样和经典集成方法
- 第五章:规则集成和解释统计
- 第六章:整体复杂性
- 附录 A: AdaBoost 等效于 FSF 程序
- 附录 B:梯度提升和稳健损失函数
我相信这是我多年前购买的第一本关于集成学习的书。对于练习者来说，尤其是那些已经在使用 r 的人来说，这是一门很好的集成学习速成课程，对于大多数练习者来说，可能有点过于数学化了；尽管如此，我认为它可能是上述集合方法教科书的一个很好的小替代品。
你可以在这里了解这本书的更多信息:
- 数据挖掘中的集成方法，2010。
集成方法
这本书的全名是“集成方法:基础和算法”，由周志华撰写，于 2012 年出版。
集成方法:基础和算法
这是另一本针对学生和学者的关于集成学习的重点教材。
这本书向研究人员、学生和实践者介绍了集成方法。这本书由八章组成，自然构成三个部分。
—第七页，集成方法:基础和算法，2012。
目录
- 第一章:引言
- 第二章:提升
- 第三章:装袋
- 第四章:组合方法
- 第五章:多样性
- 第六章:整体修剪
- 第七章:集群集成
- 第八章:高级主题
这本书写得很好，涵盖了主要方法，有很好的参考。我认为这是在集成方法基础上的又一个很好的开端，只要读者对一些数学知识感到满意。我喜欢算法描述和工作示例。
你可以在这里了解这本书的更多信息:
- 集成方法:基础与算法，2012。
集成机器学习
这本书的全称是《集成机器学习:方法与应用》，由查章、马云倩主编，2012 年出版。
集成机器学习
这本书是一系列作者撰写的关于集成机器学习应用的学术论文的集合。
尽管集成学习方法最近取得了巨大的成功，但我们发现专门针对这一主题的书籍非常少，更少的书籍提供了关于如何将这种方法应用于现实应用的见解。这本书的主要目标是填补文献中现有的空白，全面涵盖最先进的集成学习方法，并提供一套演示集成学习方法在现实世界中的各种用法的应用程序。
—第五页，集成机器学习:方法与应用，2012。
目录
- 第一章:集成学习
- 第二章:增强算法:方法、理论和应用综述
- 第三章:增强核估计
- 第四章:针对性学习
- 第五章:随机森林
- 第六章:负相关学习的集成学习
- 第七章:集成团
- 第八章:对象检测
- 第九章:用于人类活动识别的分类器增强
- 第十章:用于解剖结构检测和分割的鉴别学习
- 第一章:生物信息学的随机森林
像其他论文集一样，我一般不会推荐这本书，除非你是一名学者，或者其中一章与你当前的机器学习项目直接相关。然而，许多章节提供了一个坚实和紧凑的介绍，集成方法，以及如何在具体应用中使用它们。
你可以在这里了解这本书的更多信息:
- 集成机器学习:方法与应用，2012。
书籍章节
许多机器学习教科书都有关于集成学习的章节。
在这一部分，我们将快速浏览一些更受欢迎的教科书和关于集成学习的相关章节。
2016 年出版的《统计学习及其在 R 中的应用导论》一书在第八章中为决策树的提升和装袋提供了坚实的介绍。
- 第 8.2 节:装袋、随机森林、提升
2013 年出版的《应用预测建模》一书涵盖了最流行的集成算法，并以 R 为例，重点介绍了决策树的集成。
- 第八章:回归树和基于规则的模型
- 第十四章:分类树和基于规则的模型
2016 年出版的《数据挖掘:实用机器学习工具和技术》一书提供了一章专门介绍集成学习，涵盖了一系列流行技术，包括提升、装袋和堆叠。
- 第十二章:集成学习。
2012 年出版的《机器学习:概率视角》一书提供了许多关于执行集合的算法的章节，以及一个专门讨论堆叠和纠错输出代码的章节。
- 第 16.2 节:分类和回归树
- 第 16.4 节:增压
- 第 16.6 节:整体学习
2016 年出版的《统计学习的要素》一书涵盖了集成学习的关键算法以及集成学习的一般理论。
- 第八章:模型推断和平均
- 第十章:增强树和加法树
- 第十五章:随机森林
- 第十六章:集成学习
我是不是错过了你最喜欢的机器学习教材，里面有一节是关于集成学习的？
在下面的评论里告诉我。
推荐
我每本书都有一本，因为我喜欢从多个角度阅读某个主题。
如果你正在寻找一个坚实的教科书致力于整体学习的主题，我会推荐以下之一:
- 集成方法:基础与算法，2012。
- 集成学习:使用集成方法的模式分类，2019。
紧随其后的是数据挖掘中的“T0”集成方法，它混合了 r
- 数据挖掘中的集成方法，2010。
还有，我推荐集成方法模式分类“如果你拿不到最近的”集成学习:集成方法模式分类。
- 使用集成方法的模式分类，2010。
摘要
在这篇文章中，你发现了一套关于集成机器学习的书籍。
你有什么问题吗？
在下面的评论中提问，我会尽力回答。
Python 集成机器学习（7 天迷你课程）
原文：https://machinelearningmastery.com/ensemble-machine-learning-with-python-7-day-mini-course/
Python 速成班的集成学习算法。
用 Python 在 7 天内掌握集成学习。
集成学习指的是结合两个或更多模型的预测的机器学习模型。
集成是一种先进的机器学习方法，通常在预测的能力和技巧比使用简单易懂的模型更重要时使用。因此，它们经常被机器学习竞赛的顶尖和获奖参与者使用，如百万美元网飞奖和卡格尔竞赛。
像 Sklearn Python 这样的现代机器学习库提供了一套高级集成学习方法，这些方法易于配置和正确使用，不会出现数据泄漏，这是使用集成算法时的一个常见问题。
在这个速成课程中，您将发现如何在七天内开始并自信地将集成学习算法带到您的 Python 预测建模项目中。
这是一个又大又重要的岗位。你可能想把它做成书签。
用我的新书Python 集成学习算法启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
Python 集成机器学习(7 天迷你课程)
图片由和提供，保留部分权利。
这个速成班是给谁的？
在我们开始之前，让我们确保你在正确的地方。
本课程面向可能了解一些应用机器学习的开发人员。也许你知道如何用流行的工具来从头到尾解决一个预测建模问题，或者至少是大部分的主要步骤。
本课程中的课程假设了您的一些情况，例如:
- 你对编程的基本 Python 很熟悉。
- 您可能知道一些用于数组操作的基本 NumPy。
- 你可能知道一些基本的 sci kit-学习建模。
你不需要:
- 数学天才！
- 机器学习专家！
这门速成课程将把你从一个懂一点机器学习的开发人员带到一个能在预测建模项目中有效和胜任地应用集成学习算法的开发人员。
注意:本速成课程假设您有一个至少安装了 NumPy 的工作 Python 3 SciPy 环境。如果您需要环境方面的帮助，可以遵循这里的逐步教程:
- 如何用 Anaconda 设置机器学习的 Python 环境
速成班概述
这门速成课分为七节课。
您可以每天完成一节课(推荐)或一天内完成所有课程(硬核)。这真的取决于你有多少时间和你的热情程度。
下面是用 Python 进行数据准备的七个经验教训:
- 第 01 课:什么是集成学习？
- 第 02 课:装袋集成
- 第 03 课:随机森林集成
- 第 04 课 : AdaBoost 集成
- 第 05 课:梯度提升集成
- 第 06 课:投票团
- 第 07 课:堆叠集成
每节课可能需要你 60 秒或 30 分钟。慢慢来，按照自己的节奏完成课程。提问，甚至在下面的评论中发布结果。
这些课程可能期望你去发现如何做事。我会给你一些提示，但是每节课的部分要点是迫使你学习去哪里寻找关于 Python 中的算法和最佳工具的帮助。(提示 : 我有这个博客所有的答案；使用搜索框。)
在评论中发布你的结果；我会为你加油的！
坚持住。不要放弃。
第一课:什么是集成学习？
在本课中，您将发现什么是集成学习，以及为什么它很重要。
应用机器学习通常涉及在数据集上拟合和评估模型。
鉴于我们无法事先知道哪个模型在数据集上表现最佳，这可能需要大量的反复试验，直到我们找到一个表现良好或最适合我们项目的模型。
另一种方法是准备多个不同的模型，然后组合它们的预测。
这被称为集成机器学习模型，或简称为集成，而寻找表现良好的集成模型的过程被称为“集成学习”
尽管实现这一点的方法几乎是无限的，但在实践中最常讨论和使用的集成学习技术可能有三类。
它们之所以受欢迎，很大程度上是因为它们易于实现，并且在广泛的预测建模问题上取得了成功。
它们是:
- 装袋，如装袋决策树、随机林。
- 升压，例如 adaboost 和梯度升压
- 堆叠，例如投票和使用元模型。
在单个模型上使用集合有两个主要原因，它们是相关的；它们是:
- 可靠性:集成可以减少预测的方差。
- 技能:集成可以达到比单一模式更好的表现。
这些都是机器学习项目的重要关注点，有时我们可能更喜欢模型的一个或两个属性。
你的任务
这节课，你必须列出集合学习的三个应用。
这些可能是著名的例子，比如机器学习竞赛，或者你在教程、书籍或研究论文中遇到的例子。
在下面的评论中发表你的答案。我想看看你有什么想法。
在下一课中，您将发现如何开发和评估 bagging 集成。
第二课:装袋集成
在本课中，您将发现引导聚合，或装袋，集成。
装袋通过创建训练数据集的样本并在每个样本上拟合决策树来工作。
训练数据集的差异导致拟合决策树的差异，进而导致这些树做出的预测的差异。然后使用简单的统计数据，如投票或平均，将全体成员做出的预测结合起来。
该方法的关键是数据集的每个样本准备训练集合成员的方式。示例(行)是从数据集中随机抽取的，尽管进行了替换。替换意味着如果选择了一行，它将返回到训练数据集中，以便在同一训练数据集中进行可能的重新选择。
这被称为引导样本，给这项技术命名。
装袋在 Sklearn 中通过装袋分类器和装袋分类器类提供，默认情况下，它们使用决策树作为基本模型，您可以通过“n _ estimates”参数指定要创建的树的数量。
下面列出了评估装袋集合进行分类的完整示例。
# example of evaluating a bagging ensemble for classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.ensemble import BaggingClassifier
# create the synthetic classification dataset
X, y = make_classification(random_state=1)
# configure the ensemble model
model = BaggingClassifier(n_estimators=50)
# configure the resampling method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the ensemble on the dataset using the resampling method
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report ensemble performance
print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
你的任务
在本课中，您必须运行示例并查看评估模型的结果。
对于加分，评估在集合中使用更多决策树的效果，甚至改变使用的基础学习器。
在下面的评论中发表你的答案。我想看看你有什么想法。
在下一课中，您将发现如何开发和评估随机森林集合。
第 03 课:随机森林集合
在本课中，您将发现随机森林集合。
随机森林是装袋集成的延伸。
像装袋一样，随机森林集成在训练数据集的不同引导样本上拟合决策树。
与装袋不同，随机森林还将对每个数据集的要素(列)进行采样。
具体来说，在构建每个决策树时，在数据中选择分割点。随机森林不会在选择分割点时考虑所有要素，而是将要素限制为要素的随机子集，例如，如果有 10 个要素，则为 3 个。
随机森林集成在 Sklearn 中通过随机森林分类器和随机森林回归器类提供。您可以通过“n _ estimates”参数指定要创建的树的数量，并通过“ max_features ”参数指定要在每个分割点考虑的随机选择的要素的数量，默认情况下，该参数设置为数据集中要素数量的平方根。
下面列出了评估随机森林集合进行分类的完整示例。
# example of evaluating a random forest ensemble for classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.ensemble import RandomForestClassifier
# create the synthetic classification dataset
X, y = make_classification(random_state=1)
# configure the ensemble model
model = RandomForestClassifier(n_estimators=50)
# configure the resampling method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the ensemble on the dataset using the resampling method
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report ensemble performance
print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
你的任务
在本课中，您必须运行示例并查看评估模型的结果。
对于加分项，评估在集合中使用更多决策树或调整每个分割点要考虑的特征数量的效果。
在下面的评论中发表你的答案。我想看看你有什么想法。
在下一课中，您将发现如何开发和评估 AdaBoost 集成。
第 04 课:AdaBoost 集成
在本课中，您将发现自适应增强或 AdaBoost 集成。
增强包括将模型按顺序添加到集合中，其中新模型试图纠正已经添加到集合中的先前模型所产生的错误。这样，添加的集成成员越多，集成预计产生的错误就越少，至少在数据支持的限度内，并且在过拟合训练数据集之前。
boosting 的思想最初是作为一种理论思想发展起来的，AdaBoost 算法是实现基于 boosting 的集成算法的第一种成功方法。
AdaBoost 的工作原理是在经过加权的训练数据集版本上拟合决策树，使得该树更多地关注先前成员出错的示例(行)，而较少关注先前模型正确的示例(行)。
AdaBoost 使用非常简单的树，在进行预测之前，对一个输入变量进行单一决策，而不是完整的决策树。这些矮树被称为决策树桩。
AdaBoost 在 Sklearn 中通过adaboosttclassifier和adaboosttregressor类提供，默认情况下，它们使用决策树(决策树桩)作为基本模型，您可以通过“n _ estimates”参数指定要创建的树的数量。
下面列出了评估 AdaBoost 集成进行分类的完整示例。
# example of evaluating an adaboost ensemble for classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.ensemble import AdaBoostClassifier
# create the synthetic classification dataset
X, y = make_classification(random_state=1)
# configure the ensemble model
model = AdaBoostClassifier(n_estimators=50)
# configure the resampling method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the ensemble on the dataset using the resampling method
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report ensemble performance
print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
你的任务
在本课中，您必须运行示例并查看评估模型的结果。
对于加分，评估在集合中使用更多决策树的效果，甚至改变使用的基础学习器(注意，它必须支持加权训练数据)。
在下面的评论中发表你的答案。我想看看你有什么想法。
在下一课中，您将发现如何开发和评估梯度提升集成。
第五课:梯度提升集成
在本课中，您将发现梯度提升集成。
梯度提升是提升集成算法的框架，是 AdaBoost 的扩展。
它将 boosting 重新构建为统计框架下的加法模型，并允许使用任意损失函数使其更加灵活，以及损失惩罚(收缩)以减少过拟合。
梯度提升还向集成成员引入了装袋的思想，例如对训练数据集的行和列进行采样，称为随机梯度提升。
对于结构化或表格数据，这是一种非常成功的集成技术，尽管考虑到模型是按顺序添加的，拟合模型可能会很慢。已经开发了更有效的实现，例如流行的极限梯度提升(XGBoost)和光梯度提升机(LightGBM)。
梯度提升在 Sklearn 中通过梯度提升分类器和梯度提升回归器类提供，默认情况下，它们使用决策树作为基本模型。您可以通过“n _ estimates”参数指定要创建的树的数量，并通过默认为 0.1 的“ learning_rate ”参数指定控制每个树的贡献的学习率。
下面列出了评估用于分类的梯度提升集成的完整示例。
# example of evaluating a gradient boosting ensemble for classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.ensemble import GradientBoostingClassifier
# create the synthetic classification dataset
X, y = make_classification(random_state=1)
# configure the ensemble model
model = GradientBoostingClassifier(n_estimators=50)
# configure the resampling method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the ensemble on the dataset using the resampling method
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report ensemble performance
print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
你的任务
在本课中，您必须运行示例并查看评估模型的结果。
对于加分，评估在集成中使用更多决策树的效果，或者尝试不同的学习率值。
在下面的评论中发表你的答案。我想看看你有什么想法。
在下一课中，您将发现如何开发和评估投票组合。
第 06 课:投票团
在本课中，您将发现投票组合。
投票集合使用简单的统计数据来组合来自多个模型的预测。
通常，这包括在同一训练数据集上拟合多个不同的模型类型，然后在回归或分类投票最多的类标签的情况下计算平均预测，称为硬投票。
当通过合计预测概率并选择具有最大合计概率的标签来预测分类问题上类别标签的概率时，也可以使用投票。这被称为软投票，当集成中使用的基本模型本身支持预测类概率时，它是首选的，因为它可以产生更好的表现。
Sklearn 中的投票组合可通过 VotingClassifier 和voting retriever课程获得。基本模型的列表可以作为模型的参数提供，列表中的每个模型必须是一个带有名称和模型的元组，例如*(“lr”，logisticreduce())*。用于分类的投票类型可以通过“投票参数指定，并设置为“软或“硬”。
下面列出了评估投票集合进行分类的完整示例。
# example of evaluating a voting ensemble for classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.ensemble import VotingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
# create the synthetic classification dataset
X, y = make_classification(random_state=1)
# configure the models to use in the ensemble
models = [('lr', LogisticRegression()), ('nb', GaussianNB())]
# configure the ensemble model
model = VotingClassifier(models, voting='soft')
# configure the resampling method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the ensemble on the dataset using the resampling method
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report ensemble performance
print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
你的任务
在本课中，您必须运行示例并查看评估模型的结果。
对于加分，评估在集成中尝试不同类型模型的效果，甚至将投票类型从软投票改为硬投票。
在下面的评论中发表你的答案。我想看看你有什么想法。
在下一课中，您将发现如何开发和评估堆叠集合。
第 07 课:堆叠集成
在本课中，您将发现堆叠概括或堆叠集合。
叠加包括组合多个不同类型的基础模型的预测，很像投票。
与投票的重要区别在于，另一个机器学习模型用于学习如何最好地组合基础模型的预测。这通常是一个线性模型，例如用于回归问题的线性回归或用于分类的逻辑回归，但也可以是您喜欢的任何机器学习模型。
元模型基于基础模型对样本外数据的预测进行训练。
这包括对每个基础模型使用 k 倍交叉验证并存储所有超出范围的预测。然后在整个训练数据集上训练基本模型，元模型在不一致的预测上训练，并学习信任哪个模型、信任它们的程度以及在什么情况下。
虽然内部堆叠使用 k-fold 交叉验证来训练元模型，但是您可以以任何您喜欢的方式评估堆叠模型，例如通过 train-test 拆分或 k-fold 交叉验证。模型的评估与内部的重采样训练过程是分开的。
堆叠集成在 Sklearn 中通过堆叠分类器和堆叠回归器课程提供。基本模型的列表可以作为模型的参数提供，列表中的每个模型必须是一个带有名称和模型的元组，例如*(“lr”，logisticreduce())*。元学习器可以通过“ final_estimator 参数指定，重采样策略可以通过“ cv 参数指定，并且可以简单地设置为指示交叉验证折叠次数的整数。
下面列出了评估堆叠集合进行分类的完整示例。
# example of evaluating a stacking ensemble for classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.ensemble import StackingClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
# create the synthetic classification dataset
X, y = make_classification(random_state=1)
# configure the models to use in the ensemble
models = [('knn', KNeighborsClassifier()), ('tree', DecisionTreeClassifier())]
# configure the ensemble model
model = StackingClassifier(models, final_estimator=LogisticRegression(), cv=3)
# configure the resampling method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the ensemble on the dataset using the resampling method
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report ensemble performance
print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
你的任务
在本课中，您必须运行示例并查看评估模型的结果。
对于加分，评估在集合中尝试不同类型的模型和不同元模型来组合预测的效果。
在下面的评论中发表你的答案。我想看看你有什么想法。
这是最后一课。
末日！
( 看你走了多远
你成功了。干得好！
花一点时间，回头看看你已经走了多远。
你发现了:
- 什么是集成学习，为什么要在预测建模项目中使用它。
- 如何使用引导聚合或装袋集成。
- 如何使用随机森林集合作为装袋的延伸？
- 如何使用自适应增强或 adaboost 集成？
- 如何使用梯度提升集成？
- 如何使用投票集合组合模型的预测。
- 如何学习如何使用叠加集合组合模型的预测。
摘要
你觉得迷你课程怎么样？
你喜欢这个速成班吗？
你有什么问题吗？有什么症结吗？
让我知道。请在下面留言。
扫一扫
892
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
