1.1 加法模型：Boosting家族的通用框架

Boosting类算法（包括AdaBoost和GBM）都可以统一描述为加法模型（Additive Model） ：最终模型由多个基函数的加权和组成。

数学上，加法模型的形式为：

其中：

• $b(x; \gamma_m)$ 是第 $m$ 个基函数（在GBM中就是决策树）
• $\gamma_m$ 是基函数的参数
• $\beta_m$ 是基函数的权重系数

在给定训练数据 $T = \{(x_1, y_1), (x_2, y_2), ..., (x_N, y_N)\}$ 和损失函数 $L(y, f(x))$ 的条件下，学习加法模型 $f(x)$ 就变成了一个经验风险极小化问题：

这是一个极其复杂的优化问题 —— 我们需要同时优化所有基函数的参数和权重。当 $M$ 较大时，直接求解几乎是不可能的。

1.2 前向分步算法：化整为零的求解策略

前向分步算法（Forward Stagewise Algorithm） 是解决上述问题的巧妙策略。其核心思想是从前向后，每一步只学习一个基函数及其系数，逐步逼近目标函数。

具体来说，在第 $m$ 步，我们固定前 $m-1$ 个基函数不变，只优化第 $m$ 个：

其中 $f_{m-1}(x) = \sum_{j=1}^{m-1} \beta_j b(x; \gamma_j)$ 是前 $m-1$ 步已经得到的模型。

更新模型：

前向分步算法的完整流程如下：

输入：训练数据集 $T$，损失函数 $L$，基函数集合 $\{b(x; \gamma)\}$

输出：加法模型 $f(x)$

算法步骤：

1. 初始化：令 $f_0(x) = 0$
2. 迭代更新：对 $m = 1, 2, \dots, M$： (a) 求解局部最优参数：极小化当前损失函数：$(\beta_m, \gamma_m) = \arg\min_{\beta,\gamma} \sum_{i} L\big(y_i,\ f_{m-1}(x_i) + \beta \cdot b(x_i; \gamma)\big)$ (b) 更新加法模型：$f_m(x) = f_{m-1}(x) + \beta_m \cdot b(x; \gamma_m)$
3. 输出最终模型：
   迭代完成后，得到加法模型：$f(x) = f_M(x) = \sum_{m=1}^{M} \beta_m \cdot b(x; \gamma_m)$

算法优势：前向分步算法将一个复杂的全局优化问题，分解为 $M$ 个相对简单的局部优化问题，每一步只需优化一个基函数的参数 $(\beta, \gamma)$，极大地降低了计算复杂度。

2.1 前向分步的困境

前向分步算法虽然思路清晰，但每一步仍然需要求解一个优化问题：

对于任意损失函数 $L$，这个优化问题可能仍然很困难。特别是当损失函数不是平方损失或指数损失时，没有简单的解析解。

梯度提升（Gradient Boosting） 的核心贡献就在于：它用“拟合负梯度”代替了“直接优化损失函数” ，从而将前向分步算法推广到了任意可微损失函数。

2.2 函数空间的梯度下降

要理解GBM为什么“拟合负梯度”，我们需要跳出参数空间，进入函数空间。

参数空间的梯度下降：

在传统的参数优化中，我们最小化损失函数 $L(\theta)$，参数更新公式为：

函数空间的梯度下降：

在GBM中，我们把函数 $f(x)$ 本身当作优化变量。在第 $m$ 步，前 $m-1$ 个基函数已经固定，即 $f_{m-1}(x)$ 已知。我们的目标是最小化：

其中 $f_m(x) = f_{m-1}(x) + \beta_m h_m(x)$。

如果我们把 $f(x)$ 当作“参数”，用梯度下降的思路来更新：

关键点：对比 $f_m(x) = f_{m-1}(x) + \beta_m h_m(x)$ 和上面的梯度下降更新式，可以发现：

也就是说，第 $m$ 棵树的训练目标，就是去拟合前一轮模型损失函数的负梯度。这就是GBM中 “拟合负梯度” 的完整数学推导。

2.3 负梯度的直观理解

负梯度也被称为 “伪残差（Pseudo Residual）” 。

• 当损失函数是平方损失 $L(y, f) = \frac{1}{2}(y - f)^2$ 时：$-\frac{\partial L}{\partial f} = y - f = \text{残差}$，此时GBM退化为拟合残差 —— 每一棵树学习的是“真实值与当前预测值的差”。

