Bagging：Bootstrap集成方法

可视化演示

动态演示Bagging的核心机制，通过开始/执行/监控/完成四种模式展示关键概念与交互流程。

集成学习思想

一位食客再资深，也有口味偏爱和心情起伏。十位“普通”食客分桌而坐、独立打分，反而更接近餐厅的真实水平——因为每个人的偏好和误判会在汇总时相互抵消。这就是集成学习的直觉：不追求打造一个完美模型，而是训练多个“基学习器”（base learner，相当于普通食客），把它们的预测组合起来。每个基学习器只要比瞎猜强一点——错误率低于 0.5——组合起来就可能比任何单一模型都好。

在机器学习里，这个思路叫“集成学习”（Ensemble Learning），Bagging 是其中最重要的成员。为什么“多票”能胜“独断”？做一个思想实验：假设每个基学习器独立判断，出错概率是 ε，只有当超过一半的学习器同时答错时，集成才会出错。用组合数可以算出，集成出错的概率随学习器数量 T 的增大而指数下降。这正是“三个臭皮匠，顶个诸葛亮”的数学版本。

$$\displaystyle P_{\text{ens}} = \sum_{k=\lceil T/2 \rceil}^{T} \binom{T}{k}\,\varepsilon^{k}\,(1-\varepsilon)^{T-k}$$

1. 错误率：每个基学习器独立地犯错，错误概率记为 ε，并假设 ε < 0.5（比抛硬币略强）。

$$\varepsilon = P\big(h_t(x) \neq f(x)\big)$$

2. 失败条件：T 票中出错的学习器达到一半以上（k ≥ ⌈T/2⌉），多数投票才会失败。

$$k \geq \left\lceil \frac{T}{2} \right\rceil$$

3. 恰好 k 个出错：k 个错误且 T−k 个正确同时发生，组合方式有 C(T,k) 种。

$$\binom{T}{k}\,\varepsilon^{k}\,(1-\varepsilon)^{T-k}$$

4. 失败区间累加：把 k 从半数到 T 全部加起来，就是集成的出错概率。

$$P_{\text{ens}} = \sum_{k=\lceil T/2 \rceil}^{T} \binom{T}{k}\,\varepsilon^{k}\,(1-\varepsilon)^{T-k}$$

就像 21 位食客投票，只要他们不是被同一份“美食攻略”洗脑（独立性），错误的口味很难形成多数。这也预告了 Bagging 的两大支柱：让每位“食客”口味有差异，再让投票定输赢。

Bootstrap采样

自助餐的取菜规则是：你端着盘子从几十道菜里挑，每挑一次，菜还在那里——同一道菜可以反复取。Bagging 的“自助”二字正来自这个动作：原始数据有 m 个样本，每次从中有放回地抽一个，抽 m 次，得到一份和原始数据一样大的新训练集。重复 T 次，就有了 T 份“菜盘”，喂给 T 个模型。

这个看似简单的抽样办法有一个绝妙结论：某个样本在 m 次抽取中一次都没有被抽中的概率，约等于 36.8%。也就是说，每份自助样本大约覆盖原始数据的 63.2%，其余位置是重复出现的样本。没被抽中的那 36.8%，被称为“袋外数据”（Out-of-Bag，简称 OOB）——它免费为模型提供了一份验证集。

$$\displaystyle \left(1 - \frac{1}{m}\right)^{m} \approx e^{-1} \approx 0.368$$

1. 单次落选概率：在 m 个样本里抽一次，某个特定样本没被抽中的概率。

$$1 - \frac{1}{m}$$

2. 连续 m 次落选：有放回地抽 m 次，每次都轮不上它。

$$\left(1 - \frac{1}{m}\right)^{m}$$

3. 极限逼近：当 m 足够大，此式趋近自然常数 e 的倒数。

$$\lim_{m \to \infty}\left(1 - \frac{1}{m}\right)^{m} = e^{-1} \approx 0.368$$

