当前位置：首页 > article >正文

集成学习（一）：从理论到实战(附代码)

article 2025/2/13 6:18:22

一、引言

在机器学习领域，打造一个独立、强大的算法是解决问题的关键。然而，集成学习提供了一种不同的视角：通过组合多个“弱”学习器来创建一个更强大的模型。本文探讨集成学习的思想、方法及其应用。

二、机器学习 vs 集成学习思想

传统机器学习思想

打造一个独立、强大的算法：传统的机器学习倾向于开发一种能够解决特定问题的高效算法。
单个算法打天下：强调单一算法的能力，试图找到适用于广泛问题的最佳解决方案。
个人英雄主义：注重单个算法的性能和能力。

集成学习思想

群狼打败猛虎的策略：集成学习采用集体智慧战胜单个强者的策略。
管理理念：招募一批二流货色，组合成一个强大的团队，以干掉一流货色。
三个臭皮匠顶个诸葛亮：通过结合多个简单的模型（弱评估器），可以构建出比任何单独模型都更强的预测模型。

三、集成学习要素

一批弱分类器：这些分类器或回归器各自的表现并不突出，但当它们组合在一起时，能显著提高整体性能。
组合策略：如何有效地将这些弱学习器的结果结合起来形成最终预测。

四、集成学习策略

4.1 Voting

思想：数据相同，算法不同，对不同算法的结果，采用多数原则

VotingClassifier 和 VotingRegressor 是集成学习中用于分类和回归任务的两种元估计器（meta-estimators）。它们的基本思想是结合多个不同的模型（通常称为“弱学习器”或基础估计器）的预测结果，以期通过集体决策来提高整体模型的性能。这种策略基于的是“群体智慧”的理念，即多个模型的组合可以比单个模型更准确。

4.1.1 VotingClassifier

VotingClassifier 主要用于分类问题，它可以通过两种主要的方式来进行投票：硬投票（hard voting）和软投票（soft voting）。

硬投票（Hard Voting）：
- 在硬投票中，每个分类器对输入数据进行分类，并将得票最多的类别作为最终的预测结果。
- 例如，如果有三个分类器分别预测 [0, 1, 1]，那么最终的预测结果将是 1，因为两个分类器都投了 1。
软投票（Soft Voting）：
- 软投票需要所有基础分类器都能够输出概率估计（即支持度），然后根据这些概率计算加权平均值，选择具有最高平均概率的类别作为预测结果。
- 这种方法考虑了每个类别的置信度，因此在理论上可能比硬投票更精确。

示例代码

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import VotingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# 创建示例数据集
# 这是Scikit-learn中的一个函数，用于生成一个合成的分类数据集。
# n_samples=1000：生成的数据集中包含1000个样本。
# n_features=20：每个样本有20个特征。
# random_state=42：设置随机种子以确保每次运行代码时生成的数据集相同。这对于实验的可重复性非常重要。
# X：形状为 (1000, 20) 的二维数组，表示1000个样本的20个特征。
# y：长度为1000的一维数组，表示每个样本对应的标签（类别）。
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
# 数据集分割
# test_size=0.3：指定测试集占总数据集的比例为30%。因此，70%的数据将被分配给训练集。
# random_state=42：再次设置随机种子，确保每次运行代码时数据集的划分方式相同。
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义基础分类器
# LogisticRegression逻辑回归分类器
# multi_class='multinomial'：指定使用多项式逻辑回归来处理多分类问题。
# random_state=1：设置随机种子，使得结果具有可重复性。
clf1 = LogisticRegression(multi_class='multinomial', random_state=1)
# RandomForestClassifier：随机森林算法，通过构建多个决策树并汇总它们的预测结果来进行分类。
# n_estimators=50：指定随机森林中决策树的数量为50。
# random_state=1：设置随机种子，使得结果具有可重复性。
clf2 = RandomForestClassifier(n_estimators=50, random_state=1)
# GaussianNB：高斯朴素贝叶斯分类器
clf3 = GaussianNB()

# 创建VotingClassifier实例
voting_clf = VotingClassifier(estimators=[('lr', clf1), ('rf', clf2), ('gnb', clf3)], voting='hard') # 或者使用 'soft'