• 当损失函数是绝对损失 $L(y, f) = |y - f|$ 时，负梯度是 $\text{sign}(y - f)$ ——只告诉新树“方向”，不告诉“幅度”。

• 当损失函数是对数损失（分类任务）时，负梯度是概率误差。

直观理解：残差 $y - f(x)$ 越大，说明前一轮模型 $f(x)$ 与真实值 $y$ 相差越大。下一轮学习器通过拟合残差（或更一般地，负梯度），就能重点纠正前一轮犯错较大的地方。

3.1 回归任务的GBM

输入：训练集 $\{(x_i, y_i)\}_{i=1}^{N}$，可微损失函数 $L(y, f(x))$，迭代次数 $M$

输出：最终模型 $f_M(x)$

算法步骤：

步骤1：初始化 —— 用一个常数 $\gamma$ 来初始化模型。对于平方损失，$\gamma$ 就是所有 $y_i$ 的均值。

步骤2：对 $m = 1, 2, ..., M$ 迭代

(a) 计算负梯度（伪残差） ：

(b) 用基学习器（通常是CART回归树）拟合负梯度：

训练一棵回归树，以 $\{x_i\}$ 为输入，$\{r_{im}\}$ 为目标值，得到第 $m$ 棵树的叶节点区域 $\{R_{jm}\}_{j=1}^{J_m}$。

(c) 计算每个叶节点的最优输出值：

(d) 更新模型：

其中 $\nu \in (0, 1]$ 是学习率（Learning Rate） ，也叫收缩系数（Shrinkage） ，用于控制每棵树的贡献，防止过拟合。

步骤3：输出最终模型 $f_M(x)$。

代码实现：

1
import numpy as np
2
from sklearn.tree import DecisionTreeRegressor
3

4
class GradientBoostingRegressor:
5
    """从零实现梯度提升回归器"""
6

7
    def __init__(self, n_estimators=100, learning_rate=0.1, max_depth=3):
8
        self.n_estimators = n_estimators
9
        self.learning_rate = learning_rate
10
        self.max_depth = max_depth
11
        self.trees = []
12
        self.initial_pred = None
13

14
    def fit(self, X, y):
15
        # 步骤1：初始化
16
        self.initial_pred = np.mean(y)
17
        f = np.full(len(y), self.initial_pred)
18

19
        # 步骤2：迭代M轮
20
        for _ in range(self.n_estimators):
21
            # (a) 计算负梯度（对于平方损失，负梯度 = y - f）
22
            residuals = y - f
23

24
            # (b) 用决策树拟合残差
25
            tree = DecisionTreeRegressor(max_depth=self.max_depth)
26
            tree.fit(X, residuals)
27
            self.trees.append(tree)
28

29
            # (c) 更新预测（学习率控制步长）
30
            f += self.learning_rate * tree.predict(X)
31

32
        return self
33

34
    def predict(self, X):
35
        f = np.full(len(X), self.initial_pred)
36
        for tree in self.trees:
37
            f += self.learning_rate * tree.predict(X)
38
        return f
39

40
# 示例：拟合正弦函数
41
np.random.seed(42)
42
X = np.linspace(0, 10, 100).reshape(-1, 1)
43
y = np.sin(X).ravel() + 0.1 * np.random.randn(100)
44

45
gbm = GradientBoostingRegressor(n_estimators=50, learning_rate=0.1, max_depth=3)
46
gbm.fit(X, y)
47
y_pred = gbm.predict(X)
48

49
print(f"训练集MSE: {np.mean((y - y_pred) ** 2):.4f}")

3.2 分类任务的GBM

对于二分类问题，GBM使用对数损失（Log Loss） ：

负梯度为：

其余步骤与回归任务相同。最终通过 $\text{sign}(f_M(x))$ 做出分类决策。

4.1 偏差-方差分解回顾

在机器学习中，泛化误差可以分解为三个部分：

• 偏差（Bias） ：模型预测的平均值与真实值之间的差异——反映模型的表达能力
• 方差（Variance） ：模型在不同训练集上的预测波动——反映模型的稳定性
• 噪声（Noise） ：数据本身的不可约误差