4. 反面即覆盖率：被抽中的概率约 63.2%，也就是自助样本的“新鲜样本覆盖率”。

$$1 - e^{-1} \approx 0.632$$

食客没尝过的那 36.8% 的菜，并不是浪费——它正好用来检验这位食客的味觉是否可靠。这就是后面要讲的 OOB 验证：谁没吃过这道菜，谁就有资格给这道菜“挑刺”。

并行化训练

食客们要分桌而坐、互不通气：如果允许互相参考，先点的会带动后点的，十个人的评分就会高度雷同，投票就失去了意义。Bagging 在算法上做到了真正的“隔离”——T 份自助样本彼此独立，T 个模型各自训练、互不通信。因此它天然支持并行计算：把 T 个训练任务丢到多核 CPU 或多台机器上同时跑，训练总时长接近训练单个模型的时间。

这种并行背后有一组值得咀嚼的性质：每份训练集都是从同一个数据分布中抽样得到的，所以模型的“底子”相似（同分布）；但抽到的样本又各不相同，所以模型“各有特色”（有差异）。这种“和而不同”正是平均化能够奏效的前提。假如 T 个模型完全独立、每个的预测方差都是 σ²，那么把它们取平均后，方差会缩小到原来的 1/T。

$$\displaystyle \operatorname{Var}\!\left(\frac{1}{T}\sum_{t=1}^{T}\hat{f}_t(x)\right) = \frac{\sigma^2}{T}$$

1. 单个模型方差：每个基学习器预测值围绕其期望的波动幅度记为 σ²。

$$\operatorname{Var}\big(\hat{f}_t(x)\big) = \sigma^2$$

2. 常数的平方：对平均操作求方差时，常数 1/T 提出后要平方。

$$\operatorname{Var}\!\left(\frac{1}{T}\sum_{t=1}^{T}\hat{f}_t(x)\right) = \frac{1}{T^2}\operatorname{Var}\!\left(\sum_{t=1}^{T}\hat{f}_t(x)\right)$$

3. 独立则相加：模型互不相关时协方差为 0，方差直接累加。

$$\operatorname{Var}\!\left(\sum_{t=1}^{T}\hat{f}_t(x)\right) = \sum_{t=1}^{T}\operatorname{Var}\big(\hat{f}_t(x)\big) = T\sigma^2$$

4. 代入得结论：平均之后方差变为原来的 1/T。

$$\frac{T\sigma^2}{T^2} = \frac{\sigma^2}{T}$$

十个食客都生活在同一座城市（同分布），口味会有共性；但各自私藏的小馆子不同（样本差异），合起来反而比单打独斗稳定得多。并行训练则保证了这种“多样性”不被互相干扰。

多数投票

每位食客最后要表态：推荐，还是不推荐？一张票而已。更细心的评审团会让每人打 1~5 星，最后求平均分——分数比“是/否”保留了更多信息。Bagging 也是这样：分类问题用“多数投票”，数一数哪个类别得到的票最多；回归问题用“取平均”，把 T 个模型的数值预测加起来除以 T。

硬投票只管最终类别，软投票则更进一步：让每个模型先输出各类别的概率，再对所有模型的概率取平均。这样，那些“犹豫不决”的模型也能把不确定性表达出来，通常能带来微小但稳定的提升。实践中，Bagging 最常搭配决策树这种天然能输出概率或类别的模型。

$$\displaystyle H(x) = \arg\max_{y \in \mathcal{Y}}\ \sum_{t=1}^{T}\mathbb{1}\big(h_t(x) = y\big)$$

1. 指示函数即一张票：第 t 个模型输出类别 y 时记 1，否则记 0。

$$\mathbb{1}\big(h_t(x)=y\big) = \begin{cases}1, & h_t(x)=y \\[2pt] 0, & h_t(x)\neq y\end{cases}$$

