Gradient Boosting

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

在上一节我们学习了自适应提升（AdaBoost），它通过调整样本权重来让后续的弱分类器聚焦于之前分错的样本。本节我们将学习另一种更强大、更通用的集成方法——梯度提升（Gradient Boosting）。梯度提升的核心思想是，将提升过程视为在函数空间中进行梯度下降，通过不断拟合当前模型的负梯度（即残差）来构建一个新的弱学习器，从而逐步逼近最优解。学完本节，你将理解梯度提升的理论框架，掌握其核心算法流程，并能通过手写代码实现一个简单的梯度提升回归树（GBDT）模型。

💡 核心导读

• 从残差到梯度：理解梯度提升如何将提升过程转化为在函数空间中沿损失函数的负梯度方向进行优化。
• 通用算法框架：掌握梯度提升的通用算法步骤，包括初始化、计算负梯度、拟合弱学习器和更新模型。
• GBDT 实例：通过一个具体的回归示例，学习如何使用决策树（CART）作为弱学习器来实现梯度提升，并观察模型如何逐步减小残差。
• 进阶优化与 XGBoost：了解梯度提升的常用优化技巧（如收缩率）以及 XGBoost 等高效实现背后的核心思想。
• 集成学习的意义：从偏差-方差分解的角度，理解集成学习（包括 Bagging 和 Boosting）为何能提升模型性能。

梯度提升的核心思想

在 AdaBoost 中，我们通过调整样本权重来让新分类器关注错误样本。梯度提升则从一个更数学化的视角来看待提升过程：将集成模型看作一个加法模型，其训练目标是最小化一个指定的损失函数。

假设我们有一个监督学习问题，目标是找到一个函数 $F(x)$，使其预测值 $F(x_i)$ 尽可能接近真实标签 $y_i$。我们通过最小化一个损失函数 $L(y, F(x))$ 来达到这个目的，例如均方误差 $L(y, F(x)) = (y - F(x))^2$ 或交叉熵损失。

梯度提升将最终模型 $F(x)$ 表示为一系列弱学习器（例如决策树）的加权和： $$F_M(x) = \sum_{m=1}^{M} \alpha_m h_m(x)$$ 其中，$h_m(x)$ 是第 $m$ 个弱学习器，$\alpha_m$ 是其权重。

训练过程是前向分步的：我们从初始模型（例如一个常数）$F_0(x)$ 开始，然后依次添加弱学习器。在第 $m$ 步，我们已经有了模型 $F_{m-1}(x)$，目标是找到一个新弱学习器 $h_m(x)$ 及其权重 $\alpha_m$，使得新模型 $F_m(x) = F_{m-1}(x) + \alpha_m h_m(x)$ 的损失最小。

关键洞察：寻找最优的 $h_m(x)$ 和 $\alpha_m$ 可以类比于在函数空间中进行梯度下降。损失函数 $L$ 关于当前模型 $F_{m-1}$ 的负梯度，正好指向损失下降最快的方向。对于第 $i$ 个样本，这个负梯度为： $$r_{mi} = -\left[ \frac{\partial L(y_i, F(x_i))}{\partial F(x_i)} \right]_{F(x)=F_{m-1}(x)}$$

对于均方误差损失 $L(y, F(x)) = \frac{1}{2}(y - F(x))^2$，其负梯度恰好是残差 $r_{mi} = y_i - F_{m-1}(x_i)$。因此，拟合残差等价于拟合损失函数的负梯度方向。梯度提升的通用策略就是：让新加入的弱学习器 $h_m(x)$ 去拟合当前模型的负梯度 $r_{mi}$。这样，将 $h_m(x)$ 加到模型上，就相当于沿着损失函数下降的方向前进了一步。

梯度提升通用算法

基于上述思想，梯度提升的通用算法可以概括为以下几步：

1. 初始化：用一个常数值初始化模型，这个常数通常是使初始损失最小的值。对于均方误差，就是目标值 $y$ 的均值。 $$F_0(x) = \arg\min_{\gamma} \sum_{i=1}^{N} L(y_i, \gamma)$$

