集成学习实战：从Voting到Stacking的原理与Python实现

做机器学习做到一定阶段，你就会发现一个尴尬的事实：单个模型的天花板，往往比你想象中来得更早。也许你在一棵决策树上调了半天超参数，准确率卡在 0.86 上不去；换成逻辑回归，结果还往下掉了两个点。这时候群里老哥可能会说一句：试试集成学习。于是你第一次见到 Bagging、Boosting、随机森林、Adaboost 这些名词，觉得又是一堆新算法要背。其实它们的核心思维特别朴素：一个模型拿不准的事，那就多找几个模型，让它们分别判断再商量着来。

我最初理解集成学习的时候，是在自己用 Python 做机器学习项目时被一记“闷棍”打醒的。单模型反复调优很久，换了个集成方法之后，测试分数直接往上走，而且代码量并没有增加多少。更关键的是，集成学习不是某一种具体算法，而是一整套“组织多个模型进行预测”的思想，包括 Voting、Bagging、Boosting、Stacking，以及基于这些思想衍生出的随机森林、Adaboost 等。这篇文章就顺着这条路线走一遍，讲清楚每种方法到底在解决什么问题、代码怎么落地、实操中有哪些坑。

1. 为什么要集成：单模型的天花板在哪，集成怎么破

1.1 偏差和方差：单模型翻车主要翻在这两个地方

要把集成学习理解到位，必须先认识监督学习里的一个经典分解：模型误差可以大致拆成偏差（Bias）和方差（Variance）。我习惯用“打靶”来解释。靶心是真实规律，你每一发子弹是一个训练出来的模型。

• 高偏差：子弹都打在一个偏离靶心的位置，弹孔集中但整体偏左或偏右。对应模型太简单，比如用线性模型去拟合强非线性关系，这时候无论怎么加数据都救不回来。
• 高方差：子弹围在靶心周围，但散布很大，有时候正中十环，有时候飞到外圈。对应模型太灵活，比如不剪枝的深决策树，训练集上记得死死的，换一批数据表现就崩。

传统单模型训练，本质是在偏差和方差之间做权衡。你说我把决策树剪枝剪猛一点，偏差上去了；我再加深树模型，方差又上来了。你在同一个模型上折腾来折腾去，相当于是一个人来回调自己的枪法，怎么练都有极限。

集成学习换了思路：我不要求某一个模型打得又稳又准，我训练一批弱一些的模型，各自有各自的特点，最后让群体决策。统计学里有个基本结论，多个独立且误差不相关的模型做平均，方差会显著下降；再进一步，如果模型之间存在互补性，一个模型错的地方另一个模型能对回来，那集体决策的准确率会比任何单模型都高。

1.2 Voting 和平均：最朴素的集成方式，但已经能提升稳定性

集成学习里最容易先上手的，就是 Voting 和平均（Averaging）。它不要求你对模型做任何结构改动，只需把几个已经训练好的模型结果组合起来。我拿分类任务举个例子。

假设你已经训练了三分类器：逻辑回归、SVM、KNN。预测一个新样本时，得出了如下结果：

• 逻辑回归认为是类别 A
• SVM 认为是类别 A
• KNN 认为是类别 B

硬投票的规则是少数服从多数，最终答案就是 A。

如果你用的是软投票，逻辑回归会输出一个概率分布，比如 A 是 0.6，B 是 0.3；SVM 输出 A 是 0.7；KNN 输出 B 是 0.8。最终把所有概率加总后取平均，再看哪个类别的平均概率最高。软投票在多数情况下比硬投票更稳，因为它保留了置信度信息，而不是把每个模型降级成一个“一票”符号。

下面是一段最简版 Python 代码，用 sklearn 里的 VotingClassifier 实现软投票。

python复制from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

model1 = LogisticRegression()
model2 = SVC(probability=True, random_state=42)
model3 = DecisionTreeClassifier(max_depth=5, random_state=42)

voting = VotingClassifier(
    estimators=[("lr", model1), ("svm", model2), ("dt", model3)],
    voting="soft"
)