2. 逐类计票：把 T 个模型的投票按类别累加，得到每个类别的总票数。

$$\text{vote}(y) = \sum_{t=1}^{T}\mathbb{1}\big(h_t(x)=y\big)$$

3. 取票数最多者：argmax 返回得票最多的类别作为最终输出。

$$H(x) = \arg\max_{y \in \mathcal{Y}}\ \text{vote}(y)$$

就像大众点评上“推荐”与“不推荐”的百分比是硬投票，星级均分是软投票——后台其实都是这么聚合众人口味的。投票规则虽朴素，却是 Bagging 把“群意”变成“决断”的最后一公里。

偏差与方差

食客对同一道菜的评价为何不一致？一种原因是某位食客天生偏甜或偏咸，这是“偏差”（bias）；另一种原因是今天饿与不饿造成的状态波动，这是“方差”（variance）。一个靠谱的评审团，既要压低系统性偏差，也要压住随机波动。机器学习中的偏差-方差分解把模型误差拆成三部分：不可消除的噪声、偏差的平方、方差。

偏差衡量模型对真实规律的系统性偏离——比如用直线去硬拟合一条曲线；方差衡量模型对不同训练集的敏感程度——比如一棵深度决策树，换一批数据决策边界就剧烈变化。Bagging 的奇妙之处在于：它不改变单个模型的偏差（平均的仍然是同一类模型），却能把方差压到原来的约 1/T。因此它对“低偏差、高方差”的模型（典型如深决策树）提升立竿见影，对“高偏差”模型（如欠拟合的线性模型）几乎帮不上忙。

$$\displaystyle \mathbb{E}\big[(y - \hat{f}(x))^2\big] = \sigma^2 + \text{Bias}^2\big(\hat{f}(x)\big) + \text{Var}\big(\hat{f}(x)\big)$$

1. 噪声项：数据生成过程中的固有随机波动，任何模型都无法消除。

$$\sigma^2 = \mathbb{E}\big[(y - f(x))^2\big]$$

2. 偏差平方：模型在众多训练集上的平均预测与真实规律的偏离程度。

$$\text{Bias}^2 = \big(f(x) - \mathbb{E}[\hat{f}(x)]\big)^2$$

3. 方差项：模型预测围绕其期望的波动幅度，正是 Bagging 着力压制的对象。

$$\text{Var} = \mathbb{E}\Big[\big(\hat{f}(x) - \mathbb{E}[\hat{f}(x)]\big)^2\Big]$$

如果食客们全都“只会说好吃”（系统性偏差），投票再多也还是两个字；但如果只是“时好时坏”（方差），一桌人平均下来就是稳定发挥。偏差与方差的这场博弈，决定了 Bagging 什么时候是神药、什么时候是安慰剂。

Bagging对比Boosting

两种团建方式：一种是“自助评审团”——大家各吃各的，最后投票；另一种是“闯关训练营”——第二个人专挑第一个人评错的菜再评，后面的人依次踩在前人的肩膀上。前者是 Bagging，并行、等权、主降方差；后者是 Boosting，串行、加权、主降偏差。AdaBoost、GBDT、XGBoost 都属于 Boosting 家族。

从数学形式上看，两者都可以写成“基学习器加权求和后取符号”的加性模型。区别在于权重怎么来：Bagging 对每个模型一视同仁，权重恒为 1；Boosting 则给每个模型分配一个权重 α_t，准确率越高的模型权重越大，并且每次迭代都会加大对上一轮错分样本的关注。一个靠“自助”制造差异，一个靠“纠错”步步紧逼。

$$\displaystyle H_{\text{Bagging}}(x) = \operatorname{sign}\!\left(\sum_{t=1}^{T} h_t(x)\right), \qquad H_{\text{Boosting}}(x) = \operatorname{sign}\!\left(\sum_{t=1}^{T} \alpha_t\, h_t(x)\right)$$

1. 统一视角：两者都是“基学习器加权求和后取符号”的加性模型。