2. 对于 m = 1 到 M（迭代轮数）： a. 计算负梯度（伪残差）：对于每个样本 $i$，计算损失函数关于当前模型预测值的负梯度。 $$r_{mi} = -\left[ \frac{\partial L(y_i, F(x_i))}{\partial F(x_i)} \right]_{F(x)=F_{m-1}(x)}$$ b. 拟合弱学习器：使用训练数据 ${(x_i, r_{mi})}_{i=1}^{N}$ 训练一个弱学习器 $h_m(x)$，使其尽可能拟合这些负梯度值。 c. 计算步长（权重）：通过线搜索确定弱学习器 $h_m(x)$ 的最优权重 $\alpha_m$，使得加上该弱学习器后总损失最小。 $$\alpha_m = \arg\min_{\alpha} \sum_{i=1}^{N} L(y_i, F_{m-1}(x_i) + \alpha h_m(x_i))$$ d. 更新模型：将新弱学习器乘以其权重后加到现有模型中。 $$F_m(x) = F_{m-1}(x) + \alpha_m h_m(x)$$

3. 输出最终模型：$F_M(x)$。

这个框架是通用的，适用于不同的损失函数和弱学习器。当弱学习器为决策树时，就得到了著名的梯度提升决策树（GBDT）。

梯度提升决策树（GBDT）示例

让我们用一个简单的回归示例，手动实现一个使用决策树桩（深度为1的决策树）作为弱学习器的GBDT模型。我们使用均方误差作为损失函数，此时负梯度就是残差。

假设我们有5个数据点 $(x, y)$：(1, 1.2), (2, 1.9), (3, 3.2), (4, 3.8), (5, 5.1)。我们的目标是学习一个回归模型 $F(x)$。

下面的代码将演示两轮提升的过程：

import math

# 训练数据
x_data = [1, 2, 3, 4, 5]
y_data = [1.2, 1.9, 3.2, 3.8, 5.1]
n = len(y_data)

# 1. 初始化：F0(x) = 目标值y的均值（对于MSE损失）
F0 = sum(y_data) / n
print(f"初始模型预测值 F0: {[F0]*n}")
print(f"初始模型常数项（均值）: {F0:.4f}\n")

# 辅助函数：计算均方误差
def mse(y_true, y_pred):
    return sum((yt - yp) ** 2 for yt, yp in zip(y_true, y_pred)) / n

# 第一轮提升 (m=1)
# a. 计算负梯度（残差）：r1i = yi - F0(xi)
residuals1 = [y - F0 for y in y_data]
print(f"第一轮负梯度（残差）: {[round(r, 3) for r in residuals1]}")

# b. 拟合一个决策树桩（弱学习器h1(x)）。这里我们手动选择一个分裂点。
#    为了简单，我们选择在 x < 3.5 和 x >= 3.5 处分裂。
split_point1 = 3.5
left_indices1 = [i for i, x in enumerate(x_data) if x < split_point1]
right_indices1 = [i for i, x in enumerate(x_data) if x >= split_point1]

#    每个区域的输出值γ是该区域内残差的均值（对于MSE损失，这是最优输出）
gamma_left1 = sum(residuals1[i] for i in left_indices1) / len(left_indices1) if left_indices1 else 0
gamma_right1 = sum(residuals1[i] for i in right_indices1) / len(right_indices1) if right_indices1 else 0
print(f"第一棵树区域划分: x < {split_point1} 和 x >= {split_point1}")
print(f"  左区域输出值 γ_left: {gamma_left1:.4f}")
print(f"  右区域输出值 γ_right: {gamma_right1:.4f}")

# c. & d. 更新模型：F1(x) = F0 + h1(x)。这里我们使用学习率 ν=1（无收缩）。
learning_rate = 1.0
h1_predictions = [gamma_left1 if x < split_point1 else gamma_right1 for x in x_data]
F1_predictions = [F0 + learning_rate * h1 for h1 in h1_predictions]
print(f"\n第一棵树预测值 h1(x): {[round(h, 4) for h in h1_predictions]}")
print(f"更新后模型预测值 F1: {[round(f, 4) for f in F1_predictions]}")
print(f"真实目标值 y: {y_data}")
print(f"F1的均方误差(MSE): {mse(y_data, F1_predictions):.6f}\n")

# 第二轮提升 (m=2)，基于更新后的模型F1
# a. 计算新的残差：r2i = yi - F1(xi)
residuals2 = [y - f1 for y, f1 in zip(y_data, F1_predictions)]
print(f"第二轮负梯度（残差）: {[round(r, 3) for r in residuals2]}")

# b. 拟合第二个决策树桩h2(x)。选择另一个分裂点，例如 x < 2.5。
split_point2 = 2.5
left_indices2 = [i for i, x in enumerate(x_data) if x < split_point2]
right_indices2 = [i for i, x in enumerate(x_data) if x >= split_point2]

