【机器学习chp9】集成学习

如何生成多个差异化的基学习器：
- 异质集成学习：基学习器算法不同。
- 同质集成学习：基学习器算法相同，但通过不同的训练数据（如Bagging）生成差异。
如何组合基学习器的预测结果：
- 常用方法：Bagging、Boosting、投票（Voting）、堆叠（Stacking）。

二、Bagging

1. Bagging的基本流程

核心思想：通过 Bootstrap采样（有放回采样）构造多个子训练集，并训练多个基模型，最终将这些模型的输出进行 投票（分类任务） 或 平均（回归任务） 来得到最终预测结果。
具体步骤：
1. 从训练集 $D$ 中进行 有放回采样，得到多个子训练集 $D^1, D^2, ..., D^M$ 。
2. 基于每个子训练集训练对应的基学习器 $f_1(x), f_2(x), ..., f_M(x)$ 。
3. 通过集成（aggregating）方法，如简单平均（回归）或多数投票（分类），得到最终预测结果 $f_\text{avg}(x)$ 。

公式：

$f_\text{avg}(x) = \frac{1}{M} \sum_{m=1}^M f_m(x)$

2. Bootstrap采样的特点

定义：从 $N$ 个样本的数据集中进行 $N$ 次 有放回采样，生成一个新的样本集。
性质：
- 每次采样生成的子集与原始数据集的大小相同，但某些样本可能被重复抽取，部分样本可能未被抽取。
  - 样本未出现在子集中（OOB数据）的概率： $P(\{$ 样本未被采样 $\}) = \left(1 - \frac{1}{N}\right)^N \approx 0.368$ 即，约 $36.8\%$ 的样本未被包含在子集中，这些 OOB数据 可用于模型性能验证。

3. Bagging的两个核心问题

如何生成差异化的基学习器：
- 同质模型：通过对训练数据集的随机采样（Bootstrap）生成差异化模型。
- 异质模型：可以使用不同的算法训练基学习器，但通常在Bagging中不常见。
如何组合基学习器的预测结果：
- 分类任务：采用 投票法。
- 回归任务：使用 平均法。

4. Bagging的优势

降低方差：通过集成多个独立的学习器，减少模型对特定训练集的依赖，降低预测结果的波动性（方差）。
对高偏差模型的效果有限：Bagging无法直接降低模型的偏差，因此适用于高方差低偏差的模型，例如深度决策树。
提高稳定性：适合复杂模型，如决策树（如随机森林）和神经网络。

公式分析：对于 $M$ 个独立同分布的学习器 $f_1(x), f_2(x), ..., f_M(x)$ ：

预测值的期望： $\mathbb{E}[f(x)] = \mathbb{E}\left[\frac{1}{M} \sum_{m=1}^M f_m(x)\right] = \mathbb{E}[f_m(x)]$ 即与单个模型相同。
预测值的方差： $\text{Var}[f(x)] = \frac{1}{M} \text{Var}[f_m(x)]$ 可见，模型数量 $M$ 越大，预测结果的方差越低。

5. Bagging降低模型方差的机制

如果基学习器是完全独立的，方差可被完全降低： $\text{Var}[f(x)] = \frac{\sigma^2}{M}$ 其中 $\sigma^2$ 是单个模型的方差。
如果基学习器之间有相关性（相关性系数 $\rho$ ），方差降低效果减弱： $\text{Var}[f(x)] = \rho \sigma^2 + \frac{1-\rho}{M} \sigma^2$
减少相关性的方法：
- 增大采样的随机性（如在随机森林中选择特征的随机子集）。

6. Bagging适用场景

偏差低、方差高的模型（例如深度决策树），Bagging通过减少方差提高预测精度。
对抗过拟合：Bagging能有效降低复杂模型的过拟合风险。
随机森林 是Bagging的经典变体，通过增加特征采样进一步降低基学习器之间的相关性。

7. Scikit-Learn中的Bagging

Scikit-Learn 提供了两种实现 Bagging 的方法：

BaggingClassifier：用于分类任务。
BaggingRegressor：用于回归任务。

BaggingClassifier和BaggingRegressor的主要参数：

base_estimator：指定基学习器，可以是分类器或回归器；如果未指定，默认使用决策树。
n_estimators：基学习器数量，通常越多效果越好，但也会增加计算开销。
max_samples：每个基学习器训练时使用的样本数比例或绝对值，支持浮点或整数。
max_features：每个基学习器训练时使用的特征数比例或绝对值。
bootstrap：是否对样本进行有放回采样，默认 True。
bootstrap_features：是否对特征进行有放回采样，默认 False。
oob_score：是否使用袋外样本计算泛化误差（Out-of-Bag Error）。
warm_start：是否允许增量训练，增加新的基学习器。

8. Out-of-Bag Error（袋外误差）

在 Bagging 中，每个基学习器只在一部分训练样本上训练，未被采样的样本称为 袋外样本（Out-of-Bag, OOB）。
OOB 样本可以直接用于验证模型，无需额外划分交叉验证集。
OOB误差计算：
- 对于每个未使用某样本训练的基学习器，计算该样本的预测误差。
- 综合所有样本的袋外误差，估计模型的泛化能力。

9. 基学习器数量的影响

效果随基学习器数量增加而提高：
- 基学习器越多，方差越低，模型越稳定。
- 当基学习器数量超过一定值后，效果趋于稳定，增大数量的收益降低。
参数建议：
- 分类任务：基学习器数量 $\sqrt{D}$ ，其中 $D$ 为特征数。
- 回归任务：基学习器数量 $D / 3$ 。

10. 随机森林（Random Forest）

定义：随机森林是 Bagging 的一种变体，结合了决策树和随机特征选择。
改进：
- 随机选择部分特征：在分裂时，每个节点只考虑一部分特征，进一步降低树之间的相关性。
- 随机选择部分样本：与 Bagging 类似，对样本进行有放回采样。

随机森林的优势：

降低相关性：通过随机性减少树之间的相关性，从而进一步降低模型方差。
广泛应用：随机森林在很多应用场景中表现优异，但由于随机性降低了解释性。

11. Scikit-Learn中的随机森林实现

RandomForestClassifier：用于分类任务。
RandomForestRegressor：用于回归任务。
Extremely Randomized Trees（极度随机森林）：
- 相比标准随机森林，极度随机森林的分裂过程更加随机：
  - 随机选择特征。
  - 对每个候选特征的阈值也随机选择，而不是基于信息增益等指标。
- 优点：增加模型随机性，方差进一步减小，但偏差可能略增。

12. 随机森林的超参数调优

随机森林的参数众多，调优时需注意以下顺序：

控制模型复杂度：
- 子采样率（subsample） 和 分裂时最大特征数（max_features）。
控制过拟合：
- 叶节点最小样本数（min_samples_leaf）。
- 分裂所需最小样本数（min_samples_split）。
控制树深：
- 最大深度（max_depth）。
- 最大叶节点数（max_leaf_nodes）。

三、提升法Boosting

1、Boosting概述

（1）Bagging与Boosting的区别

Bagging（并行）：多个基学习器同时训练，各自独立，最终通过投票或平均的方式融合。
Boosting（顺序）：多个基学习器按顺序训练，每个学习器通过修正前一个学习器的错误逐步提高性能。

（2）Boosting的核心思想

目标：将一系列弱学习器组合成一个强学习器。
弱学习器：性能略优于随机猜测的模型（如深度较浅的决策树）。
训练过程：
1. 先训练第一个弱学习器。
2. 后续的弱学习器针对前一个学习器的错误样本进行改进。
3. 最终模型是多个弱学习器的加权组合： $f(x) = \sum_{m=1}^M \alpha_m \phi_m(x)$

（3）互补学习器的获取方式

为了让每个弱学习器互相弥补，Boosting 通过以下方式构建差异化的弱学习器：

样本重采样：对训练集重新采样，生成不同的数据集。
标签调整：对训练数据的标签进行调整（基于提升方法）。
样本加权（AdaBoost）：根据前一个学习器的错误率，对样本分配权重，关注难分类样本。

（4）Boosting的优缺点

优点：

能够有效降低偏差，适合弱学习器。
强调难分类的样本，提高分类器的整体性能。
具有强大的理论支持，如与指数损失函数的等价性。

缺点：

对异常点敏感，可能因权重的提高导致过拟合。
弱学习器的选择和调参对结果影响较大。

2、AdaBoost

（1）AdaBoost的基本原理

核心思想：每次迭代训练一个弱分类器，重点关注前一轮误分类的样本，通过更新样本权重逐步提升模型性能。
步骤：
1. 初始化样本权重分布： $w_{1,i} = \frac{1}{N}$
2. 计算弱分类器 $\phi_1(x)$ 在权重分布下的误差率： $\epsilon_1 = \sum_{i=1}^N w_{1,i} \cdot \mathbb{I}(y_i \neq \phi_1(x_i))$
3. 根据误差率计算弱分类器的权重： $\alpha_1 = \frac{1}{2} \ln\left(\frac{1 - \epsilon_1}{\epsilon_1}\right)$
4. 更新样本权重，错误分类的样本权重增大： $w_{2,i} = w_{1,i} \cdot \exp\left(-\alpha_1 y_i \phi_1(x_i)\right)$ 然后归一化： $w_{2,i} = \frac{w_{2,i}}{\sum_{j=1}^N w_{2,j}}$
5. 重复上述步骤，训练后续弱学习器，最终组合所有弱学习器。

（2）样本加权的具体计算

分对的样本权重降低，分错的样本权重提高：
- 对于分错的样本： $w_{2,i} = w_{1,i} \cdot d_1$
- 对于分对的样本： $w_{2,i} = \frac{w_{1,i}}{d_1}$
$d_1$ 的值由以下公式计算： $d_1 = \sqrt{\frac{1 - \epsilon_1}{\epsilon_1}}$ 其中， $\epsilon_1$ 为上一轮弱分类器的误差率。这里d1的推导过程见附录1

（3）AdaBoost M1算法

总结为以下步骤：