$$H(x) = \operatorname{sign}\!\left(\sum_{t=1}^{T} w_t\, h_t(x)\right)$$

2. Bagging 的等权：所有模型权重相同 w_t = 1，纯靠票数说话。

$$w_t = 1,\quad t = 1, 2, \dots, T$$

3. Boosting 的加权：权重 α_t 由该模型的加权错误率 ε_t 决定，错得越少权重越大。

$$\alpha_t = \frac{1}{2}\ln\frac{1-\varepsilon_t}{\varepsilon_t}$$

4. 一句话差异：Bagging 求“稳”，Boosting 求“准”——分别对应方差与偏差。

$$\varepsilon_t \uparrow \;\Rightarrow\; \alpha_t \downarrow$$

想要多家医院独立会诊得结论，选 Bagging；想让徒弟快速出师、专攻师父的错题，选 Boosting。两者没有绝对的优劣，只有是否匹配你的误差来源。

随机森林扩展

食客团有个隐患：如果大家私下都刷了同一份美食排行榜，口味会严重“撞车”——投票就退化成一个人投了十票。怎么办？没收攻略，每人只发菜单的一页：有人只看前菜，有人只看主菜，有人只看甜点。随机森林正是这个思路的系统化：在 Bagging 基础上加入“特征随机选择”。

随机森林（Random Forest）= Bagging + CART 决策树 + 特征随机选择。每棵树在分裂时，不是从所有 d 个特征里挑最优，而是先从特征全集里随机抽 k 个（常用 k = log₂(d) 或 √d），再在这 k 个里选最优。这强制让不同树的“关注点”错开，树与树之间的相关性大幅降低，方差压缩效果比朴素 Bagging 更好。它还附带两个赠品：OOB 误差免费做验证，以及基于 Gini 不纯度下降量计算的特征重要性。

$$\displaystyle \text{Gini}(D) = 1 - \sum_{k=1}^{K} p_k^2$$

1. 类别占比：数据集 D 中第 k 类样本所占比例记为 p_k。

$$p_k = \frac{|D_k|}{|D|}$$

2. 占比平方和：平方和越大，说明样本越集中在少数类别，节点越“纯”。

$$\sum_{k=1}^{K} p_k^2$$

3. 补成不纯度：1 减去平方和得到 Gini 不纯度，值越小越好；CART 分裂时选择使 Gini 下降最多的特征。

$$\text{Gini}(D) = 1 - \sum_{k=1}^{K} p_k^2$$

“没收美食榜、随机发菜单”，让每位食客的偏见不再同步，投票质量反而更高。随机森林也因此被许多人视为 Bagging 家族最成熟、最实用的成员。

流程与实战

把整套食客评审写成标准手册：筹备组（确定模型数量 T）→ 发菜单（自助采样）→ 隔离试吃（并行训练）→ 收评分（汇总预测）→ 复盘（OOB 检验）。Bagging 的算法流程同样清晰：对 t = 1 到 T，先从原始数据有放回地抽 m 次得到自助训练集，再在每份训练集上独立训练一个基学习器；预测时，分类用多数投票、回归用平均。

实战中最重要的参数是 T（基学习器数量）和基学习器的容量。T 越大结果越稳，但边际收益递减，一般 100~500 足够；基学习器建议选“高方差”模型（如不剪枝的深决策树），否则 Bagging 收益有限。另一个高频技巧是用 OOB 误差代替交叉验证——它几乎零成本，却与测试误差高度相关。

$$\displaystyle \varepsilon_{\text{OOB}} = \frac{1}{m}\sum_{i=1}^{m}\mathbb{1}\big(H_{\text{OOB}}(x_i) \neq y_i\big)$$

1. 袋外成员集合：对样本 i，收集所有未把它纳入训练集的基学习器，记为集合 T(i)。

$$\mathcal{T}(i) = \{ t \mid i \notin D_t \}$$