gamma_left2 = sum(residuals2[i] for i in left_indices2) / len(left_indices2) if left_indices2 else 0
gamma_right2 = sum(residuals2[i] for i in right_indices2) / len(right_indices2) if right_indices2 else 0
print(f"第二棵树区域划分: x < {split_point2} 和 x >= {split_point2}")
print(f"  左区域输出值 γ_left2: {gamma_left2:.4f}")
print(f"  右区域输出值 γ_right2: {gamma_right2:.4f}")

# c. & d. 更新模型：F2(x) = F1(x) + h2(x)
h2_predictions = [gamma_left2 if x < split_point2 else gamma_right2 for x in x_data]
F2_predictions = [f1 + learning_rate * h2 for f1, h2 in zip(F1_predictions, h2_predictions)]
print(f"\n第二棵树预测值 h2(x): {[round(h, 4) for h in h2_predictions]}")
print(f"更新后模型预测值 F2: {[round(f, 4) for f in F2_predictions]}")
print(f"真实目标值 y: {y_data}")
print(f"F2的均方误差(MSE): {mse(y_data, F2_predictions):.6f}")

初始模型预测值 F0: [3.04, 3.04, 3.04, 3.04, 3.04]
初始模型常数项（均值）: 3.0400

第一轮负梯度（残差）: [-1.84, -1.14, 0.16, 0.76, 2.06]
第一棵树区域划分: x < 3.5 和 x >= 3.5
  左区域输出值 γ_left: -0.9400
  右区域输出值 γ_right: 1.4100

第一棵树预测值 h1(x): [-0.94, -0.94, -0.94, 1.41, 1.41]
更新后模型预测值 F1: [2.1, 2.1, 2.1, 4.45, 4.45]
真实目标值 y: [1.2, 1.9, 3.2, 3.8, 5.1]
F1的均方误差(MSE): 0.581000

第二轮负梯度（残差）: [-0.9, -0.2, 1.1, -0.65, 0.65]
第二棵树区域划分: x < 2.5 和 x >= 2.5
  左区域输出值 γ_left2: -0.5500
  右区域输出值 γ_right2: 0.3667

第二棵树预测值 h2(x): [-0.55, -0.55, 0.3667, 0.3667, 0.3667]
更新后模型预测值 F2: [1.55, 1.55, 2.4667, 4.8167, 4.8167]
真实目标值 y: [1.2, 1.9, 3.2, 3.8, 5.1]
F2的均方误差(MSE): 0.379333

过程解读：

1. 初始化：$F_0(x)$ 是所有 $y$ 的均值 3.04，一个很粗糙的起点（初始 MSE 为 1.9064）。
2. 第一轮：残差显示模型普遍高估了左边、低估了右边。树桩以 $x=3.5$ 为界拟合残差（左 $-0.94$、右 $1.41$），加上去之后 MSE 从 1.906 直落到 0.581。
3. 第二轮：基于 $F_1$ 算新残差，换 $x=2.5$ 再切一刀，MSE 进一步降到 0.379。

通过不断添加拟合残差的树，模型 $F_m(x)$ 逐步逼近真实值。实际的 GBDT 会用更深的树、更多轮迭代，直到残差足够小或触发停止条件。

讲师的经典例子：用两棵树预测年龄

课末讲师用一个人人都能看懂的例子收束了 GBDT。任务：预测四个人 A、B、C、D 的年龄——14、16、24、26 岁。

如果是传统决策树：一棵树学到底。比如先按”月购物金额 < 1000 / ≥ 1000”分成两组（14、16 在左，24、26 在右），再在每组内按”上网时长”细分，一次建出四个区域，每个区域一个精确年龄。

GBDT 的做法是”先粗后补”：

• 第一棵树（弱分类器）：只用一个特征——购物金额。< 1000 的一组是 {14, 16}，均值 15；≥ 1000 的一组是 {24, 26}，均值 25。每个区域都用均值代替真值。
• 算残差：14 − 15 = −1，16 − 15 = +1，24 − 25 = −1，26 − 25 = +1。四个人的残差正是 −1、+1、−1、+1（组内均值恰好为 0）。
• 第二棵树：不再学原始年龄，改学残差。这次换个特征——“是否常在百度上提问”：爱提问的是 14 岁的初中生和 24 岁刚入职场的新人（残差 −1 那两个），爱回答的是 16 岁的高中生和 26 岁的职场老手（残差 +1）。按这个特征一刀切下去，两边的残差均值正好是 −1 和 +1——切完之后残差清零，问题完美解决。
• 预测一个 24 岁的人：第一棵树按购物金额给出 25；第二棵树按”爱提问”给出 −1；两棵树相加：25 + (−1) = 24。分毫不差。