# 训练模型
voting_clf.fit(X_train, y_train)

# 预测
predictions = voting_clf.predict(X_test)

举一个软投票的例子，并说明投票的过程，使用软投票策略进行预测，并为每个分类器指定不同的权重。

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 生成合成数据集
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

# 将数据集划分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义基础分类器
clf1 = LogisticRegression(multi_class='multinomial', random_state=1)
clf2 = RandomForestClassifier(n_estimators=50, random_state=1)
clf3 = GaussianNB()

# 创建VotingClassifier实例，设置voting='soft'表示使用软投票，并指定各分类器的权重
voting_clf_soft_weighted = VotingClassifier(estimators=[
    ('lr', clf1), 
    ('rf', clf2), 
    ('gnb', clf3)
], voting='soft', weights=[2, 1, 1])

# 训练模型
voting_clf_soft_weighted.fit(X_train, y_train)

# 使用训练好的模型进行预测
y_pred_soft_weighted = voting_clf_soft_weighted.predict(X_test)

# 计算并打印准确率
accuracy_soft_weighted = accuracy_score(y_test, y_pred_soft_weighted)
print(f"Soft Voting Classifier with Weights Accuracy: {accuracy_soft_weighted:.4f}")

带权重的软投票的工作原理

在这个例子中，我们为每个分类器指定了不同的权重：

逻辑回归 (LogisticRegression)：权重为2。
随机森林 (RandomForestClassifier)：权重为1。
高斯朴素贝叶斯 (GaussianNB)：权重为1。

这意味着逻辑回归的预测概率将被赋予两倍于其他两个分类器的重要性。

具体步骤如下：

预测概率：对于每个测试样本，每个分类器都会输出一个概率向量。

假设我们有一个测试样本 x，三个分类器对其类别 [0, 1, 2] 的预测概率分别为：
- 逻辑回归：[0.2, 0.5, 0.3]
- 随机森林：[0.3, 0.4, 0.3]
- 高斯朴素贝叶斯：[0.1, 0.6, 0.3]
加权平均：根据指定的权重，对每个类别的概率进行加权平均。例如，假设权重为 [2, 1, 1]，则计算方法如下：
- 类别0的加权平均概率：(2 * 0.2 + 1 * 0.3 + 1 * 0.1) / (2 + 1 + 1) = (0.4 + 0.3 + 0.1) / 4 = 0.2
- 类别1的加权平均概率：(2 * 0.5 + 1 * 0.4 + 1 * 0.6) / 4 = (1.0 + 0.4 + 0.6) / 4 = 0.5
- 类别2的加权平均概率：(2 * 0.3 + 1 * 0.3 + 1 * 0.3) / 4 = (0.6 + 0.3 + 0.3) / 4 = 0.3
选择最高概率的类别：根据加权平均后的概率向量，选择具有最高概率的类别作为最终预测结果。在这个例子中，类别1的概率最高（0.5），因此最终预测结果为类别1。

带权重的软投票通过结合多个分类器的概率预测结果并考虑不同分类器的重要性来提高整体模型的准确性。

4.1.2 VotingRegressor

VotingRegressor 则适用于回归任务。它的工作原理与 VotingClassifier 类似，但不是通过投票来决定类别，而是通过对各个基础回归器的预测结果取平均值（或其他聚合方式）来得到最终的预测值。

平均法：最简单直接的方法是对所有基础回归器的预测结果求均值作为最终的预测值。
加权平均法：可以为每个回归器分配一个权重，然后根据这些权重计算加权平均值。

示例代码：

from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.svm import SVR
from sklearn.ensemble import VotingRegressor
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split

# 创建示例数据集
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义基础回归器
reg1 = LinearRegression()
reg2 = RandomForestRegressor(n_estimators=50, random_state=1)
reg3 = SVR()

# 创建VotingRegressor实例
voting_reg = VotingRegressor(estimators=[('lr', reg1), ('rf', reg2), ('svr', reg3)])

# 训练模型
voting_reg.fit(X_train, y_train)

# 预测
predictions = voting_reg.predict(X_test)

4.1.3 总结

