Bagging

小象实战讲义 · 机器学习算法精讲

在上一节中，我们学习了决策树 CART 算法。本节课，我们将探讨如何将多个“弱”的决策树（或其它模型）组合起来，形成一个更强大的“强”模型。这种“集成学习”的思想是提升模型性能、降低过拟合风险的关键技术。本节将重点介绍集成学习的第一种经典范式：Bagging，并理解其核心——自助采样法（Bootstrap）与投票/平均机制。

💡 核心导读

• 集成学习哲学：理解“三个臭皮匠，顶个诸葛亮”的算法实现思路，即如何通过组合多个弱模型来提升整体性能。
• Bootstrap 自助采样：掌握“有放回随机采样”这一统计学方法，它是 Bagging 生成多样性训练集的基础。
• Bagging 算法流程：学习从自助采样、训练多个基学习器，到最终通过投票（分类）或平均（回归）进行集成的完整步骤。
• 随机森林：认识 Bagging 思想在决策树上的直接应用——随机森林，并理解其“随机”的双重含义。
• 方差与偏差：从降低模型方差的角度，直观理解 Bagging 为何能有效抑制过拟合，提升模型稳定性。

集成学习：从弱到强的智慧

在机器学习中，我们常常发现，一个复杂的模型容易在训练数据上表现完美（过拟合），但在新数据上表现不佳；而一个简单的模型（弱学习器）虽然偏差大，但方差小，更稳定。集成学习（Ensemble Learning）的核心思想就是：将多个相对简单、性能一般的“弱学习器”组合起来，通过某种策略形成一个性能更优、更稳健的“强学习器”。

这就像古语所说的“三个臭皮匠，顶个诸葛亮”。每个弱学习器（臭皮匠）可能只对数据的一部分模式敏感，或者容易受到噪声的影响。但当我们汇集许多弱学习器的意见时，正确的模式会被强化，而随机的噪声则可能被抵消，从而得到更接近“诸葛亮”般智慧的决策。

本节课要讲的 Bagging，以及下节课的 Boosting，是两种最主流的集成学习框架。

Bagging：自助聚合

Bagging 是 Bootstrap AGGregating 的简写。讲师特别提醒别望文生义：它不是一个”袋子”（bag），而是”自助采样 + 聚合”两个词的缩写。

Bootstrap 自助采样

Bootstrap 是一种统计学上的重采样技术。它的操作非常简单：从原始训练集中有放回地随机抽取样本，以构成一个新的训练集。讲师的语境是：拿到一份大数据后，通常 70% 划作训练集、30% 留作测试集（测试数据不能碰，一直放在那儿），而 Bootstrap 就作用在训练集上。

过程像从罐子里抓小球：随机摸一个小球放进新篮子，再把球放回去，接着随机摸下一个……如此往复。每一次 Bootstrap 得到的数据集，都是原始数据的一个”反映与写照”——大部分真实分布被保留，但细节因重复与缺失而各不相同。假设我们有一个包含 $n$ 个样本的原始训练集 $D$，一次采样的完整流程是：

1. 随机从 $D$ 中抽取一个样本。
2. 记录该样本后，将其放回 $D$ 中。
3. 重复步骤1和2 $n$ 次（即采样次数与原始集大小相同），得到一个新的数据集 $D_1$。

由于是有放回采样，$D_1$ 中有些样本可能被多次抽到，而有些原始样本可能一次都没被抽中。理论上，当 $n$ 较大时，一次 Bootstrap 采样中，大约有 $1 - (1 - \frac{1}{n})^n \approx 1 - e^{-1} \approx 63.2\%$ 的原始样本会被至少抽中一次。这意味着每个新训练集都保留了大部分原始信息，但又通过样本的重复和缺失引入了多样性。

下面我们用一个小例子来模拟 Bootstrap 采样：

import random

# 设定随机种子，保证结果可复现
random.seed(42)

# 原始小型数据集
original_data = ['A', 'B', 'C', 'D', 'E']
n = len(original_data)
print(f"原始数据: {original_data}")