这里有一个很重要的细节：如果你打算用软投票，所有参与投票的模型必须都能输出概率。SVC 默认并不输出概率，需要显式设置 probability=True，这会额外引入交叉验证计算，让训练时间变长。

Voting 虽然思路简单，但它能不能起到正面作用，取决于基模型的差异性。如果三个模型高度相似，比如深度和结构差不多的三棵决策树，它们的错误模式近乎一致，投票后提升幅度会很小。反过来说，逻辑回归擅长线性边界，决策树擅长非线性切分，KNN 擅长局部结构，三者预测的互补性更强，投票才有意义。这条“多样性带来增益”的规律，在整个集成学习里都成立。

2. Bagging 与随机森林：并行训练，集体投票为什么这么稳

2.1 Bagging 的采样逻辑：为什么一定要“有放回”地抽

Voting 是对同一批模型输出做整合，Bagging 则更进一步，它对训练数据和模型生成方式都做了改造。Bagging 全称是 Bootstrap Aggregating，中文常翻译为自助采样集成。核心操作也直白：从原始训练集里有放回地随机抽取若干个子集，每个子集训练一个基模型，最后把基模型的结果做平均或投票。

我经常碰到小白问：为什么采样一定要有放回？直接不放回地切几份不行吗？这个问题问到点子上了。如果不放回，每个子集都是原始数据集的一个固定划分，子集和子集之间没有重叠，模型之间的相关性会低一些，但每个子集的数据量都被迫变小。在原始数据本身不多的情况下，这样做会浪费大量信息。

有放回采样则不同，原始数据里大约 63.2% 的样本会在某个子集里至少出现一次，其余约 36.8% 的样本在该子集中完全没出现过，这部分样本被称作袋外样本（Out-of-Bag，OOB）。由于每次抽样的结果都不同，每个基模型面对的数据分布略有变化，但它们使用的数据结构又是完整的，不会像不放回切分那样明显损失数据量。

对高方差模型，比如深度较大的决策树，Bagging 的效果非常显著。树模型天生容易记住训练集噪声，不同子集上训练出的树，在预测时误差方向并不完全一致；平均之后，方向不同的误差会相互抵消，方差下降，整体泛化能力上升。而偏差基本保持不变，因为每棵树的表达能力并没有被削弱太多。

2.2 随机森林的“双重随机”：它不是简单 Bagging 一棵决策树

Bagging 的想法很简单：把一批高方差决策树平均。可实践后大家发现，直接用 Bagging 生成一批决策树，如果数据集中某个特征特别强，绝大部分树分裂时都会优先用这个特征，树的结构会很相似，相关性高，平均降方差的收益就大打折扣。

随机森林作为 Bagging 的改进版，做的关键改动是在树节点分裂时引入特征随机。原始决策树分裂时会在所有特征里挑最优切分点；随机森林在每次分裂时，先从全部特征里随机抽出一个小特征子集，比如分类任务默认取特征总数的平方根，然后只在这个子集里找最优切分点。这就是“双重随机”：样本随机 + 特征随机。

这个改动看起来轻描淡写，实际效果却很大。它强迫每一棵树去注意不同维度的信号，有的树偏向特征 A，有的树偏向特征 B、C，树和树之间的相关性显著降低。随机森林的作者 Breiman 有一个很直观的结论：随机森林的泛化误差上界，和树之间的相关性以及单棵树强度有关。相关性越低、单棵树表现越强，整体效果就越好。因此，调随机森林很多时候不是在调深度，而是在调特征采样策略，让树之间不要太像。

2.3 用 sklearn 搭一个随机森林，几个关键参数一次说清

实操时我最常推荐的入门数据集是乳腺癌分类数据集。它的维度适中，随机森林能很快跑到还不错的分数。下面这端代码可以直接在 Jupyter Notebook 里跑。

python复制from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

rf = RandomForestClassifier(
    n_estimators=200,
    max_features="sqrt",
    min_samples_leaf=3,
    oob_score=True,
    n_jobs=-1,
    random_state=42
)
rf.fit(X_train, y_train)

print("OOB score:", rf.oob_score_)
print("Train acc:", rf.score(X_train, y_train))
print("Test acc:", rf.score(X_test, y_test))