初始化样本权重 $w_{1,i} = \frac{1}{N}$ 。
迭代到：
- 使用当前权重训练弱分类器 $\phi_m(x)$ 。
- 计算弱分类器误差率 $\epsilon_m$ 。
- 计算分类器权重： $\alpha_m = \frac{1}{2} \ln\left(\frac{1 - \epsilon_m}{\epsilon_m}\right)$
- 更新样本权重： $w_{m+1,i} = w_{m,i} \exp\left(-\alpha_m y_i \phi_m(x_i)\right)$ 并归一化。（这里将 $\alpha_m$ 的公式带入其实可以化成 $d_m$ 的形式，即这个式子等价于通过 $d_m$ 对 $w_{m+1,i}$ 的更新的两个公式。）
最终模型： $f(x) = \text{sign}\left(\sum_{m=1}^M \alpha_m \phi_m(x)\right)$

（4）例子

（5）证明“随着弱学习器数量增多，训练误差越来越小”

i、背景与目标

在 AdaBoost 中，多个弱学习器通过迭代训练组合成一个强学习器。
训练误差定义为： $ERR_{train}(f(x)) = \frac{1}{N} \sum_{i=1}^N \mathbb{I}(y_i \neq \text{sign}(f(x_i)))$ 其中， $\mathbb{I}(\cdot)$ 是指示函数，表示预测错误的样本个数。

目标：证明训练误差随弱学习器数量 $M$ 增加而不断减小。

ii、AdaBoost 的组合模型

最终的强学习器由所有弱学习器的加权组合构成：

$f(x) = \sum_{m=1}^M \alpha_m \phi_m(x)$

其中：

$\alpha_m$ 表示第 $m$ 个弱学习器的权重，与其误分类率相关。
$\phi_m(x)$ 表示第 $m$ 个弱学习器。

iii、权重更新公式的展开

从 AdaBoost 的权重更新公式：

$w_{m+1, i} = \frac{w_{m, i} \exp(-\alpha_m y_i \phi_m(x_i))}{Z_m}$

可以迭代展开得到：

$w_{M+1, i} = \frac{w_{1, i} \exp(-y_i f(x_i))}{\prod_{m=1}^M Z_m}$

$w_{1,i} = \frac{1}{N}$ 是初始权重。
$\prod_{m=1}^M Z_m$ 是归一化因子，确保权重分布的总和为 1。
其中 $f(x_i) = \sum_{m=1}^M \alpha_m \phi_m(x_i)$ 是强分类器。

iv、训练误差的指数上界

从指示函数到指数函数的松弛：

训练误差涉及指示函数 $\mathbb{I}(y_i \neq \text{sign}(f(x_i)))$ ，可以用指数函数进行松弛：

$\mathbb{I}(y_i \neq \text{sign}(f(x_i))) \leq \exp(-y_i f(x_i))$

因此，训练误差满足：

$ERR_{train}(f(x)) \leq \frac{1}{N} \sum_{i=1}^N \exp(-y_i f(x_i))$

权重归一化的影响：

根据权重公式：

$w_{M+1, i} = \frac{\frac{1}{N} \cdot \exp(-y_i f(x_i))}{\prod_{m=1}^M Z_m}$

由于 $w_{M+1}$ 是一个分布，所以 $\sum_{i=1}^N w_{M+1, i} = 1$ ，即： $\sum_{i=1}^N w_{1, i} \frac{\exp(-y_i f(x_i))}{\prod_{m=1}^M Z_m} = 1$

所以有：

$\frac{1}{N} \sum_{i=1}^N \exp(-y_i f(x_i)) = \prod_{m=1}^M Z_m$

将其代入训练误差的表达式，得：

$ERR_{train}(f(x)) \leq \prod_{m=1}^M Z_m$

v、归一化因子 Zm 的性质

归一化因子 $Z_m$ 的值为：

$Z_m = 2\sqrt{\epsilon_m (1 - \epsilon_m)}$

其中：

$\epsilon_m$ 是第 $m$ 个弱学习器的误分类率。

性质分析：

当 $\epsilon_m < 0.5$ 时： $Z_m = 2\sqrt{\epsilon_m (1 - \epsilon_m)} < 1$ , 说明弱学习器表现优于随机猜测。
当 $\epsilon_m = 0.5$ 时： $Z_m = 1$ , 表示弱学习器等价于随机猜测，不影响训练误差。

因此，每一轮的 $Z_m < 1$ （前提是弱学习器有效），导致训练误差递减。

vi、训练误差的递减

将训练误差表达为：

$ERR_{train}(f(x)) \leq \prod_{m=1}^M Z_m$

累积效应：

每一轮迭代的归一化因子 $Z_m < 1$ ，使得 $\prod_{m=1}^M Z_m$ 指数递减。
随着弱学习器数量 $M$ 增加，训练误差上界不断减小。

vii、指数损失的解释

AdaBoost 的优化目标是最小化指数损失函数：

$L(f(x), y) = \frac{1}{N} \sum_{i=1}^N \exp(-y_i f(x_i))$

指数损失比 0-1 损失更敏感，尤其是对高置信度的错误分类样本有更大的优化压力。

训练误差作为指数损失的上界，能够随指数损失的优化而减小。

viii、结论

训练误差受到 $\prod_{m=1}^M Z_m$ 的限制。
$Z_m < 1$ 确保每轮迭代训练误差递减。
AdaBoost 的设计通过动态调整样本权重，优化弱学习器，使得训练误差随弱学习器数量增加而趋于零（理论上）。

（6）AdaBoost 测试误差详细分析（疑问？）

i、回顾训练误差

AdaBoost 的训练误差可以表示为：

$\text{ERR}_{\text{train}} = \frac{1}{N} \sum_{i=1}^N \mathbb{I}(y_i \neq \text{sgn}(f(x_i)))$

其中， $\text{sgn}(f(x_i))$ 是最终分类器的符号函数。

为了分析误差的变化，引入指数损失函数代替 $0-1$ 损失：

$\mathcal{L}_{\text{exp}} = \frac{1}{N} \sum_{i=1}^N \exp(-y_i f(x_i))$

其中 $f(x) = \sum_{m=1}^M \alpha_m \phi_m(x)$

训练误差的上界

将训练误差与指数损失关联：

$\mathbb{I}(y_i \neq \text{sgn}(f(x_i))) \leq \exp(-y_i f(x_i))$

因此：

$\text{ERR}_{\text{train}} \leq \frac{1}{N} \sum_{i=1}^N \exp(-y_i f(x_i)) = \prod_{m=1}^M Z_m$

其中：

$Z_m = \sum_{i=1}^N w_{m,i} \exp(-\alpha_m y_i \phi_m(x_i)) = 2 \sqrt{\epsilon_m (1 - \epsilon_m)}$

每轮的归一化因子 $Z_m$ 控制了训练误差的变化。
由于 $Z_m < 1$ ，因此训练误差随着 $M$ 增加呈指数级下降。

ii、测试误差的推导

(1) 测试误差公式

测试误差定义为：

$\text{ERR}_{\text{test}} = \frac{1}{N_{\text{test}}} \sum_{i=1}^{N_{\text{test}}} \mathbb{I}(y_i \neq \text{sgn}(f(x_i)))$

其中 $f(x_i) = \sum_{m=1}^M \alpha_m \phi_m(x_i)$ 是加权分类器的输出。

由于无法直接优化测试误差，我们通过 Margin 来分析其变化。

(2) 引入 Margin 的概念

Margin 定义为：

$\text{Margin}(x_i) = y_i \cdot f(x_i)$

其中：

$\text{Margin}(x_i) > 0$ 表示分类正确；
$\text{Margin}(x_i) \leq 0$ 表示分类错误；
Margin 越大，分类的置信度越高。

Margin 与测试误差的关系：

$\text{ERR}_{\text{test}} \approx \mathbb{P}(\text{Margin}(x_i) \leq 0)$

(3) Margin 的分布变化

图中数据表明：

Minimum Margin 随着迭代轮数 $M$ 增加而增大： $\text{Minimum Margin}_{M=5} = 0.14, \quad \text{Minimum Margin}_{M=1000} = 0.55$
当 Margin 全部大于 0.5 时，测试误差接近最小（在 $M=1000$ 时， $\text{ERR}_{\text{test}} = 3.1\%$ ）。

这表明，随着 $M$ 增加，AdaBoost 会逐步增大所有样本的 Margin，提升分类器的置信度。

iii、Margin 优化的数学推导

(1) 训练误差的指数形式

训练误差可以写成：

$\mathcal{L}_{\text{exp}} = \sum_{i=1}^N w_i \exp(-y_i f(x_i))$

其中权重 $w_i$ 的更新为：

$w_{m+1, i} = \frac{w_{m, i} \exp(-\alpha_m y_i \phi_m(x_i))}{Z_m}$

将总误差展开：

$\mathcal{L}_{\text{exp}} = \prod_{m=1}^M Z_m$

这表明，Margin 的优化等价于最大化 $Z_m$ 的分布范围。

(2) Margin 的优化目标

Margin 的下界通过每轮弱学习器的权重 $\alpha_m$ 决定：

$\alpha_m = \frac{1}{2} \ln\left(\frac{1 - \epsilon_m}{\epsilon_m}\right)$

因此 Margin 的变化率为：

$\Delta \text{Margin} \propto \alpha_m = \ln\left(\frac{1 - \epsilon_m}{\epsilon_m}\right)$

当 $\epsilon_m$ 较小时， $\alpha_m$ 较大，Margin 增加较快。

(3) 泛化能力的数学分析

通过公式可以发现：

当 $Z_m$ 越小：

每轮的优化幅度越大；

Margin 分布集中于正值范围，泛化性能更好。

当 $M$ 增加时：

$Z_m = 2\sqrt{\epsilon_m(1 - \epsilon_m)} < 1$ 确保训练误差持续下降；

由于测试数据中的 Margin 逐渐增大，测试误差趋于稳定而不再下降。

iv、结论与总结

训练误差：
- 随着迭代轮次 $M$ 增加，训练误差以指数速度下降。
- 训练误差上界由 $\prod_{m=1}^M Z_m$ 控制， $Z_m < 1$ 。
测试误差：
- 测试误差与样本的 Margin 分布相关。
- 随着迭代增加，Minimum Margin 持续增大，测试误差趋于稳定。
优化目标：
- AdaBoost 的优化目标是最大化 Margin，而非单纯地最小化训练误差。

v、问题：测试误差是否会因 M 增加而增大吗？

(1) 泛化误差的上界

测试误差的泛化上界由以下公式给出：

$\text{ERR}_{\text{test}} \leq \text{ERR}_{\text{train}} + \mathcal{O}\left(\sqrt{\frac{M \log N}{N}}\right)$