# 进行一次Bootstrap采样（有放回采样n次）
bootstrap_sample_indices = [random.randint(0, n-1) for _ in range(n)]
bootstrap_sample = [original_data[i] for i in bootstrap_sample_indices]

print(f"采样索引: {bootstrap_sample_indices}")
print(f"采样后数据: {bootstrap_sample}")

# 计算独特样本的比例
unique_samples = len(set(bootstrap_sample))
unique_ratio = unique_samples / n * 100
print(f"独特样本比例: {unique_ratio:.1f}% (理论值约63.2%)")

原始数据: ['A', 'B', 'C', 'D', 'E']
采样索引: [0, 0, 2, 1, 1]
采样后数据: ['A', 'A', 'C', 'B', 'B']
独特样本比例: 60.0% (理论值约63.2%)

可以看到，样本 ‘A’ 和 ‘B’ 被重复采样了，而 ‘D’ 和 ‘E’ 没有被采到。新数据集的大小仍是5，但内容已不同于原数据集。

Bagging 算法流程

Bagging 算法正是利用了 Bootstrap 采样来创造多样性：

1. 生成多样化的训练集：对原始训练集 $D$ 进行 $T$ 次独立的 Bootstrap 采样，得到 $T$ 个新的训练集 $D_1, D_2, ..., D_T$。
2. 并行训练基学习器：用这 $T$ 个训练集，分别独立地训练 $T$ 个相同的基学习器（例如决策树）。这些基学习器就是我们的“臭皮匠”。
3. 聚合预测结果：
   • 分类任务：对于一个新的输入样本 $x$，每个基学习器给出自己的类别预测。最终的预测结果是所有基学习器预测的众数（即投票最多的类别）。
   • 回归任务：对于一个新的输入样本 $x$，最终的预测结果是所有基学习器预测值的平均值。

这个过程可以形式化地表示为：

• 分类：$H(x) = \text{mode}\lbrace h_1(x), h_2(x), ..., h_T(x)\rbrace$
• 回归：$H(x) = \frac{1}{T} \sum_{t=1}^{T} h_t(x)$

其中，$h_t(x)$ 是第 $t$ 个基学习器的预测，$H(x)$ 是集成模型的最终预测。

投票的两种等价写法（讲师补充）：分类也常写成”求均值”的形式——若类别记为 0/1，把 $T$ 个预测加起来求均值，得到 0.3 就偏 0 类、0.8 就偏 1 类；更常见的是把类别记为 $-1/+1$，求和后看结果大于 0 还是小于 0——这个写法将贯穿下一节 Boosting 的加权投票。另有一点值得注意：Bagging 默认每个基学习器的权重完全均等——那如果让”学得好的分类器话语权更大”呢？这就引出了下一节的 Boosting。

Bagging 为何有效：降低方差

Bagging 提升模型性能的关键在于降低模型的方差。

回忆一下模型的泛化误差可以分解为偏差（Bias）、方差（Variance）和噪声（Noise）。方差衡量了模型对于训练数据微小变化的敏感度。一个复杂的模型（如深度很深的决策树）方差很高，容易过拟合。

Bagging 通过以下方式降低方差：

1. 数据多样性：每个基学习器在不同的 Bootstrap 样本集上训练。这些样本集共享主要的数据分布，但在细节（尤其是噪声点和边界点）上有所不同。这迫使每个基学习器学到略有不同的模式。
2. 平均效应：在聚合时，对于分类任务，一个偶然的错误预测（可能由某个噪声点导致）会被其他多数正确的预测所覆盖；对于回归任务，极端预测值会被平均掉。

一个直观的画面（讲师课上的画图讲解）：原始数据里有些点长得很”奇怪”——画了黄圈的那颗、缩在角落离群体很远的那几颗，它们很可能就是噪声。只用全部数据训练一个复杂模型时，分界面会被这些噪声点带得歪歪扭扭，一会儿鼓成”山包”、一会儿绕成”河流”。但 Bootstrap 采样的妙处在于：采 10 次、20 次，大多数采样根本碰不到那些孤零零的噪声点（每个子集里被重复采到的是主体数据）。于是在”干净”子集上训练出的边界往往简单得多——也许数据的本质就是一条简单的直线。多次采样、多个臭皮匠投票之后，噪声的影响被稀释，方差降下来了。