我给新手讲参数时，会让他们优先关注四个：

• n_estimators：树的数量。这个值不是越大越好，通常到 200~500 后边际收益就很小了，训练时间却线性增长。想象一下，一个人数太多的评审团，如果大多数人水平相近，再多找几个成员也改变不了结论。
• max_features：每次分裂时随机抽出的特征数。这个参数对随机森林的最终效果影响非常大。它控制了树之间的差异性，也是“随机”二字的来源。分类默认是 sqrt，回归默认是 None（等于全部特征），实际项目里建议用网格搜索小范围试。
• min_samples_leaf：叶子节点最少样本数。设大一点能防止单棵树无限生长导致过拟合。常见取 3、5、7。
• oob_score：是否计算袋外分数。这个功能等于白送一个验证集评估。每棵树都有没见过的样本，把所有树的袋外预测汇总起来就能估算模型泛化能力，不需要额外切验证集。

还要着重提醒：所有用到随机过程的模型，训练时一定要固定 random_state，否则每次跑出来的结果都不同，你以为在调参，其实只是被随机数波动骗了。

3. Boosting 和 Adaboost：串行纠错，把注意力留给分错的样本

3.1 Boosting 的核心机制：前一个模型没学会的，下一个接着学

Bagging 的思路是并行训练，Boosting 恰恰相反，它采取串行方式。每训练一个新的模型，都在主动关注前一个模型犯错的地方。你可以想象成学生复习错题本：第一轮看整体知识点，做错的题目标红；第二轮重点刷红题，刷完又发现一批新问题；第三轮继续针对这批新问题用力。几轮下来，原本很难的样本被一轮轮攻克，整体正确率自然就上去了。

从误差分解角度看，Boosting 更擅长降低偏差。它通常从一个很弱的基学习器出发，比如深度只有 1 的决策树桩。每个弱学习器单独拿出来都不堪大用，但经过多轮加权组合，整体模型可以被训练到很低的偏差。正因为如此，Boosting 可以容忍“弱”模型的存在，这是它和 Bagging 用强树模型来降低方差的最大差异。

具体到 Adaboost，它的全称是 Adaptive Boosting，适应性提升算法。它的运作逻辑可以压缩成三个循环往复的步骤。第一步，初始化所有训练样本的权重为 1/n，其中 n 是样本数量。第二步，在带权重的训练集上训练一个弱分类器，计算其加权错误率。第三步，根据错误率调整模型的可信度，并更新样本权重，错误的样本权重变大，正确的样本权重变小，然后进入下一轮。

3.2 手工推一遍 Adaboost 的权重更新流程，印象会深得多

公式不能只看不练。我拿一个极简化例子说明。假设训练集有 5 个样本，初始权重都是 0.2。第一轮你训练了一个决策树桩，它把这 5 个样本里的 2 个分错了，那么本轮误差率为：

err = 0.2 + 0.2 = 0.4

接着计算该模型在最终投票中的可信度：

alpha = 0.5 * ln((1 - err) / err) = 0.5 * ln(0.6 / 0.4) = 0.5 * ln(1.5) ≈ 0.2027

注意，错误率越接近 0.5，这个模型的可信度越接近 0，说明它和随机乱猜差不多，不值得信任；错误率越低，alpha 越大，最终决策时的话语权越高。

接下来更新权重。正确的样本权重乘以 exp(-alpha)，错误的样本权重乘以 exp(alpha)。代入上面的值，正确样本权重约为 0.2 * e^(-0.2027) ≈ 0.163；错误样本权重约为 0.2 * e^(0.2027) ≈ 0.245。做完后把所有权重加起来，再归一化，得到下一轮的新权重。可以看到错误样本的权重被抬高了，下一轮的弱分类器如果不重点照顾这些样本，加权错误率就会很难看，于是模型被“逼”着去解决上一轮的难点。

最终预测时，Adaboost 不做简单投票，而是把每一轮分类器的输出按 alpha 加权求和，取符号作为最终类别。这也意味着，可信度高的模型对最终结果影响更大。

3.3 从 Adaboost 到 GBDT：Boosting 家族后来的路