VotingClassifier 和 VotingRegressor 提供了一种简单而有效的方法来集成多个模型，以提高预测性能。
对于分类任务，可以选择硬投票或软投票；对于回归任务，默认采用的是平均预测值的方法。
使用这些集成方法时，重要的是确保所选的基础模型具有一定的多样性，这样可以最大化集成的效果。如果所有模型都非常相似，那么集成可能不会带来显著的性能提升。

4.2 Bagging

Bootstrap Sampling：从原始数据集中随机抽取样本（有放回抽样），创建多个不同的子集。
独立训练模型：在每个子集上使用相同的算法训练一个模型。
聚合结果：
- 对于分类问题，通常采用多数投票的方式决定最终类别（适用于BaggingClassifier）。
- 对于回归问题，通常采用平均值的方式来决定最终预测值（适用于BaggingRegressor）。

BaggingClassifier 和 BaggingRegressor 是集成学习方法中的一种，它们基于Bootstrap aggregating（简称Bagging）技术。

4.2.1 BaggingClassifier

BaggingClassifier 用于分类任务。它通过构建多个基础分类器，并对这些分类器的预测结果进行投票来确定最终的预测结果。

示例代码

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 生成合成数据集
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

# 将数据集划分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义基础分类器
base_classifier = DecisionTreeClassifier()

# 创建BaggingClassifier实例
bagging_clf = BaggingClassifier(base_estimator=base_classifier, 
                                n_estimators=100, 
                                max_samples=0.5, 
                                max_features=0.5,
                                random_state=42)

# 训练模型
bagging_clf.fit(X_train, y_train)

# 使用训练好的模型进行预测
y_pred = bagging_clf.predict(X_test)

# 计算并打印准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"Bagging Classifier Accuracy: {accuracy:.4f}")

base_estimator：指定作为基础模型的分类器，默认为决策树。
n_estimators：指定要训练的基础模型的数量。
max_samples：每个基础模型使用的样本数比例（可以小于1表示使用部分样本）。
max_features：每个基础模型使用的特征数比例（可以小于1表示使用部分特征）。

4.2.2 BaggingRegressor

BaggingRegressor 用于回归任务。它通过构建多个基础回归器，并对这些回归器的预测结果取平均值来确定最终的预测结果。

示例代码

from sklearn.ensemble import BaggingRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# 生成合成数据集
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)

# 将数据集划分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义基础回归器
base_regressor = DecisionTreeRegressor()

# 创建BaggingRegressor实例
bagging_reg = BaggingRegressor(base_estimator=base_regressor, 
                               n_estimators=100, 
                               max_samples=0.5, 
                               max_features=0.5,
                               random_state=42)

# 训练模型
bagging_reg.fit(X_train, y_train)

# 使用训练好的模型进行预测
y_pred = bagging_reg.predict(X_test)

# 计算并打印均方误差
mse = mean_squared_error(y_test, y_pred)
print(f"Bagging Regressor MSE: {mse:.4f}")

参数解释与BaggingClassifier类似，只是基础模型换成了回归器，评估指标也相应地变为了回归任务常用的均方误差（MSE）。

4.2.3 总结

BaggingClassifier 和 BaggingRegressor 通过在不同的数据子集上训练多个相同类型的模型，并结合它们的预测结果来提高模型的性能。
在分类问题中，Bagging通过多数投票来决定最终类别；在回归问题中，则通过计算预测值的平均值来得到最终结果。

4.3 Stacking

基础模型：在第一阶段，使用不同的算法训练多个基础模型。这些模型可以是任何类型的分类器或回归器。
元模型：在第二阶段，使用一个新的模型（元模型）来学习如何最好地结合基础模型的预测结果。元模型接收的是基础模型对训练数据的预测作为输入特征，并试图学习一个最佳的组合策略。
交叉验证：为了避免过拟合，通常使用交叉验证的方法来生成用于训练元模型的数据集。也就是说，基础模型的预测不是直接基于整个训练集，而是基于每个基础模型在其未见过的数据上的预测结果。

StackingClassifier 和 StackingRegressor 是集成学习方法中的另一种技术，称为堆叠（Stacking）。堆叠的核心思想是通过训练多个基础模型（也称作第一层模型或弱学习器），然后使用另一个模型（称为元模型或第二层模型）来结合这些基础模型的预测结果，从而生成最终的预测。这种方法允许模型之间进行更复杂的交互，并且能够利用不同模型的优点。