其中：

 $M$ 是迭代次数；

$N$ 是样本数。

随着 $M$ 增加，第二项 $\mathcal{O}\left(\sqrt{\frac{M \log N}{N}}\right)$ 会增大。这说明 泛化误差可能随 $M$ 的增加而增大，特别是当 $M$ 很大时。

(2) Margin 的作用

Margin 是 AdaBoost 泛化能力的关键因素：

$\text{Margin}(x_i) = y_i \cdot f(x_i) = y_i \cdot \sum_{m=1}^M \alpha_m \phi_m(x_i)$

其中 $\alpha_m = \frac{1}{2} \ln\left(\frac{1 - \epsilon_m}{\epsilon_m}\right)$ 。

如果 $M$ 增大，Margin 分布会逐渐向正值集中，从而增强模型的分类置信度。
然而，过大的 $M$ 可能会导致某些噪声样本的权重过高，影响模型的泛化性能。

（3）实验观察

从片子中的实验数据可以得出以下规律：

训练误差 随着 $M$ 增加迅速下降至 0。
测试误差 在早期（如 $M = 5$ 到 $M = 100$ ）快速下降，但在 $M$ 很大时（如 $M = 1000$ ）趋于稳定。

实际数据总结

# Rounds ( $M$ )	Train Error	Test Error
5	0.0	8.4
100	0.0	3.3
1000	0.0	3.1

测试误差在 $M$ 增加到一定程度（例如 $M = 100$ ）后基本不再显著变化，而没有出现明显的过拟合。
这表明 AdaBoost 不容易出现测试误差随 $M$ 增加而增大的现象，这是其与其他模型（如深度学习模型）的重要区别。

（4）为什么 AdaBoost 的测试误差不容易增大？

最大化 Margin 的优化目标

AdaBoost 通过优化指数损失函数，间接最大化所有样本的 Margin，而 Margin 是测试误差的关键影响因素：

Margin 越大，分类器的泛化能力越强。
随着 $M$ 增加，Minimum Margin 会逐渐增大，从而减少低置信度样本对泛化性能的影响。

弱学习器的局限性

每轮弱学习器（如决策树桩）的模型复杂度有限，因此即使 $M$ 很大，最终模型的复杂度增长也较为缓慢。

噪声的鲁棒性

虽然权重调整可能放大噪声样本的影响，但 AdaBoost 并非直接拟合噪声样本，而是通过加权优化整体分类性能。因此，它对噪声的敏感性较低。

（5）结论

从理论和实验上看，AdaBoost 的测试误差不容易因为 $M$ 的增加而显著增大，具体结论如下：

早期阶段：测试误差快速下降，因为模型逐步优化分类边界。
中后期阶段：测试误差趋于稳定，训练误差继续下降但对泛化性能影响较小。
极端情况：如果 $M$ 极大且样本中存在大量噪声数据，可能会导致测试误差略微增加，但这种情况不常见。

因此，在实际应用中，可以选择适当的 $M$ （如通过交叉验证）来获得最优的测试误差。

3、Gradient Boosting Decision Tree (GBDT)

（1）Boosting 的一般框架

核心框架：

初始化：
- 初始模型 $f_0(x)$ 通常是简单的基学习器输出（如目标均值）。
迭代构建：
- 在每一轮中：
  - 寻找一个弱学习器 $\phi_m(x)$ ，使其能够改进当前模型 $f_{m-1}(x)$ 。
  - 更新模型： $f_m(x) = f_{m-1}(x) + \alpha_m \phi_m(x)$ , 其中 $\alpha_m$ 是弱学习器的权重。
返回最终模型： $f(x) = f_M(x)$ .

总结：

Boosting 的本质是通过逐步加法的方式优化目标函数。
每一轮迭代中，新的弱学习器的任务是补充当前模型的不足。

（2）Gradient Boosting 的基本思想

核心思想：沿损失函数对于模型的梯度找到（拟合）一个个新的模型，用拟合出来的模型乘以学习率更新我们的模型，经过一步步更新最终得到一个很好的最终模型。

目标：

Gradient Boosting 的目标是最小化损失函数：

$\mathcal{J}(f) = \sum_{i=1}^N L(y_i, f(x_i))$

其中 $L(y, f)$ 是一个可微的损失函数。

改进过程：

假设当前模型为 $f_{m-1}(x)$ ，新的模型更新为：
$f_m(x) = f_{m-1}(x) - \eta \cdot \left[\frac{\partial \mathcal{J}(f)}{\partial f(x)} \right]_{f = f_{m-1}(x)}$
即沿着负梯度方向更新。
梯度的负方向对应当前模型在损失函数上的最大改进方向。
- 用弱学习器 $\phi_m(x)$ 来拟合负梯度： $r_{i, m} = -\left[\frac{\partial L(y_i, f(x_i))}{\partial f(x_i)}\right]_{f=f_{m-1}(x)}$
- 将弱学习器加入模型： $f_m(x) = f_{m-1}(x) + \eta \cdot \phi_m(x)$ .

（3）Gradient Boosting Algorithm

具体算法步骤如下：

初始化模型：
$f_0(x) = \arg \min_f \frac{1}{N} \sum_{i=1}^N L(y_i, f(x_i))$
例如，对于平方误差，初始值是目标值的均值。
迭代更新：
- 计算残差（负梯度）： $r_{i, m} = -\left[\frac{\partial L(y_i, f(x_i))}{\partial f(x_i)}\right]_{f=f_{m-1}(x)}$
- 使用弱学习器拟合残差： $\phi_m(x) = \arg \min_\phi \sum_{i=1}^N \left(r_{i, m} - \phi(x_i)\right)^2$
- 更新模型： $f_m(x) = f_{m-1}(x) + \eta \cdot \phi_m(x)$
输出最终模型：
$f(x) = f_M(x)$ ，迭代M次后的模型。

（4）从梯度下降到 Gradient Boosting

梯度下降：参数空间中的优化

梯度下降在参数空间中更新：
$\theta_t = \theta_{t-1} - \eta \cdot g_t$
其中 $g_t$ 是损失函数的梯度。
参数更新公式可以写成：
$\theta = \sum_{t=1}^T \Delta \theta_t$
即累计每次更新的增量。

Gradient Boosting：函数空间中的优化

类似梯度下降，Gradient Boosting 在函数空间中更新模型：
$f_t(x) = f_{t-1}(x) - \eta \cdot g_t(x)$
其中 $g_t(x)$ 是损失函数对 $f(x)$ 的梯度。
最终模型为：

$F(x) = \sum_{t=1}^T \eta \cdot h_t(x)$

其中 $h_t(x)$ 是第 $t$ 棵弱学习器。

总结：

Gradient Boosting 的本质是将梯度下降从参数优化扩展到函数优化。

（5）不同损失函数的应用

分类问题：负 log 似然损失

损失函数： $L(y, f(x)) = \ln(1 + \exp(-y \cdot f(x)))$
梯度（残差）： $r_{i, m} = y_i - \sigma(f(x_i))$ , 其中 $\sigma(z) = \frac{1}{1 + \exp(-z)}$ 是 Sigmoid 函数。

回归问题：L2 损失

损失函数： $L(y, f(x)) = \frac{1}{2} (y - f(x))^2$
梯度（残差）： $r_{i, m} = y_i - f_{m-1}(x_i)$

总结：

GBDT 的灵活性体现在其可以适应多种损失函数，分类和回归问题均适用。

（6）L2Boosting 的具体实现

L2Boosting 是 Gradient Boosting 的特例，使用平方误差作为损失函数。

步骤：

损失函数：
$L(y, f(x)) = \frac{1}{2} (y - f(x))^2$
初始化：
$f_0(x) = \bar{y}$
其中 $\bar{y}$ 是目标值的均值。
残差计算：
- 第 $m$ 步的负梯度为： $r_{i, m} = y_i - f_{m-1}(x_i)$
拟合残差：
- 使用弱学习器拟合残差 $r_{i, m}$
更新模型：
$f_m(x) = f_{m-1}(x) + \eta \cdot \phi_m(x)$

总结：

L2Boosting 实际上是对残差的递归拟合，最终模型收敛到最小化平方误差的解。

弱学习器 $\phi_m(x)$ ：学习残差（负梯度）与输入之间的关系，最后残差倾向于白噪声，没有模式，无需再学习器

（7）Gradient Boosting 回归的例子

见附录2

（8）LogitBoosting

i、LogitBoosting 的任务目标

多分类问题定义

假设有 $K$ 类，分类标签 $y \in \{1, 2, \dots, K\}$ ，独热编码表示为：
$y = (0, 0, \dots, 1, \dots, 0)^\top$
其中第 $k$ 个分量为 1 表示当前样本属于第 $k$ 类。
$f(x) = (f_1(x), f_2(x), \dots, f_K(x))$ 表示每个类别的得分。

交叉熵损失函数

分类问题的目标是最小化交叉熵损失：

$L(f(x), y) = -\sum_{k=1}^K y_k \ln p_k$

其中：

$p_k$ 是样本属于第 $k$ 类的预测概率；
$p_k$ 通过 Softmax 函数计算： $p_k(x) = \frac{\exp(f_k(x))}{\sum_{j=1}^K \exp(f_j(x))}$ .

ii、损失函数梯度的计算（关于模型的梯度）

损失对 $f_m(x)$ 的导数

对于第 $m$ 类，交叉熵损失对 $f_m(x)$ 的梯度为：

$\frac{\partial L(f(x), y)}{\partial f_m} = -\sum_{k=1}^K y_k \frac{\partial \ln p_k}{\partial f_m}$

$p_k$ 的导数（Softmax 梯度）：
$\frac{\partial p_k}{\partial f_m} = \begin{cases} p_m(1 - p_m), & \text{if } k = m, \\ -p_k p_m, & \text{if } k \neq m. \end{cases}$
代入梯度公式：
$\frac{\partial L(f(x), y)}{\partial f_m} = -\sum_{k=1}^K y_k \frac{\partial \ln p_k}{\partial f_m}$
展开为：
$\frac{\partial L(f(x), y)}{\partial f_m} = -\sum_{k=1}^K y_k \frac{1}{p_k} \cdot \frac{\partial p_k}{\partial f_m}$
化简后得到：

$\frac{\partial L(f(x), y)}{\partial f_m} = p_m - y_m$