理解了 Adaboost 之后，再往后看 Boosting 家族就容易多了。Adaboost 是通过调整样本权重来让下一个模型关注难样本，而后续的 GBDT（Gradient Boosting Decision Tree）换了一种更通用的思路：每一轮都在拟合前一个模型的负梯度。在平方损失函数下，负梯度就是残差，比如一个房子的真实价格是 100 万，前一个模型预测了 80 万，残差就是 20 万，下一棵树就去学习这 20 万的规律。实际应用里，我们常常用对数损失、指数损失等更复杂的损失函数，此时负梯度就不等于普通残差了，但思想是共通的：串行地学习“之前没学好的部分”。

在 sklearn 里使用 Adaboost 写起来很简单：

python复制from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier

ada = AdaBoostClassifier(
    estimator=DecisionTreeClassifier(max_depth=1),
    n_estimators=100,
    learning_rate=1.0,
    random_state=42
)
ada.fit(X_train, y_train)

有一点我必须强调：Adaboost 对噪声样本极度敏感。因为它的机制是不断放大错误样本的权重，如果某个样本本身就是标注错误，或者属于天然难以分类的离群点，Adaboost 会在后面的迭代里投入大量精力去死磕这个错标样本，反而把正常样本忽略掉。我在实际调研里见过类似情况：做影响学生压力的因素分析时，问卷数据只要存在少量随意填写的异常样本，直接上 Boosting 类模型后分数反而下降。先清洗样本，再用 Boosting，才能发挥出它降偏差的优势。

4. Stacking：把多个模型的预测结果当成新特征，再学一次

4.1 Stacking 为什么往往能刷出更高分

Voting 是让几个模型平权投票，Bagging 和 Boosting 在数据或训练方式上做文章，而 Stacking 英文全称 Stacked Generalization，中文叫堆叠泛化。它的思路是用两层模型结构。第一层训练多个不同的基模型，第二层不再对这些模型的输出做简单平均，而是把它们的预测结果当作新特征，再训练一个“元模型”去学习“如何综合这些预测”。

我以前用过一个很形象的比喻：Voting 是公司开会，每个部门经理提一个方案，然后大家举手表决，一人一票；Stacking 则是先让每个部门经理发言，之后由总裁综合这些发言做最终决策。总裁掌握的信息不只是“谁赞成谁反对”，还包括哪位经理在什么情况下更有发言权。所以 Stacking 能做的不只是消除错误，还能学出不同基模型在不同样本子空间上的相对优势。

4.2 K 折交叉预测：防止 Stacking 数据泄漏的关键一步

很多新手写 Stacking 时会犯一个非常严重的错误：直接用第一层的模型在整个训练集上训练，然后再对同一个训练集做预测，把预测结果丢给第二层模型。这么做会导致灾难性的数据泄漏。基模型已经“见过”这些训练样本了，第一层的预测表现会好得离谱，第二层学到的是一套对训练集很像的映射，但面对新数据时立刻失效。线上的公开比赛里，这种处理经常让 A 榜分数奇高，到 B 榜或者线下新测试集上就崩塌。

正确的标准做法是使用 K 折交叉预测，也叫 Out-of-Fold 预测。我以 5 折为例描述一遍完整流程。

第一层有一个基模型，比如逻辑回归。先把训练数据切成 5 份。第一次取前 4 份作为训练子集，训练一个逻辑回归；对这个模型来说，第 5 份它没见过，可以用它来预测第 5 份样本，得到第 5 份样本的第一层特征。同时，也要用这个训练好的模型去预测真正的测试集，但暂时保存下来，不要直接用。第二次，把第 4 份作为验证，其余四份训练，继续得到第 4 份样本的预测，同时也得到对测试集的预测。循环 5 次之后，训练集每一份样本都会有一个来自“没见过它的模型”的预测值，把这些预测值纵向拼接起来，就是完整的第一层训练特征。而测试集在第一轮中得到了 5 个预测结果，把这 5 个预测结果取平均，作为测试集的第一层特征。这样处理之后，第二层模型拿到的训练特征全部是“中立”的，没有混入第一层模型见过样本后的记忆，数据泄漏就被挡住了。