这就是 GBDT 与原始决策树的本质区别：不建一棵完美的大树，而是用多棵”只管一件事”的弱树，每棵拟合上一棵剩下的残差，最后把结果累加起来。

优化技巧与 XGBoost

基本的梯度提升算法已经很强大了，但仍有改进空间。常见的优化技巧包括：

• 收缩（Shrinkage）：在更新模型时不直接加上 $h_m(x)$，而是加上 $\theta \cdot h_m(x)$，其中 $\theta$ 是一个很小的正数——讲师给的范围是 0.001～0.01。 $$F_m(x) = F_{m-1}(x) + \theta \cdot \alpha_m h_m(x)$$ 收缩让每一步只朝目标方向挪一小步，每轮都留下一部分残差交给后面的树继续消化。它减慢了拟合速度，但”小步慢走”不容易冲过头、错过最优解，通常能取得更好的最终效果。

• 子采样（Subsampling）：类似于随机森林，在每一轮训练弱学习器时，不是使用全部训练数据，而是随机抽取一部分样本（有放回或无放回）。这增加了模型的随机性，有助于降低方差，也是防止过拟合的有效手段。

• 正则化：在决策树作为弱学习器时，可以通过限制树的最大深度、最小叶子节点样本数等来进行正则化；也可以直接在损失函数上加正则项。

XGBoost（X 代表 eXtreme——“极致”的梯度提升）是梯度提升算法的高效工程实现，也是各类机器学习竞赛的常胜工具。它背后的核心道理正是本节的 Gradient Boosting，在此之上叠加了多重强化：二阶泰勒展开（不只利用一阶梯度，还利用损失函数的二阶导数信息，让每步更新方向更准）、正则化、Shrinkage，以及大量工程层面的速度优化。正是这些强化让它在很多问题上能不断逼近最好的结果。讲师课后提供了 XGBoost 与随机森林等算法对比的代码，建议亲手跑一跑。

集成学习的意义：偏差与方差的权衡

为什么集成学习（包括 Bagging 和 Boosting）通常比单一模型更好？我们可以从偏差（Bias）和方差（Variance）的角度来理解。

模型的泛化误差可以分解为偏差、方差和不可避免的噪声之和：

• 偏差：模型预测值的期望与真实值之间的差异。高偏差意味着模型拟合能力不足，可能欠拟合。
• 方差：模型预测值的变化范围。高方差意味着模型对训练数据中的随机波动过于敏感，可能过拟合。

讲师用打靶把四种组合讲成了一幅图：

• 低偏差、低方差：枪法准、瞄得也准——子弹都聚在靶心，最理想；
• 高偏差、低方差：枪法不错但瞄歪了——弹着点很集中，却整体偏在一边，是系统性错误；
• 低偏差、高方差：瞄准的是中心，但手抖——弹着点散布在靶心四周；
• 高偏差、高方差：瞄得又不准、枪法又差——满靶乱飞，最糟糕。

不同的集成方法对偏差和方差的影响不同：

• Bagging（如随机森林）：通过自助采样构建多个差异化的模型，然后取平均（回归）或投票（分类）。其主要作用是降低方差。因为平均操作可以平滑掉各个模型因数据随机性而产生的波动。对于本身高方差、低偏差的模型（如深度决策树），Bagging 效果显著。
• Boosting（如 AdaBoost, GBDT）：通过顺序训练，让后续模型纠正前序模型的错误。其主要作用是降低偏差。因为每一步都在努力减少当前模型在训练集上的误差（损失），从而不断提升模型的拟合能力。同时，由于集成了多个模型，它也能在一定程度上降低方差。

理想模型是低偏差且低方差的。集成学习通过组合多个”弱”或”不稳定”的学习器，往往能在偏差和方差之间取得更好的平衡，从而获得更优的泛化性能——多个臭皮匠投票，把个体的误差与噪声”投”出去，留下集体的智慧。

最后留一个更高的视角：集成学习本身并不是某个单独的算法，它更像一种 meta learning（元学习）——在已有的一批算法之上，研究”用什么方式把它们组合起来”才能得到更好的最终结果。这正是本章从头到尾在做的事。

📝 动手练一练

1. 概念辨析：请简述梯度提升（Gradient Boosting）与自适应提升（AdaBoost）的核心区别。它们分别主要降低的是模型的偏差还是方差？

2. 代码实践：在上面提供的 GBDT 示例代码中，我们使用了固定的分裂点（3.5 和 2.5）。请修改代码，实现一个简单的函数，让它自动寻找使左右区域残差平方和最小的分裂点（只考虑数据点之间的中点作为候选），并完成第三轮提升（m=3）。观察 MSE 是否继续下降。