iii、LogitBoosting 的训练过程

(1) 初始化

所有类别的得分初始为 0：

$f_{0,k}(x) = 0, \quad k = 1, 2, \dots, K$

初始预测概率均为均匀分布：

$p_k(x) = \frac{1}{K}, \quad k = 1, 2, \dots, K$

(2) 第 $m$ 步更新

在每一轮迭代中：

计算负梯度（残差）：
$g_{m,i} = -\frac{\partial L(f_m, y)}{\partial f_m} = y_{m,i} - p_{m,i}$
其中 $y_{m,i}$ 是样本属于第 $m$ 类的真实标签， $p_{m,i}$ 是第 $p_{m,i}$ 类的预测概率。
拟合残差：用弱学习器（如回归决策树）拟合 $\{x_i, g_{m,i}\}$ ，得到更新值 $\phi_m(x)$ 。
更新模型：
$f_m(x) = f_{m-1}(x) + \eta \cdot \phi_m(x)$
其中 $\eta$ 是学习率。
更新预测概率：
$p_k(x) = \frac{\exp(f_k(x))}{\sum_{j=1}^K \exp(f_j(x))}$

(3) 收敛条件

当残差 $g_{m,i}$ 趋于 0 或损失函数 $L(f(x), y)$ 不再显著下降时停止迭代。

iv、Shrinkage（学习率）

学习率的作用

在每一轮中，更新模型时引入学习率 $\eta$ ：

$f_m(x) = f_{m-1}(x) + \eta \cdot \phi_m(x)$

其中 $0 < \eta \leq 1$ 。

较小的学习率（如 $\eta = 0.01$ ）使模型更新更缓慢，减少过拟合的风险。
较小的学习率需要更多的弱学习器以达到相同的效果。

优势

学习率可以控制模型复杂度，提升测试集上的泛化性能。

v、LogitBoosting 的应用场景

LogitBoosting 主要用于 多分类问题，其优点包括：

灵活性：
- 可以处理多分类任务，并支持 Softmax 损失。
高效性：
- 基于梯度更新，每轮拟合残差的过程简单明了。
鲁棒性：
- 通过 Shrinkage 减少过拟合风险。

vi、LogitBoosting 总结

LogitBoosting 的核心是：

使用 Softmax 函数预测多分类概率；
最小化交叉熵损失，梯度形式简单为 $p_m - y_m$ ；
每轮迭代中，拟合残差更新模型，同时更新预测概率；
通过引入学习率（Shrinkage）提升泛化性能。

4、XGBoost

（1）XGBoost 简介

名称：Extreme Gradient Boosting。
特点：
- 自定义损失函数：通过二阶 Taylor 展开优化任意可导损失函数。
- 正则化：叶子节点数量和叶子节点权重的正则化项提升模型泛化能力。
- 高效建树：
  - 支持分裂点近似搜索，减少计算量。
  - 内置稀疏特征处理和缺失值处理机制。
- 并行计算：提升训练速度。
- 内存缓存：优化大规模数据集的训练效率。

（2）损失函数的二阶近似

XGBoost 使用二阶 Taylor 展开对损失函数 $L$ 进行近似，公式为：

$f(x + \Delta x) \approx f(x) + f'(x)\Delta x + \frac{1}{2} f''(x)(\Delta x)^2$

在第 $m$ 轮迭代中：

定义：
- 一阶梯度： $g_{m,i} = \frac{\partial L(f, y)}{\partial f}$ 。
- 二阶梯度： $h_{m,i} = \frac{\partial^2 L(f, y)}{\partial f^2}$ 。
展开：

$L(y_i, f_{m}(x_i) ) \\ =L(y_i, f_{m-1}(x_i) + \phi(x_i)) \\ \approx L(y_i, f_{m-1}(x_i)) + g_{m,i} \phi(x_i) + \frac{1}{2} h_{m,i} \phi(x_i)^2$

这一公式为树的优化提供了数学基础。

（3）常用损失函数的梯度和 Hessian

i、L2 损失（回归任务）

$L(f(x), y) = \frac{1}{2} (f(x) - y)^2$

一阶梯度： $g_{m,i} = f_{m-1}(x_i) - y_i$ 。
二阶梯度： $h_{m,i} = 1$ 。

ii、交叉熵损失（分类任务）

$L(f_k(x), y) = -\sum_{k=1}^K y_k \ln p_k, \quad p_k = \frac{\exp(f_k)}{\sum_{j=1}^K \exp(f_j)}$

一阶梯度： $g_{m,i} = p_k(x_i) - y_k$ 。
二阶梯度： $h_{m,i} = p_k(x_i)(1 - p_k(x_i))$ 。

这些公式说明了如何根据具体任务计算梯度和 Hessian，用于优化树结构。

（4）正则项与模型复杂度

目标：通过正则化项控制树的复杂度，防止过拟合。
树的表达式： . 其中：
- $q$ ：结构函数，将输入映射到叶子节点。
- $w_{q(x)}$ ：叶子节点的权重。
正则化项（复杂度的定义）：
- $T$ ：叶子节点的数量（L1 正则化）。
- $w_t^2$ ：叶子节点权重平方和（L2 正则化）。

通过增加正则化项，模型更倾向于选择简单的树结构。

复杂度计算例子：

（5）树的目标函数

假设已知树的结构 $q(x)$ ，目标函数为：

$J(f) = \sum_{t=1}^T \left[G_t w_t + \frac{1}{2} (H_t + \lambda) w_t^2\right] + \gamma T$

其中：

$G_t = \sum_{i \in I_t} g_i$ ：叶子节点的梯度和。
$H_t = \sum_{i \in I_t} h_i$ ：叶子节点的 Hessian 和。

推导过程为：

通过对 $w_t$ 求导，得到最优叶子节点权重：

$w_t = -\frac{G_t}{H_t + \lambda}$

最终目标函数化简为：

$J(f) = -\frac{1}{2} \sum_{t=1}^T \frac{G_t^2}{H_t + \lambda} + \gamma T$

最佳的 $w$ 对应的目标函数 $J(f)$ ，可视为树的分数，分数越小的树越好！

（6）示例：树的分数计算

图片中的例子展示了如何计算树的分数：

每个样本计算梯度统计量 $g_i, h_i$
根据节点划分计算 $G_t, H_t$ ，每个节点的 $G_t, H_t$ 是节点中所以样本的 $g_i, h_i$ 之和。
分数计算： $\text{Obj} = -\sum_{j} \frac{G_j^2}{H_j + \lambda} + \gamma T$ . 分数越小，树结构越优。

（7）XGBoost 中回归树的学习策略

如何确定树的结构？

暴力枚举：
- 理论上，枚举所有可能的树结构，选择损失值最小的结构。
- 该问题属于 NP 难问题，计算不可行。
贪心算法：
- 每次尝试分裂一个叶节点。
- 计算分裂前后的目标函数增益，选择增益最大的分裂点。

XGBoost使用贪心算法，即每次分裂一个叶节点，且选择增益最大的分裂点。

（8）分裂增益的度量

比较不同算法的分裂指标

ID3 算法：信息增益。
C4.5 算法：信息增益比。
CART 算法：Gini 系数。
XGBoost 算法：使用梯度统计量计算目标函数的分数。

XGBoost 的分裂增益公式

分裂增益定义为目标函数的变化：

$\text{Gain} = \frac{1}{2} \left[\frac{G_L^2}{H_L + \lambda} + \frac{G_R^2}{H_R + \lambda} - \frac{(G_L + G_R)^2}{H_L + H_R + \lambda}\right] - \gamma$

$G_L, G_R$ ：左、右子节点的一阶梯度和。
$H_L, H_R$ ：左、右子节点的二阶梯度和。
$\lambda$ ：正则化系数，防止过拟合。
$\gamma$ ：叶子节点分裂的惩罚项。

（9）精确贪心算法详细分析

贪心算法：每次分裂一个叶节点，且选择增益最大的分裂点。

i、精确贪心算法的具体示例

共4个样本：A、B、C、D

示例数据中有 4 个样本 $A, B, C, D$ ，对特征值 age 逐一计算分裂点。
增益计算：
- 对分裂点 age < b：

$G_L = g_A, \quad G_R = g_B + g_C + g_D$

$H_L = h_A, \quad H_R = h_B + h_C + h_D$

$\text{Gain} = \frac{1}{2} \left[\frac{G_L^2}{H_L + \lambda} + \frac{G_R^2}{H_R + \lambda} - \frac{(G_L + G_R)^2}{H_L + H_R + \lambda}\right] - \gamma$

选择增益最大的分裂点作为结果。

ii、算法描述

输入：
- 样本集合 $I$ 、特征维度 $D$ 。
步骤：
- 对每个特征维度 $k$ ，对特征值进行排序。
- 逐一计算分裂点，使用增益公式选择最佳分裂点。
输出：
- 增益最大的分裂点。

iii、时间复杂度

对于深度为的树：
- 排序时间为 $O(N \log N)$ ，其中 $N$ 为样本数。
- 每次分裂的计算时间为 $O(KDN \log N)$ ，其中 $D$ 为特征数。

iv、预排序算法的优缺点

优点

能够精确地找到最佳分裂点。
对特征值排序后，可重复使用。

缺点

内存消耗大：
- 特征值和索引需要保存两倍于训练数据的存储空间。
时间消耗大：
- 每次分裂点的增益计算需要扫描所有可能的分裂点。
对缓存不友好：
- 特征值访问的随机性导致较多的缓存未命中（Cache Miss）

（10）直方图近似算法

直方图近似算法是为了弥补贪心算法中的缺点。贪心算法中要对所有可能分裂点进行增益评估，精确搜索分裂点的代价过高。直方图近似算法通过减少候选分裂点的数量，优化分裂点选择过程。

i、背景与概述

当数据量太大，无法完全装载到内存时，精确搜索分裂点的代价过高。直方图近似算法通过减少候选分裂点的数量，优化分裂点选择过程。
核心思路：
- 根据特征值的分布构建直方图，划分连续特征为固定数量的区间（Bin）。
- 计算每个区间内的梯度和二阶梯度的统计量。
- 从有限的候选分裂点中选择最佳分裂点。

ii、分裂点选择方式