4.3.1 StackingClassifier

StackingClassifier 适用于分类任务，它通过将多个基础分类器的结果传递给一个元分类器来进行最终的分类决策。

示例代码

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import StackingClassifier
from sklearn.metrics import accuracy_score

# 生成合成数据集
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

# 将数据集划分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义基础分类器
base_classifiers = [
    ('rf', RandomForestClassifier(n_estimators=100, random_state=42)),
    ('gb', GradientBoostingClassifier(n_estimators=100, random_state=42))
]

# 定义元分类器
meta_classifier = LogisticRegression()

# 创建StackingClassifier实例
stacking_clf = StackingClassifier(estimators=base_classifiers, final_estimator=meta_classifier, cv=5)

# 训练模型
stacking_clf.fit(X_train, y_train)

# 使用训练好的模型进行预测
y_pred = stacking_clf.predict(X_test)

# 计算并打印准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"Stacking Classifier Accuracy: {accuracy:.4f}")

estimators：指定一组基础分类器。
final_estimator：指定元分类器，用于学习如何结合基础分类器的输出。
cv：指定交叉验证的折数，默认为5折交叉验证。这确保了元模型不会直接看到基础模型的训练数据，从而减少过拟合的风险。

4.3.2 StackingRegressor

StackingRegressor 类似于 StackingClassifier，但适用于回归任务。它通过将多个基础回归器的结果传递给一个元回归器来进行最终的预测。

示例代码

from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import StackingRegressor
from sklearn.metrics import mean_squared_error

# 生成合成数据集
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)

# 将数据集划分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义基础回归器
base_regressors = [
    ('rf', RandomForestRegressor(n_estimators=100, random_state=42)),
    ('gb', GradientBoostingRegressor(n_estimators=100, random_state=42))
]

# 定义元回归器
meta_regressor = LinearRegression()

# 创建StackingRegressor实例
stacking_reg = StackingRegressor(estimators=base_regressors, final_estimator=meta_regressor, cv=5)

# 训练模型
stacking_reg.fit(X_train, y_train)

# 使用训练好的模型进行预测
y_pred = stacking_reg.predict(X_test)

# 计算并打印均方误差
mse = mean_squared_error(y_test, y_pred)
print(f"Stacking Regressor MSE: {mse:.4f}")

参数设置与 StackingClassifier 类似，只是这里的基础模型和元模型都是针对回归任务设计的。

如何理解将多个基础分类器的结果传递给一个元分类器来进行最终的分类决策?

关键点解析：

基础模型（Base Models）：可以是任何类型的机器学习模型，例如决策树、支持向量机、神经网络等。在分类任务中，它们被称为基础分类器；在回归任务中，它们被称为基础回归器。
元模型（Meta Model）：这是一个单独的模型，它接收基础模型对训练数据的预测结果作为输入，并基于这些预测进行最终的预测。对于分类问题，元模型输出的是类别标签；对于回归问题，元模型输出的是连续值。

详细解释

基础分类器的预测：首先，你有一组不同的基础分类器（比如逻辑回归、随机森林和K近邻）。每个分类器都会对相同的训练集或验证集做出预测。这些预测结果通常是一个概率分布（对于每个样本属于各个类别的概率）或者直接是类别标签。
生成新的特征集：接下来，利用这些基础分类器对训练集的预测结果来创建一个新的特征集。具体来说，如果有一个包含N个样本的数据集，且有M个基础分类器，则每个样本现在会对应M个预测值（如果是概率形式，则可能是M*K个值，其中K是类别的数量）。这实际上为原始数据集添加了一层新的特征表示。
元分类器的训练：然后，使用上述步骤生成的新特征集作为输入来训练元分类器。也就是说，元分类器不是直接基于原始特征进行训练，而是基于基础分类器的预测结果进行训练。这样做的目的是让元分类器学会如何最好地整合来自不同基础分类器的信息，从而做出更准确的最终预测。
最终的分类决策：一旦元分类器训练完成，在测试阶段，首先用所有基础分类器对测试集进行预测，然后将这些预测结果作为输入传递给元分类器，由元分类器根据这些信息做出最终的分类决定。