下面的代码模拟了 Bagging 在简单分类场景下的投票过程：

import random
import statistics

random.seed(42)

def weak_learner_predict():
    """模拟一个准确率不高的弱分类器对单个样本的预测。
       假设真实标签应为1，但弱分类器只有60%概率预测正确。"""
    # 模拟60%正确率
    return 1 if random.random() < 0.6 else 0

def bagging_predict(n_estimators):
    """模拟Bagging集成预测：聚合n_estimators个弱分类器的投票结果。"""
    predictions = [weak_learner_predict() for _ in range(n_estimators)]
    # 投票：多数票决
    return 1 if sum(predictions) > n_estimators / 2 else 0

# 模拟对同一个样本进行多次独立预测
n_trials = 10
print("模拟10次独立预测中，单一弱分类器与Bagging集成（5个分类器）的表现：")
single_preds = []
bagging_preds = []

for _ in range(n_trials):
    single_preds.append(weak_learner_predict())
    bagging_preds.append(bagging_predict(5))

print(f"单一弱分类器预测结果: {single_preds}")
print(f"Bagging(5个弱分类器)集成预测结果: {bagging_preds}")
print(f"单一预测中‘1’的比例: {sum(single_preds)/len(single_preds)*100:.1f}%")
print(f"Bagging预测中‘1’的比例: {sum(bagging_preds)/len(bagging_preds)*100:.1f}%")

模拟10次独立预测中，单一弱分类器与Bagging集成（5个分类器）的表现：
单一弱分类器预测结果: [0, 0, 1, 0, 0, 0, 0, 1, 0, 0]
Bagging(5个弱分类器)集成预测结果: [1, 1, 1, 1, 1, 1, 0, 1, 1, 1]
单一预测中‘1’的比例: 20.0%
Bagging预测中‘1’的比例: 90.0%

在这个模拟中，每个弱分类器只有60%的概率做出正确预测（输出1）。单独看，它在10次预测中只对了2次。但当我们用5个这样的弱分类器进行Bagging集成投票时，10次集成预测中有9次给出了正确的预测（1）。这生动地展示了“群体智慧”如何显著提升预测的稳定性与准确性。

随机森林：Bagging的明星代表

随机森林（Random Forest） 是 Bagging 思想与决策树结合的典型成功算法。讲师的一句话定义：用 Bagging 的方式生成很多很多 CART 树，这个算法就叫随机森林——森林（forest），本来就是很多树（many trees）。

标准实现中，随机森林通常还有第二重随机性，进一步拉大基学习器之间的差异、更好地降方差：

1. 样本随机（Bagging）：对训练样本进行 Bootstrap 采样。
2. 特征随机：在决策树每个节点分裂时，先随机选出一个特征子集（常见大小为 $\sqrt{d}$ 或 $\log_2(d)$，$d$ 为总特征数），只在这个子集里挑最优分裂特征。

这种双重随机让森林里每棵树从不同的数据子集、不同的特征视角学习，集成的效果通常比普通的 Bagging 决策树更好，过拟合也进一步受到抑制。

下面的代码展示了不同数量基学习器对 Bagging 集成结果的影响：

import random

random.seed(42)

def weak_learner_predict():
    """另一个模拟的弱分类器，正确率设为55%"""
    return 1 if random.random() < 0.55 else 0

def bagging_predict_vote(n_estimators):
    """Bagging投票集成"""
    votes = [weak_learner_predict() for _ in range(n_estimators)]
    return 1 if sum(votes) > n_estimators / 2 else 0

# 测试不同数量基学习器下的集成效果
test_cases = [3, 5, 7]
n_trials = 10