全局近似：
- 在构造树的初始阶段提出所有候选分裂点。
- 每一层次采用相同的候选分裂点。
- 优点：计算次数少，候选点固定。
- 缺点：对深层次的树可能不够精确。
局部近似：
- 每次分裂时重新生成候选分裂点。
- 优点：适用于深层树的优化，分裂更加精确。
- 缺点：计算代价较高。

iii、示例：直方图近似分裂点

步骤：
1. 对特征值进行排序。
2. 使用分位点（如 1/3 和 2/3 分位点）作为候选分裂点。
3. 统计每个 Bin 内的样本数量、梯度和二阶梯度。
4. 从候选分裂点中选择增益最大的分裂点。
结果：直方图将原始特征值的 6 个可能分裂点减少为 2 个候选点，显著降低了计算复杂度。

iv、优势与局限性

优势

存储效率：直方图方法将特征离散化，每个 Bin 仅存储一个统计值，节省内存。
计算效率：仅计算候选分裂点的增益，避免对所有特征值进行计算。
无需排序：离散化过程不需要对每个特征值排序。

局限性

对于 长尾分布 的特征，直方图可能利用不足，导致分裂点选择不够精确。
- 通过对特征值进行对数变换（Log Transform），将长尾分布压缩为对称分布，提升了直方图的利用率。如下图所示：

（11）稀疏特征处理

i、背景

在实际任务中，稀疏特征非常常见，可能来源于：

缺失数据：如表格型数据中的空值。
人工设计特征：如 One-Hot 编码产生的大量零值。

ii、XGBoost 的处理方法

视为缺失值：将稀疏特征统一视为缺失值。
缺省方向：
- 在每个树节点中设置缺省方向（左或右）。
- 通过增益计算自动确定缺省方向。
- 仅访问非缺失数据，减少计算开销。

iii、算法细节

目标：在树的每个分裂节点上选择最佳缺省方向，使得分裂增益最大。
步骤：
1. 统计非缺失数据的梯度和 Hessian。
2. 计算缺省方向为左或右时的增益。
3. 选择增益最大的缺省方向。

iv、优势

高效性：只访问非缺失数据，复杂度与非缺失数据量线性相关。
实践效果：
- 在 Allstate-10K 数据集上，稀疏特征处理的速度比基本算法快约 50 倍。

v、示例：稀疏特征分裂点选择

数据包含缺失值或稀疏特征。
样本通过是否缺失进行分组。
缺省方向通过增益公式计算后自动确定。

（12）XGBoost的例子

见附录3

（13）关于XGBoost 的思考

见附录4

（14）XGBoost 与GBDT的相同点

1. 算法框架

目标一致：两者都基于梯度提升算法（Gradient Boosting），通过逐步拟合损失函数的梯度来优化模型。
弱学习器：两者的弱学习器通常是 CART 决策树。
模型更新：模型通过累加当前树的预测值（弱学习器是基于当前树预测性能构建的。）进行更新：
- $F_t(x)$ ：模型在第 $t$ 轮的预测值。
- $f_t(x)$ ：第 $t$ 棵弱学习器。
- $\eta$ ：学习率，控制每棵树的影响。

2. 使用梯度信息

两者都计算损失函数的负梯度，作为弱学习器的拟合目标。
- 梯度 ( $g_i$ )： $g_i = \frac{\partial L(y_i, F_{t-1}(x_i))}{\partial F_{t-1}(x_i)}$
都使用基于梯度的优化思想，逐步减少模型误差。

3. 损失函数

都支持多种损失函数（如均方误差、对数损失等），并允许用户自定义损失函数。

4. 加法模型

两者都使用加法模型将弱学习器的输出累加，逐步逼近目标值。

（15）XGBoost 与GBDT的不同点

1. 模型实现层面

方面	GBDT	XGBoost
优化方式	只使用一阶导数（梯度）优化。	使用一阶导数（梯度）和二阶导数（曲率）进行优化，更精确。
正则化	没有显式的正则化项。	包含 L1 和 L2 正则化项，控制模型复杂度，防止过拟合。
损失函数展开	使用一阶梯度展开优化目标函数。	使用二阶泰勒展开优化目标函数，加入曲率信息。
叶子节点权重	通过经验调整叶子节点权重。	直接用梯度和曲率计算叶子节点的权重： $w_j = -\frac{\sum_{i \in j} g_i}{\sum_{i \in j} h_i + \lambda}$

2. 性能优化

方面	GBDT	XGBoost
并行化	不支持并行计算，每次迭代串行完成。	支持特征并行和树构建并行，大幅提高计算效率。
分裂点查找	无特别优化，直接按每个特征逐一计算。	特征按块分裂（Block-based结构），提高计算效率，同时充分利用缓存。
缺失值处理	需要用户自行处理缺失值。	自动处理缺失值，在树分裂时动态确定缺失值的方向。
内存效率	对大数据支持较弱。	使用列块存储（Column Block Storage），高效处理大规模稀疏数据集。
分布式训练	不支持。	支持分布式计算，能够在多机多核上训练大规模数据集。

3. 灵活性

方面	GBDT	XGBoost
弱学习器	仅支持 CART 决策树。	支持多种弱学习器（CART、线性模型等）。
自定义损失函数	支持有限的损失函数。	用户可以自由定义目标函数，只要可微即可（需要提供一阶和二阶导数）。
正则化控制	没有显式的正则化控制。	显式支持 L1 和 L2 正则化参数，用户可灵活调节正则化强度。

4. 工程实现细节

方面	GBDT	XGBoost
编程接口	传统 GBDT 的实现较少支持高级接口。	提供多种编程语言接口（Python、R、C++、Java 等），且对常见的机器学习框架（如 scikit-learn）支持良好。
速度	通常比 XGBoost 慢，尤其在大规模数据上。	通过并行化、多线程优化和高效内存管理，XGBoost 在速度上显著快于传统 GBDT。

5. 使用场景

场景	GBDT	XGBoost
小数据集	适合，简单实现即可满足需求。	适合，但性能优势不明显。
大规模数据集	性能有限。	表现出色，支持分布式计算。
模型复杂度控制要求高的场景	不推荐，缺乏正则化手段。	推荐，支持正则化和子采样等。
Kaggle/比赛等极致性能需求	通常不被选用。	是许多比赛的首选算法。

6. 性能表现

训练速度：
- XGBoost 的优化和并行化使其训练速度远快于传统 GBDT。
- 特别是在大数据场景下，XGBoost 的分布式能力显得尤为突出。
抗过拟合能力：
- GBDT 没有显式正则化，可能容易过拟合，尤其在树深较大时。
- XGBoost 的 L1 和 L2 正则化、子采样等机制显著提高了抗过拟合能力。
对稀疏数据的支持：
- GBDT 对缺失值和稀疏数据支持较差，需要用户自行处理。
- XGBoost 自动处理缺失值，并对稀疏数据有专门优化，性能表现更优。
预测精度：
- XGBoost 在许多任务（如 Kaggle 比赛）中表现优异，往往较传统 GBDT 更精确。

5、LightGBM

（1）LightGBM 的核心特点

i、定义与优点

定义： LightGBM 是微软开发的 GBDT 算法框架，支持高效并行训练。
主要优点：
- 更快的训练速度。
- 更低的内存消耗。
- 分布式支持，能处理海量数据。

（2）基于直方图的分裂算法

i、核心思想

直方图构建：
- 将连续特征值离散化为 $K$ 个整数桶（Bins）。
- 遍历数据时，根据离散值的索引在直方图中累积统计量。
- 基于这些统计量，寻找最佳分裂点。
直方图存储：
- 特征值的直方图可以大幅减少存储需求，例如存储为 256 个 Bin，仅需 8 bit。

ii、优缺点

优点：

存储优化：只需存储每个 Bin 的统计量。
计算优化：无需对每个样本逐一计算增益，提升效率。

缺点：

Histogram 算法不能找到精确的分割点，训练误差没有预排序算法好。
但从实验结果来看， Histogram 算法在测试集的误差预排序算法差异并不是很大，甚至有时候效果更好。实际上可能决策树对于分割点的精确程度并不太敏感，而且较“粗”的分割点也自带正则化的效果。

iii、直方图算法的计算速度

直方图计算的优化来源于：
- 做差加速：
  - 子节点的直方图可以通过父节点直方图减去兄弟节点的直方图快速得到。
- 减少样本数 #data ↓ （基于梯度的单边采样）：
  - 通过单边采样等技术减少参与计算的样本数。
- 减少特征数 #feature ↓ （互斥特征捆绑）：
  - 使用互斥特征捆绑（EFB），合并稀疏的互斥特征。

（3）直方图算法加速——做差加速

Histogram做差加速：一个叶子的直方图可以由它的父亲节点的直方图与它兄弟的直方图做差得到。

通常构造直方图，需要遍历该叶子上的所有数据。

直方图做差仅需遍历直方图的 $K$ 个桶。利用这个方法，LightGBM 可以在构造一个叶子的直方图后，可以用非常微小的代价得到它兄弟叶子的直方图，在速度上可以提升一倍。

（4）直方图算法加速——基于梯度的单边采样

i、核心思想

保留对损失函数影响较大的样本，丢弃不重要的样本：
- 梯度大的样本：保留所有绝对值大的梯度样本（前 $a\%$ 的数据）。
- 梯度小的样本：随机采样其余梯度小的样本（后 $1-a\%$ 的数据）。

ii、算法步骤

根据梯度的绝对值对样本降序排序。
保留梯度大的前 $a\%$ 样本。
随机从剩余梯度小的样本中采样 $b\%$ 样本。

iii、优势

减少样本数，显著降低计算成本。
保证梯度大的样本不丢失，提升模型拟合效果。

（5）直方图算法加速——互斥特征捆绑

i、背景

高维数据中，许多特征是互斥的（例如 One-hot 编码）。
互斥特征在同一行中往往只有一个非零值。

ii、EFB 的实现

目标：
- 将互斥特征捆绑为一个特征，降低特征数量。
方法：
1. 计算特征间的冲突度（同一行非零值的重叠数量）。
2. 使用图着色算法将互斥特征分配到不同的特征组。

iii、优势

降低特征维度，减少内存和计算需求。
提升大规模数据的训练效率。

（6）带深度限制的按叶子生长策略 (Leaf-wise Growth)

i、传统的按层生长 (Level-wise Growth)

特点：
- 每次同时分裂同一层的所有叶子节点。
- 树结构更加均衡，便于防止过拟合。