2. 袋外投票：只用这些“没见过 i”的学习器对 i 做多数投票，得到 OOB 预测。

$$H_{\text{OOB}}(x_i) = \arg\max_{y}\; \sum_{t \in \mathcal{T}(i)} \mathbb{1}\big(h_t(x_i) = y\big)$$

3. 平均错误率：对所有样本的错误指示取平均，得到泛化误差的估计值。

$$\varepsilon_{\text{OOB}} = \frac{1}{m}\sum_{i=1}^{m}\mathbb{1}\big(H_{\text{OOB}}(x_i) \neq y_i\big)$$

手册写完了，餐厅也要开业了。Bagging 就是那种“平凡但可靠”的招数：没有花哨的聪明，却能在风控、推荐、医疗等场景里稳稳坐镇 C 位。

AI 应用场景

Python 演示

"""从零实现 Bagging：Bootstrap 有放回采样 + 决策树桩 + 多数投票"""import numpy as np  class Stump:    """决策树桩：在某个特征上寻找最优阈值做二分，作为弱学习器"""     def __init__(self):        self.feat = 0        self.thr = 0.0        self.left = 0        self.right = 1     def fit(self, X, y):        best_err = 1.0        for f in range(X.shape[1]):            vals = np.unique(X[:, f])            if vals.size < 2:                continue            for t in (vals[:-1] + vals[1:]) / 2:                mask = X[:, f] <= t                for l in (0, 1):                    err = (np.sum(y[mask] != l) + np.sum(y[~mask] != 1 - l)) / len(y)                    if err < best_err:                        best_err = err                        self.feat, self.thr = f, t                        self.left, self.right = l, 1 - l     def predict(self, X):        return np.where(X[:, self.feat] <= self.thr, self.left, self.right)  class Bagging:    """Bagging 集成：对每个基学习器做 bootstrap 采样，独立训练，最后投票"""     def __init__(self, n_estimators=50):        self.n_estimators = n_estimators        self.models = []     def fit(self, X, y):        n = len(X)        for _ in range(self.n_estimators):            idx = np.random.choice(n, n, replace=True)   # 有放回采样            weak = Stump()            weak.fit(X[idx], y[idx])            self.models.append(weak)     def predict(self, X):        votes = np.zeros((len(X), 2))        for m in self.models:            votes[np.arange(len(X)), m.predict(X)] += 1        return votes.argmax(axis=1)  if __name__ == "__main__":    rng = np.random.RandomState(42)    X0 = rng.randn(300, 2) + np.array([-2.0, 0.0])    X1 = rng.randn(300, 2) + np.array([2.0, 0.0])    X = np.vstack([X0, X1])    y = np.array([0] * 300 + [1] * 300)     order = rng.permutation(len(X))    X, y = X[order], y[order]     X_train, y_train = X[:480], y[:480]    X_test, y_test = X[480:], y[480:]     single = Stump()    single.fit(X_train, y_train)    acc1 = np.mean(single.predict(X_test) == y_test)     bag = Bagging(n_estimators=50)    bag.fit(X_train, y_train)    acc2 = np.mean(bag.predict(X_test) == y_test)     print("单棵决策树桩准确率: %.3f" % acc1)    print("Bagging 集成准确率: %.3f" % acc2)

1. idx = np.random.choice(n, n, replace=True)核心的“有放回抽样”，产出与原始数据等大的自助样本，正是自助餐式取菜
2. weak.fit(X[idx], y[idx])每个弱学习器只在各自的自助样本上训练，互不通信，对应“分桌试吃”
3. self.models.append(weak)T 个模型各练各的，最后统一汇总，体现并行化的思想
4. votes[np.arange(len(X)), m.predict(X)] += 1对每个测试样本按模型预测的类别累加票数，实现多数投票
5. votes.argmax(axis=1)返回票数最多的类别，就是 Bagging 的最终判决

常见误区

面试题