sklearn 里提供了 StackingClassifier 封装，底层其实已经帮你处理好了交叉预测逻辑，直接调用很方便。

python复制from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier

estimators = [
    ("rf", RandomForestClassifier(n_estimators=100, random_state=42)),
    ("gbdt", GradientBoostingClassifier(n_estimators=100, random_state=42))
]

stack = StackingClassifier(
    estimators=estimators,
    final_estimator=LogisticRegression(),
    cv=5
)
stack.fit(X_train, y_train)

但如果你用的是自己写的自定义模型，或者想理解背后的细节，手动实现 K 折预测仍然是一次非常有价值的练习。知道封装的底层在做什么，才不会被黑盒骗。

4.3 Stacking 的适用边界：不是所有数据都适合堆模型

我见过很多人听说 Stacking 在 Kaggle 上能提分，转头就在自己的小数据集上无脑套用。实际效果往往是：分数没有明显提升，训练时间翻了好几倍。Stacking 要吃到红利，通常需要满足几个条件。

第一，数据量要足够。第一层每个模型都得做交叉验证，样本太少的时候，K 折里每一折的验证集都太单薄，第一层特征本身就不稳定，第二层再学习这种不稳定特征，只会放大波动。第二，第一层的基模型要尽可能不同类型。如果全是决策树变体，它们看到的数据结构几乎一样，输出的预测高度相关，第二层很难学到额外的整合信息。第三，你要有充足的时间和计算资源。Stacking 的训练成本是多个模型之和，还要乘上交叉验证的折数。

项目里如果只是小数据集、给一个解释性要求高的模型，我通常不会优先用 Stacking，而是直接用逻辑回归或单棵剪枝决策树，模型又稳又容易解释，不会为了零点几个点的分数把复杂度拉上天。

5. 六种集成方法怎么选：用一张对比表和一套决策习惯来落地

5.1 一张表理清 Voting、Bagging、Boosting、Stacking 的核心差异

集成学习方法选型不能靠背口诀，得清楚每种方法改变的是哪部分训练过程。我整理过一张对比表，基本涵盖了面试和项目里常用的考察角度。

还有一层对比常常被人忽略：训练效率。Bagging 和随机森林天生适合并行，所有树互不依赖，sklearn 里设置 n_jobs=-1 就能跑满 CPU 多核；Boosting 串行训练的天然属性，前一个模型不训练完，后一个无法开始，即使多核机器，提速空间也有限。Stacking 因为要做 K 折交叉预测，时间成本是所有方法里最高的。

5.2 我的选择习惯：先跑 baseline，再按数据形态决定加哪个

选型这件事看似复杂，但落到实操里，我一般按下面这个流程走。

拿到一份结构化表格数据，先别急着上高级算法。我会用逻辑回归和随机森林各跑一个 5 折交叉验证，作为 baseline。逻辑回归代表线性模型的稳健程度，随机森林代表非线性模型能拿到什么水平。如果两者差异不大，说明问题可能更偏线性，优先考虑特征工程，而不是继续堆复杂模型。

如果随机森林明显优于逻辑回归，说明特征间有复杂交互，我会继续试 GBDT 类模型。你用它对比一下随机森林在同样数据上的表现，如果 GBDT 明显更高，那说明模型的目标函数空间更适合逐步逼近。这一步做完后，再根据调参结果决定要不要加 Voting 或 Stacking。

最后要记住，集成方法不会凭空创造信息。几个模型都只见过同一批特征，如果特征本身已经无法区分样本，你堆 100 个模型也解决不了问题。我在做压力因素分析项目的调研时，发现原始问卷整理成特征后，影响最大的是学业负担类特征，如果这些特征丢失了，无论随机森林还是 GBM 模型，精度都只能徘徊在某个固定值附近。所以，集成的收益应该理解为“榨干数据里已有信号”，而不是代替数据收集和清洗。

6. 集成学习实操里的坑：数据泄漏、样本不均衡和过度堆叠

6.1 数据泄漏：最隐蔽也最致命的问题