ii、LightGBM 的按叶子优先生长策略

特点：
- 每次选择当前增益最大的叶子节点进行分裂。
- 优势：
  - 优化增益最大化，提升模型拟合能力。
  - 避免不必要的节点分裂。
- 劣势：
  - 树结构可能不均衡，容易导致过拟合。

iii、深度限制

为避免过拟合，LightGBM 在 Leaf-wise Growth 中加入深度限制，确保模型的泛化能力。

（7）直接支持类别型特征

i、背景问题

在传统的机器学习模型中，类别型特征（Categorical Features）通常需要进行预处理，如 One-hot 编码 或 目标编码。然而，这些方法存在以下问题：

维度爆炸：
- One-hot 编码会将一个类别型特征扩展为多个二元特征，导致维度升高。
计算效率低下：
- 高维稀疏特征矩阵会增加模型训练的内存和计算需求。
信息利用不足：
- One-hot 编码将类别特征视为独立的属性，未充分利用类别间的排序和频率信息。

ii、LightGBM 对类别型特征的优化

(1) 直接支持类别型特征

LightGBM 无需将类别型特征转换为 0/1 编码，而是直接输入原始类别型特征值。
通过改进的决策树分裂算法，LightGBM 能够对类别型特征进行高效处理。

(2) 增强的决策树算法

在类别型特征的分裂规则中，LightGBM 会直接比较类别的 增益值 来确定分裂点：

每个类别被视为一个单独的分裂候选。
按类别的增益值排序，逐一合并类别，找到增益最大的分裂点。

iii、分裂规则

(1) 分裂点选择

假设类别型特征 $X$ 有 $K$ 个类别，LightGBM 的分裂规则如下：

按照类别特征的增益值 $\frac{G^2}{H + \lambda}$ 降序排列：

其中：
- $G_L, G_R$ ：左、右子节点的一阶梯度和。
- $H_L, H_R$ ：左、右子节点的二阶梯度和。
- $\lambda$ ：正则化参数。
- $\gamma$ ：分裂惩罚项。
将类别型特征的增益值逐一合并，选择最大增益的分裂点。

(2) 直方图优化

LightGBM 使用直方图算法对类别特征统计一阶梯度和二阶梯度：
- 对类别的增益值进行排序。
- 根据直方图的统计结果高效计算增益。

iv、示例

假设一个类别型特征 $X$ 有 3 个类别 $A, B, C$ ，数据如下：

$X = \{A, A, B, B, B, C, C\}$ 。
梯度统计：
- $G_A = 6, G_B = 10, G_C = 4$ 。
- $H_A = 3, H_B = 5, H_C = 2$ 。

分裂增益计算

按增益值排序，计算：
增益 $= \frac{G_L^2}{H_L + \lambda} + \frac{G_R^2}{H_R + \lambda} - \frac{(G_L + G_R)^2}{H_L + H_R + \lambda}$
比较不同的分裂方式：
- 分裂为 $X \in \{A\}$ 和 $X \in \{B, C\}$ 。
- 分裂为 $X \in \{A, B\}$ 和 $X \in \{C\}$ 。
- 分裂为 $X \in \{A, C\}$ 和 $X \in \{B\}$ 。

最终，选择增益最大的分裂点。

v、LightGBM 的优势

(1) 高效性

避免了 One-hot 编码带来的维度爆炸问题，显著降低内存和计算开销。

(2) 分裂精度

直接在类别特征上进行增益计算，充分利用类别间的统计信息，避免 One-hot 编码对类别之间关系的丢失。

(3) 处理稀疏数据

对于类别数量较多但数据稀疏的场景，LightGBM 能够自动优化分裂过程，提高模型的鲁棒性。

vi、实际应用场景

(1) 分类问题

示例：用户行为预测中的性别、城市等类别特征。
直接输入类别特征，无需独热编码。

(2) 推荐系统

示例：商品推荐中的商品类别、用户群体等离散型特征。
LightGBM 能高效处理数千个类别的特征。

vii、优势与局限性

优势

减少内存和计算消耗。
避免 One-hot 编码带来的特征维度膨胀。
支持类别特征的自动分裂规则，优化模型性能。

局限性

对类别数量极多（如数百万级）的特征，可能存在分裂效率下降的问题。

6、CatBoost

（1）类别型特征的挑战

i、传统编码方法

独热编码 (One-hot Encoding)：
- 将类别型特征转化为多维二进制特征。
- 问题：
  - 高维特征矩阵占用大量内存。
  - 类别特征之间的关系被忽略。
目标编码 (Target Encoding)：
- 使用目标值（如分类任务中的标签 $y$ ）的统计信息对类别型特征进行编码。
- 问题：
  - 易发生信息泄漏（即，标签值影响模型输入），导致模型过拟合。

（2）CatBoost 的类别特征处理

CatBoost 针对类别特征的处理进行了优化，主要通过以下技术：

i、基于目标值的统计编码

CatBoost 不使用独热编码，而是基于目标值进行统计编码：

编码方式：

条件概率：
拉普拉斯平滑：为避免类别样本数量过少时编码不稳定，CatBoost 使用拉普拉斯平滑：

其中：

$\alpha$ ：平滑参数。
$C$ ：类别的先验概率。

ii、防止信息泄漏的有序编码

问题：目标值的统计信息可能造成信息泄漏。

原因：
- 编码时，直接使用当前数据集的目标值进行统计，导致模型可能“偷看”测试数据。

解决方案：

有序编码：
- 编码时仅使用“当前样本之前”的目标值进行统计。
- 模拟训练过程中的真实数据分布。
随机置换：
- 对数据进行随机排序，保证统计过程的随机性。

iii、防止过拟合的其他方法

加噪声：
- 在统计过程中加入一个拉普拉斯分布的随机噪声，避免单个数据点对统计结果的过大影响。
分箱计算：
- 将类别特征的统计信息分箱处理，减少计算开销。

iv、计算编码的实现方式

(1) 编码公式

(2) 解决方案总结

解决方案 1：保留当前样本，用其余样本计算概率：
- 适用于数据充足的场景。
解决方案 2：统计历史数据：
- 对当前样本的编码仅使用历史统计信息。
解决方案 3：加入随机噪声：
- 避免单个数据点的影响。
解决方案 4：随机置换 + 历史信息编码：
- 提高随机性，同时减少信息泄漏。

v、优势分析

(1) 高效处理类别特征

避免 One-hot 编码的高维特征问题。
基于目标值的统计编码能够充分利用类别间的分布信息。

(2) 防止信息泄漏

有序编码和随机置换策略避免了目标值对输入特征的污染。

(3) 降低过拟合风险

拉普拉斯平滑和噪声处理增强了模型的泛化能力。

(4) 内存和计算优化

分箱计算和统计信息缓存显著减少了计算开销。

iv、实践中的应用场景

分类问题：
- 用户行为预测中的性别、职业等类别特征。
回归问题：
- 包含大量类别型特征的数据（如商品分类）。
高维稀疏数据：
- 如搜索引擎中的查询词特征。

四、投票法

五、堆叠法

1、堆叠法的基本概念

（1）堆叠法的核心思想

层次模型：堆叠法分为两层或多层：
1. 第一层：包含多个基学习器（如 SVM、随机森林、LightGBM 等）。
2. 第二层：通过一个融合模型（如线性回归、逻辑回归）对第一层学习器的输出进行组合。
目标：
- 通过结合不同基学习器的优点，提升整体预测性能。

（2）与其他集成方法的对比

Bagging（如随机森林）：
- 使用相同模型的多次训练结果进行投票或平均。
Boosting（如 XGBoost）：
- 顺序训练多个模型，每个模型学习前一个模型的残差。
Stacking：
- 不同模型的输出作为新的特征进行融合。

2、堆叠法的工作流程

（1）第一层：基学习器

训练多个基学习器（如 SVM、随机森林、LightGBM）。
输入：
- 原始特征 XXX。
- 标签 yyy。
输出：
- 每个基学习器对训练集和测试集的预测值 fi(x)f_i(x)fi(x)。

（2）第二层：融合学习器

使用第一层基学习器的预测值作为新的输入特征。
训练一个简单的融合模型（如逻辑回归、线性回归、深度神经网络）。
最终输出为融合模型的预测结果。

3、堆叠法的两种实现方式

（1）类似交叉验证

流程：
1. 将训练集划分为 KKK 个子集，进行 KKK-折交叉验证。
2. 每个基学习器在 K−1K-1K−1 个子集上训练，在剩余子集上预测。
3. 将所有子集的预测结果拼接，作为融合模型的训练集特征。
优点：
- 能有效避免过拟合。
- 使用全部训练数据，提高基学习器的泛化能力。

（2）类似留出法

流程：
1. 从训练集中划分出一个小的留出集（probe set）。
2. 使用剩余数据训练基学习器，并对留出集进行预测。
3. 将留出集的预测结果作为融合模型的输入特征。
优点：
- 实现简单，计算开销小。
缺点：
- 留出集数据较少时，可能导致融合模型训练不足。

4、堆叠法的关键要素

（1）基学习器的选择

多样性：
- 基学习器应具有显著的差异性（如线性模型、非线性模型、树模型）。
性能强：
- 每个基学习器需要有足够的预测能力。
数量适中：
- 基学习器过多会导致融合模型的特征维度膨胀，增加过拟合风险。

（2）融合模型的选择

简单模型优先：
- 如逻辑回归、线性回归，避免模型过拟合。
强模型适配：
- 在高维数据中，可以尝试使用随机森林或神经网络作为融合模型。

（3）数据划分策略

交叉验证能更充分地利用数据，但计算成本高。
留出法简单高效，但可能导致数据不足。

5、堆叠法的优势与局限性

（1）优势

提升模型性能：
- 通过组合多个学习器的优点，提高整体模型的泛化能力。
灵活性：
- 可根据任务需求自由选择基学习器和融合模型。
减少单一模型的偏差：
- 不同模型的组合可以缓解单一模型的过拟合问题。

（2）局限性

计算开销高：
- 特别是在交叉验证的实现中，计算复杂度较大。
数据需求高：
- 数据不足时，融合模型可能无法有效训练。
模型调参复杂：
- 需要同时优化基学习器和融合模型的参数。

6、实际应用场景