示例流程

假设我们有三个基础分类器：clf1, clf2, 和 clf3，以及一个元分类器 meta_clf。

对于训练集中的每个样本，分别得到 clf1, clf2, 和 clf3 的预测结果。
使用这些预测结果作为新特征来训练 meta_clf。
在测试阶段，同样获取这三个分类器对测试集的预测结果。
将这三个分类器的预测结果输入到 meta_clf 中，meta_clf 根据这些输入给出最终的分类结果。

这种机制使得堆叠能够有效地利用多个模型的优势，克服单个模型可能存在的局限性，进而提升整个系统的预测能力。

4.3.3 总结

StackingClassifier 和 StackingRegressor 通过构建多个基础模型并将它们的预测结果传递给一个元模型来实现最终的预测。
这种方法允许模型之间进行更复杂的交互，并能够利用不同模型的优点，提高整体模型的性能。
使用交叉验证来生成元模型的训练数据，有助于防止过拟合，使得模型更加稳定和可靠。
在实践中，调整超参数和考虑模型之间的多样性也是优化堆叠模型性能的重要方面。

4.4 Boosting

错题本思想：通过调整错误分类实例的权重，使得后续分类器更加关注这些困难案例。

AdaBoost 和 Gradient Boosting 是两种基于提升（Boosting）策略的集成学习方法，它们通过构建一系列弱学习器并将这些弱学习器组合成一个强学习器来提高预测性能。

4.4.1 AdaBoost

AdaBoost（Adaptive Boosting）是一种迭代算法，它通过对先前分类错误的数据点赋予更高的权重来逐步改进模型。

4.4.1.1 AdaBoostClassifier

from sklearn.ensemble import AdaBoostClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# 创建合成数据集
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义AdaBoost分类器
adaboost_clf = AdaBoostClassifier(n_estimators=50, random_state=42)

# 训练模型
adaboost_clf.fit(X_train, y_train)

# 预测
predictions = adaboost_clf.predict(X_test)

4.4.1.2 AdaBoostRegressor

工作原理：类似于 AdaBoostClassifier，但用于回归任务。它通过最小化损失函数来更新样本权重，并结合多个弱回归器的结果以生成最终预测值。
- 不同之处：主要在于如何计算每个弱学习器的贡献以及如何更新样本权重，具体细节依赖于所使用的损失函数（如线性、平方等）。

from sklearn.ensemble import AdaBoostRegressor
from sklearn.datasets import make_regression

# 创建合成数据集
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 定义AdaBoost回归器
adaboost_reg = AdaBoostRegressor(n_estimators=50, random_state=42)

# 训练模型
adaboost_reg.fit(X_train, y_train)

# 预测
predictions = adaboost_reg.predict(X_test)

4.4.2 Gradient Boosting

Gradient Boosting 是一种前向分步算法，它通过添加新的模型来纠正现有模型的误差，从而逐步降低损失函数的值。

4.4.2.1 GradientBoostingClassifier

工作原理：从一个简单的初始模型（通常是常数预测）开始，然后依次添加新的弱学习器（通常是决策树），每个新添加的模型都试图减少整体模型的损失函数。具体来说，每个新的弱学习器都是基于前一轮模型的残差（即预测值与真实值之间的差异）进行训练的。

from sklearn.ensemble import GradientBoostingClassifier

# 定义Gradient Boosting分类器
gb_clf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)

# 训练模型
gb_clf.fit(X_train, y_train)

# 预测
predictions = gb_clf.predict(X_test)

4.4.2.2 GradientBoostingRegressor

工作原理：与 GradientBoostingClassifier 类似，但用于回归任务。它的目标是最小化回归任务中的损失函数（如均方误差）。
- 过程：从初始估计开始，随后每一步都添加一个新的弱学习器，该学习器专注于拟合上一步中模型预测值与实际值之间的残差，以此来逐步改善模型的整体性能。

from sklearn.ensemble import GradientBoostingRegressor

# 定义Gradient Boosting回归器
gb_reg = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)

# 训练模型
gb_reg.fit(X_train, y_train)

# 预测
predictions = gb_reg.predict(X_test)