for n_est in test_cases:
    print(f"\n--- Bagging with {n_est} estimators ---")
    predictions = [bagging_predict_vote(n_est) for _ in range(n_trials)]
    print(f"集成预测结果: {predictions}")
    print(f"预测为‘1’的比例: {sum(predictions)/len(predictions)*100:.1f}%")

--- Bagging with 3 estimators ---
集成预测结果: [1, 0, 1, 1, 1, 1, 0, 1, 1, 0]
预测为‘1’的比例: 70.0%

--- Bagging with 5 estimators ---
集成预测结果: [0, 0, 1, 1, 1, 1, 0, 1, 0, 1]
预测为‘1’的比例: 60.0%

--- Bagging with 7 estimators ---
集成预测结果: [0, 1, 1, 1, 1, 0, 1, 1, 1, 1]
预测为‘1’的比例: 80.0%

可以看到，即使弱分类器本身正确率仅略高于50%（55%），通过集成多个分类器，集成预测的正确率（预测为 1 的比例）明显抬升（本例中 7 个学习器时达到 80%）。基学习器数量越多，正确的意见越容易在投票中占据多数，集成也越稳定——当然计算成本随之上升。

📝 动手练一练

1. 概念辨析：Bagging 算法中，每个基学习器是并行训练的还是串行训练的？这与我们下一节要讲的 Boosting 算法有何根本区别？这种区别导致了它们在降低模型偏差和方差上各有什么侧重？

2. 代码实践：在上面的 Bagging 投票模拟代码中，我们将弱分类器的正确率设置为 55%。请修改代码，将弱分类器的正确率设置为 45%（即比随机猜测还差），然后观察随着基学习器数量（如 3, 5, 7, 9, 11）的增加，集成模型的预测表现（预测为1的比例）有何变化？这个实验说明了 Bagging 对基学习器有什么基本要求？

import random

random.seed(42)

def weak_learner_predict_bad():
    """一个正确率只有45%的'坏'分类器"""
    return 1 if random.random() < 0.45 else 0

def bagging_predict_vote(n_estimators):
    votes = [weak_learner_predict_bad() for _ in range(n_estimators)]
    return 1 if sum(votes) > n_estimators / 2 else 0

# 试验次数加大到 2000，让统计趋势压过单次噪声
for n_est in [3, 5, 7, 9, 11]:
    predictions = [bagging_predict_vote(n_est) for _ in range(2000)]
    correct_rate = sum(predictions) / len(predictions)
    print(f"基学习器数 {n_est:2d}: 集成预测为1的比例 = {correct_rate:.1%}")

基学习器数  3: 集成预测为1的比例 = 40.8%
基学习器数  5: 集成预测为1的比例 = 40.2%
基学习器数  7: 集成预测为1的比例 = 40.1%
基学习器数  9: 集成预测为1的比例 = 38.8%
基学习器数 11: 集成预测为1的比例 = 34.6%

本章小结

本节我们深入探讨了集成学习的第一块基石——Bagging 算法。我们理解了如何通过 Bootstrap 自助采样技术，从原始数据中创造出多个既相似又不同的训练子集，并在此基础上并行训练一系列基学习器。最终，通过简单的投票（分类）或平均（回归）策略，将这些“臭皮匠”的智慧聚合起来，得到一个更强大、更稳定的“诸葛亮”模型。随机森林作为 Bagging 与决策树结合的典范，因其卓越的性能和良好的抗过拟合能力，已成为机器学习中最常用的算法之一。

📋 行动清单

• 在脑海中复述 Bagging 算法的两个核心步骤：Bootstrap 和 Aggregating。
• 理解为什么 Bootstrap 采样（有放回）能创造出多样化的训练集，并记住大约 63.2% 的独特样本率。
• 运行并理解本节中的模拟代码，体会从弱分类器到强集成器的变化过程，特别是基学习器数量与集成稳定性的关系。
• 思考：如果基学习器本身已经是强学习器（例如一个已经调优好的复杂神经网络），使用 Bagging 还会有显著效果吗？为什么？

—— 小象教研组