Kaggle 比赛：
- 常用于解决结构化数据任务，通过堆叠多种模型获得最佳性能。
金融风险评估：
- 结合逻辑回归、随机森林和梯度提升决策树，提高预测准确性。
推荐系统：
- 在推荐排序任务中堆叠多种模型（如矩阵分解、树模型）提升效果。

六、⭐⭐全文总结⭐⭐

附录

1、d1的推导

公式 $d_1 = \sqrt{\frac{1 - \epsilon_1}{\epsilon_1}}$ 的推导过程如下：

背景

在 AdaBoost 中，每一轮迭代都会根据当前弱分类器的错误率 $\epsilon_1$ 更新样本的权重分布。权重更新的目标是：

对误分类样本增加权重，赋予更高的学习优先级。
对正确分类的样本减少权重，以降低其对下一轮训练的影响。

这里的 $d_1$ 是权重更新的缩放因子，用于区分误分类样本和正确分类样本。

目标公式

我们希望保证新的权重分布仍然是一个有效的概率分布：

$\sum_{i=1}^N w_{2, i} = 1$

同时，新权重应该满足以下约束：

对误分类的样本：

$w_{2, i} = w_{1, i} \cdot d_1$

对正确分类的样本：

$w_{2, i} = \frac{w_{1, i}}{d_1}$

关键约束

假设弱分类器的错误率为 $\epsilon_1$ ，即误分类样本的权重总和为：

$\epsilon_1 = \sum_{i=1}^N w_{1, i} \cdot \mathbb{I}(y_i \neq \phi_1(x_i))$

其中 $\mathbb{I}(\cdot)$ 是指示函数。

正确分类样本的权重总和为：

$1 - \epsilon_1 = \sum_{i=1}^N w_{1, i} \cdot \mathbb{I}(y_i = \phi_1(x_i))$

权重分布归一化

新权重分布的归一化常数 $Z_1$ 是：

$Z_1 = \sum_{i=1}^N w_{2, i}$

代入权重更新规则：

$Z_1 = \sum_{i=1}^N w_{1, i} \cdot d_1 \cdot \mathbb{I}(y_i \neq \phi_1(x_i)) + \sum_{i=1}^N w_{1, i} \cdot \frac{1}{d_1} \cdot \mathbb{I}(y_i = \phi_1(x_i))$

拆分求和得到：

$Z_1 = d_1 \cdot \epsilon_1 + \frac{1}{d_1} \cdot (1 - \epsilon_1)$

让权重归一化

为了使归一化常数 $Z_1 = 1$ ，令：

$d_1 \cdot \epsilon_1 + \frac{1}{d_1} \cdot (1 - \epsilon_1) = 1$

整理为二次方程：

$d_1^2 \cdot \epsilon_1 - d_1 + (1 - \epsilon_1) = 0$

最终结果

$d_1 = \sqrt{\frac{1 - \epsilon_1}{\epsilon_1}}$

这个结果体现了误分类率 $\epsilon_1$ 对权重调整的影响：当 $\epsilon_1$ 接近 0.5 时，权重变化较小；当 $\epsilon_1$ 较低或较高时，权重变化较大。

2、Gradient Boosting 回归的例子

（1）初始模型 f_0(x)

数据与初始化：

数据中列出了 $x = \text{Years}$ 和 $y = \text{Salary}$ 的关系。
损失函数选择为 MSE： $L(f(x), y) = \frac{1}{N} \sum_{i=1}^N (y_i - f(x_i))^2$
模型的初始化： $f_0(x) = \bar{y} = \frac{1}{N} \sum_{i=1}^N y_i = 134$ . 初始化值是 $y$ 的均值，这是最小化均方误差的最佳常数值。

初始残差：

残差（负梯度）： $r_i = y_i - f_0(x_i)$ 。
根据数据计算，初始残差为： $r = \{-52, -54, -31, -16, 38, -7, 70, 55, -35, 32\}$

（2）第一轮迭代 f_1(x)

拟合残差：

使用一个回归树拟合残差 $r = y - f_0(x)$ 。
决策树分裂规则：
- 分裂点：
  - 左子节点值： $-38.25$ （节点内残差的均值）。
- 分裂点：
  - 右子节点值： $25.5$ （节点内残差的均值）。
弱学习器输出： $\phi_1(x) = \begin{cases} -38.25, & \text{if } x \leq 23, \\ 25.5, & \text{if } x > 23. \end{cases}$

更新模型：

新的模型为： $f_1(x) = f_0(x) + \phi_1(x)$ .

更新后的预测值与残差：

根据新的模型 $f_1(x)$ 计算预测值： $f_1(x) = \{95.75, 95.75, 95.75, 95.75, 159.5, 159.5, 159.5, 159.5, 159.5, 159.5\}$
新的残差 $r = y - f_1(x)$ ： $r = \{-13.75, -15.75, 7.25, 22.25, 12.5, -32.5, 44.5, 29.5, -60.5, 6.5\}$

（3）第二轮迭代 f_2(x)

拟合新的残差：

对新的残差 $r = y - f_1(x)$ 进行拟合。
决策树分裂规则：
- 分裂点：
  - 左子节点值： $6.75$ 。
- 分裂点：
  - 右子节点值： $-27$ 。
弱学习器输出： $\phi_2(x) = \begin{cases} 6.75, & \text{if } x \leq 34, \\ -27, & \text{if } x > 34. \end{cases}$

更新模型：

新的模型为： $f_2(x) = f_1(x) + \phi_2(x)$

更新后的预测值与残差：

新的模型预测值： $f_2(x) = \{102.5, 102.5, 102.5, 102.5, 166.25, 166.25, 166.25, 166.25, 132.5, 132.5\}$
新的残差： $r = \{-20.5, -22.5, 0.5, 15.5, 5.75, -39.25, 37.75, 22.75, -33.5, 33.5\}$

（4）第三轮迭代 f_3(x)

拟合新的残差：

再次对残差进行拟合。
决策树分裂规则：
- 分裂点：
  - 左子节点值： $-10.0833$ 。
- 分裂点：
  - 右子节点值： $15.125$ 。
弱学习器输出： $\phi_3(x) = \begin{cases} -10.0833, & \text{if } x \leq 28, \\ 15.125, & \text{if } x > 28. \end{cases}$

更新模型：

新的模型为： $f_3(x) = f_2(x) + \phi_3(x)$ .

更新后的预测值与残差：

更新后的预测值： $f_3(x) = \{92.42, 92.42, 92.42, 92.42, 156.17, 156.17, 181.38, 181.38, 147.63, 147.63\}$
更新后的残差： $r = \{-10.42, -12.42, 10.58, 25.58, 15.83, -29.83, 22.62, 7.62, -15.63, 18.37\}$

（5）最终结果与分析

损失函数收敛

每轮模型的 MSE 分别为：
- $f_1$ : 875875875,
- $f_2$ : 692692692,
- $f_3$ : 540540540。
随着迭代次数增加，MSE 不断减小，模型拟合逐步优化。

弱学习器

每轮的弱学习器 $\phi_m(x)$ 通过拟合残差，逐步减小误差。
每个弱学习器拟合了数据中的局部模式，形成最终的强学习器。

残差趋于噪声

最后一轮的残差趋近于随机噪声（无模式），说明模型已经足够复杂，继续迭代的收益会减小。

（6）总结

核心机制：
- Gradient Boosting 的核心是逐步拟合残差，每轮的弱学习器对前一轮的误差进行修正。
- 通过累积弱学习器的输出，最终形成强大的预测模型。
模型改进过程：
- 每轮迭代中，MSE 减少，模型逐步捕捉数据的模式。
- 残差逐步减小并趋向于随机噪声。
应用场景：
- 示例展示了梯度提升在回归任务中的应用，可以推广到分类、排序等任务。

（7）决策树分裂规则

每轮迭代中，决策树的分裂规则是基于如何 最小化当前节点的残差（负梯度）的均方误差（MSE） 来决定的。

1.决策树分裂规则的核心目标

在 Gradient Boosting 中，每轮迭代都会拟合当前模型的残差 $r_i = y_i - f_{m-1}(x_i)$ 。
决策树分裂的目标是：选择一个分裂点，使得分裂后的均方误差（MSE）最小。

MSE 的定义：

假设当前节点有 $N$ 个样本 $(x_i, r_i)$ ，残差的均方误差为：

$\text{MSE} = \frac{1}{N} \sum_{i=1}^N \left(r_i - \hat{r}\right)^2$

其中 $\hat{r}$ 是该节点内样本残差的均值：

$\hat{r} = \frac{1}{N} \sum_{i=1}^N r_i$

分裂后的目标：

若分裂点为 $s$ ，将节点划分为两个子节点 $R_L(s)$ 和 $R_R(s)$ ：

$R_L(s)$ ：左子节点，包含所有 $x_i \leq s$ 的样本。
$R_R(s)$ ：右子节点，包含所有 $x_i > s$ 的样本。

分裂后的总均方误差为：

$\text{MSE}_{\text{split}} = \frac{|R_L(s)|}{N} \cdot \text{MSE}_{L}(s) + \frac{|R_R(s)|}{N} \cdot \text{MSE}_{R}(s)$

其中：

$|R_L(s)|$ 、 $|R_R(s)|$ 是左、右子节点的样本数；
$\text{MSE}_{L}(s)$ 、 $\text{MSE}_{R}(s)$ 是左、右子节点的均方误差。

2. 分裂点的选择

分裂点 $s$ 的选择是通过 遍历所有可能的分裂点，找到最小化 $\text{MSE}_{\text{split}}$ 的分裂点。

分裂点选择

对当前节点的所有特征值 $\{x_i\}$ 排序。
遍历每个可能的分裂点：
- 将数据划分为 $R_L(s)$ 和 $R_R(s)$ ；
- 计算分裂后的总误差 $\text{MSE}_{\text{split}}$ 。
选择使 $\text{MSE}_{\text{split}}$ 最小的分裂点 $s^*$ ： $s^* =\underset{s}{ \arg \min }\text{MSE}_{\text{split}}(s)$

3. 数学推导：MSE 的优化

(1) 节点的均方误差

对于一个节点 $N$ 内的样本，均方误差为：

$\text{MSE} = \frac{1}{N} \sum_{i=1}^N \left(r_i - \hat{r}\right)^2$

展开后：

$\text{MSE} = \frac{1}{N} \left(\sum_{i=1}^N r_i^2 - 2\hat{r}\sum_{i=1}^N r_i + N\hat{r}^2\right)$