4.2 随机森林：降低方差

随机森林通过并行构建多棵独立树并平均它们的预测来降低方差。

在之前的文章中我们推导过：如果 $m$ 棵树之间的相关性为 $\rho$，单棵树的方差为 $\sigma^2$，则平均预测的方差为：

当 $m \to \infty$ 时，方差趋近于 $\rho\sigma^2$。

随机森林通过行采样（Bootstrap） 和列采样（特征子空间） 来降低 $\rho$，从而进一步降低方差。

随机森林的本质 —— 通过“平均”来平滑掉单棵树的噪声，降低方差。

4.3 GBM：降低偏差

GBM则走了完全不同的路径。它通过串行地拟合残差（负梯度） ，每一轮都在修正前一轮的错误。

从偏差-方差的角度来看：随机森林降低方差，GBM降低偏差。

GBM的本质 —— 通过“持续纠错”来逼近真实函数，降低偏差。

这解释了为什么随机森林在噪声数据上更稳健，不容易过拟合；而GBM在干净数据上通常能达到更高的精度，但需要精细调参。

4.4 核心对比总结

5.1 原因分析

GBM对异常值的敏感性源于其 “串行纠错” 的机制。

• 原因一：平方损失放大了异常值的影响

  • 当使用平方损失时，负梯度就是残差 $y - f(x)$。
  • 如果一个样本是异常值（即 $y$ 与正常值相差很大），它的残差会非常大。由于平方损失对大误差的惩罚是二次的，这个异常值会在梯度中产生不成比例的巨大影响。
  • 在下一轮迭代中，新树会重点拟合这个巨大的残差，从而导致模型被异常值“带偏”。

• 原因二：串行传播放大了异常值的影响

  • 在随机森林中，一棵树受异常值影响，其他树可能不受影响，最终投票可以“稀释”掉这个影响。
  • 但在GBM中，每一棵树都建立在前面所有树的基础上 —— 如果早期的一棵树被异常值带偏，这个偏差会在后续的迭代中被不断放大。

5.2 缓解方法

• 方法一：使用鲁棒的损失函数

  • GBM的一大优势是可以使用任意可微的损失函数。如果我们担心异常值的影响，可以用Huber损失或绝对损失代替平方损失。
  • Huber损失：在误差较小时使用平方损失（光滑可微），在误差较大时使用绝对损失（对异常值不敏感）
  $$L_{\delta}(y, f) = \begin{cases} \frac{1}{2}(y - f)^2, & |y - f| \leq \delta \\ \delta |y - f| - \frac{1}{2}\delta^2, & |y - f| > \delta \end{cases}$$

• 方法二：降低学习率：较小的学习率意味着每棵树的贡献更小，模型更新更“谨慎”，从而降低了异常值的影响。

• 方法三：子采样（Subsampling）：在每次迭代中，只使用部分样本（如80%）来训练树。这可以降低异常值被选中的概率，类似于随机森林的行采样思想。

• 方法四：使用XGBoost/LightGBM等现代实现：这些实现内置了L1/L2正则化，可以有效控制模型的复杂度，减轻异常值的影响。

代码实现：

1
from sklearn.ensemble import GradientBoostingRegressor
2
from sklearn.datasets import make_regression
3
import numpy as np
4

5
# 生成数据并加入异常值
6
X, y = make_regression(n_samples=200, n_features=5, noise=10, random_state=42)
7
y[0] = y[0] * 10  # 制造一个异常值
8

9
# 使用平方损失（默认）
10
gbm_mse = GradientBoostingRegressor(loss='squared_error', n_estimators=100,
11
                                      learning_rate=0.1, random_state=42)
12
gbm_mse.fit(X, y)
13

14
# 使用Huber损失（对异常值更鲁棒）
15
gbm_huber = GradientBoostingRegressor(loss='huber', n_estimators=100,
16
                                       learning_rate=0.1, random_state=42)
17
gbm_huber.fit(X, y)
18

19
print(f"MSE损失模型在异常值样本上的预测: {gbm_mse.predict([X[0]])[0]:.2f}")
20
print(f"Huber损失模型在异常值样本上的预测: {gbm_huber.predict([X[0]])[0]:.2f}")
21
print(f"真实值: {y[0]:.2f}")
22
# Huber损失通常能更好地抵抗异常值的影响