前面讲 Stacking 时提到的交叉预测泄漏，其实是整个机器学习数据泄漏问题的一个缩影。新手最容易犯的另一类错误是在切分训练集和测试集之前，就执行了标准化或归一化。假设你调用 StandardScaler 对全量数据做了拟合，再去切训练集和测试集，缩放器已经把测试集的均值和标准差记在了自己的参数里，这等于训练阶段偷偷看了测试集的分布信息。换到随机森林这类树模型上，这类影响往往不大，但换到逻辑回归、SVM 或者 Stacking 里的 LR 元模型上，分数虚高程度会很明显。

解决方案是，把数据切分放在任何预处理前面，或者用 sklearn 的 Pipeline 把预处理器和模型打包成一个整体，让 Pipeline 在每一折交叉验证内部自动执行预处理。这能帮你挡住一大半数据泄漏问题。

6.2 类别不均衡下，Accuracy 是骗人的

做分类项目，尤其是像“预测学生压力水平”这种正负样本可能严重失衡的场景，只看准确率会误导你。如果 95% 的样本是“无压力”，5% 是“有压力”，一个永远预测“无压力”的模型也能拿到 95% 的准确率，但它没有任何实用价值。集成模型里，随机森林支持 class_weight='balanced'，Adaboost 可以在样本采样时就做加权处理，但更重要的是把评价指标换成 AUC、F1、LogLoss 这类对少数类敏感的指标。

顺便提醒一个细节：很多分类模型面对不平衡数据时，默认阈值 0.5 并不是最优的。集成模型输出的概率，可以单独算 ROC 曲线来选一个假正率和真正率最平衡的阈值，再决定把概率大于多少判定为正类。这块内容看起来是部署环节，但直接影响了最终收益。

6.3 随机森林的 OOB 分数到底该怎么用

随机森林提供了一个非常方便的内置验证指标，oob_score_，它是对那些没有被当前树采样的样本做预测后统计出来的。很多初学者不知道这一点，会在代码里同时设置 oob_score=True，底下又硬生生再切出一个验证集，感觉多了一重保障。

实际上，OOB 分数和交叉验证并不完全等价，但确实非常接近。我会把它当作调参阶段的一个快速信号。例如想判断 n_estimators=100 还是 n_estimators=300 更合适，无需每次都跑一遍交叉验证，只需看不同树量下 OOB 分数变化趋势，确认是否已经进入平台期。但最终决定模型是否上线，我还是会留出一份独立测试集，或者跑正式的 K 折交叉验证做最后确认。

6.4 集成不是模型大乱炖，堆得越多不一定越好

最后这个坑是我早期踩得最深的一个。当时以为把随机森林、GBDT、Adaboost、XGBoost、LightGBM 全部塞进 Stacking 里，自己就能成为竞赛大佬。结果训练时间从几分钟涨到几小时，线下交叉验证分数不见提升，测试集分数甚至微降。

后来分析了一下，原因是那些树类模型之间的相关性太高。它们对样本的错误判断模式几乎一致，第二层能学到的互补信息非常有限，反而是无脑叠计算开销。正确的做法是先看基模型预测结果之间的相关性矩阵。比如随机森林和 ExtraTrees 的预测相关性如果高达 0.98，二者只需要留一个；逻辑回归和 KNN 的预测相关性明显低很多，把逻辑回归加进融合里往往更有价值。集成提升的本质是多样性，不是数量。这一点，无论是 Voting、Stacking 还是随机森林内部的随机采样，都反复在验证同一件事。

说了这么多，集成学习的内容并不真的像名字那样吓人。它不要求你发明新算法，而是教你如何用一套合理的策略，让多个普通模型协作完成更难的预测任务。如果你自己正卡在“单模型分数上不去”的阶段，可以先从 Voting 做起，确认模型之间的差异性；再切到随机森林看 Bagging 的效果，按情况尝试 Adaboost 或 GBDT；最后，数据充足且有精力时，再谨慎地试 Stacking。每个步骤都记录下训练分数、测试分数和训练耗时，你会发现，真正让你提升的往往不是某一次花哨的调参，而是你逐步理解了模型误差从哪里来，又该用哪种方式去对冲。