因为 $\hat{r} = \frac{1}{N} \sum_{i=1}^N r_i$ ，所以有：

$\text{MSE} = \frac{1}{N} \left(\sum_{i=1}^N r_i^2 - N\hat{r}^2\right)$

(2) 分裂后的总均方误差

假设分裂点为 $s$ ，左、右子节点分别包含样本 $R_L(s)$ 和 $R_R(s)$ ，则分裂后的误差为：

$\text{MSE}_{\text{split}} = \frac{|R_L(s)|}{N} \cdot \text{MSE}_{L}(s) + \frac{|R_R(s)|}{N} \cdot \text{MSE}_{R}(s)$

对每个子节点，均方误差为：

$\text{MSE}_{L}(s) = \frac{1}{|R_L(s)|} \left(\sum_{x_i \in R_L(s)} r_i^2 - |R_L(s)| \hat{r}_L^2\right)$ $\text{MSE}_{R}(s) = \frac{1}{|R_R(s)|} \left(\sum_{x_i \in R_R(s)} r_i^2 - |R_R(s)| \hat{r}_R^2\right)$

其中 $\hat{r}_L, \hat{r}_R$ 分别为左、右子节点的残差均值。

(3) 分裂的最优性条件

找到最优分裂点 $s^*$ 使得 $\text{MSE}_{\text{split}}$ 最小化：

$s^* = \arg \min_s \left[\frac{|R_L(s)|}{N} \cdot \text{MSE}_{L}(s) + \frac{|R_R(s)|}{N} \cdot \text{MSE}_{R}(s)\right]$

4.总结

分裂规则核心：
- 每轮迭代中，决策树通过枚举所有可能的分裂点 $s$ ，选择能最小化分裂后均方误差（MSE）的分裂点。
分裂点优化：
- 左、右子节点的样本均值是分裂后的预测值，分裂点通过计算所有可能分裂点的总 MSE 来确定。
示例展示：
- 示例中每轮分裂均使用 MSE 最小化原则，从残差中提取新的信息并进行更新。最终模型不断优化，误差逐步减小。

3、XGBoost的例子

（1）例子背景

假设我们有一个简单的回归问题：

数据集：

x y
1 2
2 3
3 6
4 8
我们希望训练一个 XGBoost 模型来拟合 y 的值。
损失函数采用 均方误差 (MSE)：（策略）
$L(y, \hat{y}) = \frac{1}{2} (y - \hat{y})^2$
参数设置：
- 学习率 ( $\eta$ ) = 0.5
- 正则化参数 ( $\lambda$ ) = 1
- 最大树深度 = 2
- 树的数量 = 2

x	y
1	2
2	3
3	6
4	8

（2）Step 1: 初始化模型

初始预测：
- XGBoost 初始预测值通常是目标值的均值。
- $\hat{y}_i = F_0(x_i) = \frac{\sum y_i}{N} = \frac{2 + 3 + 6 + 8}{4} = 4.75$
初始预测：
- 对所有样本，初始预测值为： $F_0(x) = 4.75$

（3）Step 2: 第一轮迭代

i、计算梯度和二阶导数

目的是为了构建第一棵树，构建过程是基于上一步的模型对样本预测效果（损失函数，或者说目标函数）的一阶导和二阶导，在这里上一步的模型是初始模型 $F_0(x)$ 。

每个样本的梯度和二阶导数为：

梯度 ( $g_i$ )：
$g_i = \frac{\partial L(y_i, F_0(x_i))}{\partial F_0(x_i)} = \hat{y}_i - y_i$
二阶导数 ( $h_i$ )：
$h_i = \frac{\partial^2 L(y_i, F_0(x_i))}{\partial^2 F_0(x_i)} = 1$

逐个计算：

样本 1: $g_1 = 4.75 - 2 = 2.75, \ h_1 = 1$
样本 2: $g_2 = 4.75 - 3 = 1.75, \ h_2 = 1$
样本 3: $g_3 = 4.75 - 6 = -1.25, \ h_3 = 1$
样本 4: $g_4 = 4.75 - 8 = -3.25, \ h_4 = 1$

ii、构建第一棵树

这里构建的第一棵树是为了用了优化 $F_0(x)$ ，第一棵树的构建过程针对的是 $F_0(x)$ 在使目标函数最小化时的不足，因此是基于梯度和二阶导的。

我们基于梯度和二阶导数构建一棵决策树，分裂的目标是最大化增益。

计算分裂点增益：
- 假设第一个分裂点是 $x = 2.5$ （特征值中间值）。
- 计算左右子节点的梯度和、二阶导数和：
  - 左子节点 ( $x \leq 2.5$ )： $G_L = g_1 + g_2 = 2.75 + 1.75 = 4.5, \ H_L = 1 + 1 = 2$
  - 右子节点 ( $x > 2.5$ )： $G_R = g_3 + g_4 = -1.25 - 3.25 = -4.5, \ H_R = 1 + 1 = 2$
- 增益计算公式：
  $\text{Gain} = \frac{1}{2} \left( \frac{G_L^2}{H_L + \lambda} + \frac{G_R^2}{H_R + \lambda} - \frac{(G_L + G_R)^2}{H_L + H_R + \lambda} \right)$
  插入参数：
  $\text{Gain} = \frac{1}{2} \left( \frac{4.5^2}{2 + 1} + \frac{(-4.5)^2}{2 + 1} - \frac{(4.5 - 4.5)^2}{4 + 1} \right) = 3.375$
选择分裂：
- 假设 $x = 2.5$ 是最佳分裂点，生成两棵子树。

iii、计算叶子节点权重

叶子节点权重公式：

$w_j = -\frac{G_j}{H_j + \lambda}$

左子节点 ( $x \leq 2.5$ )：
$w_L = -\frac{4.5}{2 + 1} = -1.5$
右子节点 ( $x > 2.5$ )：
$w_R = -\frac{-4.5}{2 + 1} = 1.5$

iv、更新模型

新的预测模型：

$F_1(x) = F_0(x) + \eta \cdot f_1(x)$

其中 $f_1(x)$ 是第一棵树的输出。

对于每个样本：

样本 1 (x=1x = 1x=1)： $F_1(x_1) = 4.75 + 0.5 \cdot (-1.5) = 4.0$
样本 2 (x=2x = 2x=2)： $F_1(x_2) = 4.75 + 0.5 \cdot (-1.5) = 4.0$
样本 3 (x=3x = 3x=3)： $F_1(x_3) = 4.75 + 0.5 \cdot (1.5) = 5.5$
样本 4 (x=4x = 4x=4)： $F_1(x_4) = 4.75 + 0.5 \cdot (1.5) = 5.5$

（4）Step 3: 第二轮迭代

重复上述步骤：

计算新的梯度：
$g_i = F_1(x_i) - y_i$
构建第二棵树：
- 以当前的残差 ( $g_i$ ) 为目标，分裂节点并计算叶子节点权重。
更新模型：
$F_2(x) = F_1(x) + \eta \cdot f_2(x)$

（5）最终模型

经过 $T = 2$ 棵树后，最终模型为：

$F(x) = F_0(x) + \eta \cdot f_1(x) + \eta \cdot f_2(x)$

对于每个样本，模型预测值逐步逼近真实值 $y$ 。

4、关于XGBoost 的思考

（1）XGBoost的每个弱学习器都是为了拟合上一步模型的梯度，在构建弱学习器时怎么体现这一点？

在 XGBoost 中，每个弱学习器（通常是决策树）的构建确实是为了拟合上一步的梯度（或更具体地说，是负梯度）。这一点体现在以下几个关键步骤中：

1. 梯度的计算

为了让弱学习器拟合当前的残差，XGBoost通过计算损失函数的梯度来衡量每个样本的误差方向和大小。

在第 ttt 轮迭代中：

对于每个样本 $(x_i, y_i)$ ，计算损失函数对模型预测值的梯度： $g_i = \frac{\partial L(y_i, F_{t-1}(x_i))}{\partial F_{t-1}(x_i)}$ 是模型在上一轮的预测值。

梯度在损失函数中的作用：

对于回归任务（均方误差，MSE）：
$L(y, \hat{y}) = \frac{1}{2}(y - \hat{y})^2$
梯度为：
$g_i = F_{t-1}(x_i) - y_i$
它表示当前预测值与真实值之间的误差。
对于分类任务（对数损失，Log Loss）：
$L(y, \hat{y}) = -y \log(\hat{y}) - (1-y) \log(1-\hat{y})$
梯度为：
$g_i = \hat{y}_i - y_i$
它表示当前预测的概率与真实类别标签之间的偏差。

计算得到的梯度 $g_i$ 是弱学习器拟合的目标。

2. 决策树的构建目标

XGBoost 的每棵决策树通过最小化目标函数来拟合梯度。目标函数为：

$\text{Obj} = \sum_{i=1}^n \left[ g_i f(x_i) + \frac{1}{2} h_i f^2(x_i) \right] + \Omega(f)$

$g_i$ ：上一轮梯度，表示每个样本的残差。
$h_i$ ：二阶导数，用于调整步长。
$f(x_i)$ ：当前树的输出，拟合的就是 $g_i$ 。
$\Omega(f)$ ：正则化项（可以忽略以简单理解）。

目标函数的作用

目标函数中的 $g_i f(x_i)$ 项确保弱学习器的输出 $f(x_i)$ 尽量与当前梯度 $g_i$ 一致，从而让模型朝着正确方向优化。

3. 树节点分裂基于梯度

决策树在构建时通过寻找最佳分裂点来最大化目标函数的增益，增益的计算直接基于梯度和二阶导数：

对于一个分裂，假设分裂点把样本分为左右两个子节点：
- 左子节点的梯度和 $G_L = \sum_{i \in \text{left}} g_i$ ，二阶导数和 $H_L = \sum_{i \in \text{left}} h_i$ 。
- 右子节点的梯度和 $G_R = \sum_{i \in \text{right}} g_i$ ，二阶导数和 $G_R = \sum_{i \in \text{right}} g_i$ 。

增益计算公式为：

$\text{Gain} = \frac{1}{2} \left[ \frac{G_L^2}{H_L + \lambda} + \frac{G_R^2}{H_R + \lambda} - \frac{(G_L + G_R)^2}{H_L + H_R + \lambda} \right] - \gamma$