import math

# 训练数据
x_data = [1, 2, 3, 4, 5]
y_data = [1.2, 1.9, 3.2, 3.8, 5.1]
n = len(y_data)

# 初始化
F_current = [sum(y_data) / n] * n
learning_rate = 1.0

def mse(y_true, y_pred):
    return sum((yt - yp) ** 2 for yt, yp in zip(y_true, y_pred)) / n

def find_best_split(x_vals, residuals):
    """在x_vals中寻找最佳分裂点（候选点为相邻值的中点），使左右区域残差平方和最小。"""
    best_split = None
    best_loss = float('inf')
    # 对x排序并获取唯一值
    sorted_pairs = sorted(zip(x_vals, residuals))
    unique_x = sorted(set(x_vals))
    
    for i in range(len(unique_x) - 1):
        # 候选分裂点为相邻x值的中点
        candidate = (unique_x[i] + unique_x[i+1]) / 2.0
        left_res = [r for x, r in sorted_pairs if x < candidate]
        right_res = [r for x, r in sorted_pairs if x >= candidate]
        
        # 计算左右区域残差平方和
        loss = sum(r*r for r in left_res) + sum(r*r for r in right_res)
        if loss < best_loss:
            best_loss = loss
            best_split = candidate
    return best_split

# 进行三轮提升
for round_num in range(1, 4):
    # 计算当前残差
    residuals = [y - f for y, f in zip(y_data, F_current)]
    
    # 寻找最佳分裂点
    best_split = find_best_split(x_data, residuals)
    
    # 划分区域并计算输出值
    left_indices = [i for i, x in enumerate(x_data) if x < best_split]
    right_indices = [i for i, x in enumerate(x_data) if x >= best_split]
    
    gamma_left = sum(residuals[i] for i in left_indices) / len(left_indices) if left_indices else 0
    gamma_right = sum(residuals[i] for i in right_indices) / len(right_indices) if right_indices else 0
    
    # 更新模型预测
    h_predictions = [gamma_left if x < best_split else gamma_right for x in x_data]
    F_new = [f + learning_rate * h for f, h in zip(F_current, h_predictions)]
    
    print(f"第{round_num}轮：")
    print(f"  最佳分裂点: {best_split:.2f}")
    print(f"  左区域输出γ: {gamma_left:.4f}, 右区域输出γ: {gamma_right:.4f}")
    print(f"  更新后预测值 F{round_num}: {[round(f, 4) for f in F_new]}")
    print(f"  当前MSE: {mse(y_data, F_new):.6f}\n")
    
    F_current = F_new

第1轮：
  最佳分裂点: 2.50
  左区域输出γ: -1.4900, 右区域输出γ: 0.9933
  更新后预测值 F1: [1.55, 1.55, 4.0333, 4.0333, 4.0333]
  当前MSE: 0.426333

第2轮：
  最佳分裂点: 1.50
  左区域输出γ: -0.3500, 右区域输出γ: 0.0875
  更新后预测值 F2: [1.2, 1.6375, 4.1208, 4.1208, 4.1208]
  当前MSE: 0.395708

第3轮：
  最佳分裂点: 1.50
  左区域输出γ: 0.0000, 右区域输出γ: -0.0000
  更新后预测值 F3: [1.2, 1.6375, 4.1208, 4.1208, 4.1208]
  当前MSE: 0.395708

本章小结

本节我们深入探讨了梯度提升（Gradient Boosting）这一强大的集成学习框架。我们从其核心思想——在函数空间中进行梯度下降以最小化损失函数——出发，推导出了通用的算法流程。通过一个具体的 GBDT 回归示例，我们亲手实践了如何用决策树拟合残差来逐步提升模型性能。此外，我们还了解了包括收缩、子采样在内的优化技巧，以及 XGBoost 如何在此基础上进行扩展和优化。最后，我们从偏差-方差分解的角度，理解了集成学习为何能有效提升模型的泛化能力。

📋 行动清单

• 理解流程：复述梯度提升通用算法的四个关键步骤（初始化、计算负梯度、拟合弱学习器、更新模型）。
• 手动推算：针对一个只有3个数据点的极小数据集，用纸笔模拟一轮 GBDT 的计算过程，验证你对残差计算和树桩拟合的理解。
• 代码扩展：尝试修改动手练习中的代码，将损失函数从均方误差改为绝对误差（L1损失），并推导其负梯度的形式，观察算法如何工作。

—— 小象教研组