集成学习（Ensemble Learning）基础知识2

文章目录

• 前文链接
• 三、提升法（Boosting）
• • 1、Boosting
  • • （1）Boosting与Bagging的对比
    • （2）Bagging（自助法）
    • （3）Boosting（提升法）
  • 3、AdaBoost
  • • （1）怎样得到互补的学习器？
    • （2）AdaBoost的基本思想
    • （3）样本重新加权
    • [（4）AdaBoost M1算法](#（4）AdaBoost M1算法)
    • （5）例：AdaBoost
    • • • [第二个弱学习器 ϕ 2 ( x ) \phi_2(x) ϕ2(x)](#第二个弱学习器 ϕ 2 ( x ) \phi_2(x) ϕ2(x))
        • [第三个弱学习器 ϕ 3 ( x ) \phi_3(x) ϕ3(x)](#第三个弱学习器 ϕ 3 ( x ) \phi_3(x) ϕ3(x))
        • 最终强分类器
    • （6）训练误差（证明）
    • • 证明过程：
      • • [1. 对 w M + 1 w_{M+1} wM+1 进行迭代展开](#1. 对 w M + 1 w_{M+1} wM+1 进行迭代展开)
        • [2. 训练误差为： E R R t r a i n ( f ( x ) ) = 1 N ∣ { i : y i ≠ sgn ( f ( x i ) ) } ∣ ERR_{train}(f(x)) = \frac{1}{N} | \{ i: y_i \neq \text{sgn}(f(x_i)) \} | ERRtrain(f(x))=N1∣{i:yi=sgn(f(xi))}∣](#2. 训练误差为： E R R t r a i n ( f ( x ) ) = 1 N ∣ { i : y i ≠ sgn ( f ( x i ) ) } ∣ ERR_{train}(f(x)) = \frac{1}{N} | { i: y_i \neq \text{sgn}(f(x_i)) } | ERRtrain(f(x))=N1∣{i:yi=sgn(f(xi))}∣)
        • [3. Z m Z_m Zm的计算公式为：对 m = 1 , . . . , M m = 1, ..., M m=1,...,M，](#3. Z m Z_m Zm的计算公式为：对 m = 1 , . . . , M m = 1, ..., M m=1,...,M，)
        • [4. 训练误差为：](#4. 训练误差为：)
    • （7）测试误差
    • （8）前向分步加法模型解释
  • [4、Gradient Boosting Decision Tree (GBDT)](#4、Gradient Boosting Decision Tree (GBDT))
  • • （1）Boosting的一般框架
    • [（2）Gradient Boosting](#（2）Gradient Boosting)
    • [（3）Gradient Boosting 算法](#（3）Gradient Boosting 算法)
    • [（4）Gradient Boosting 算法](#（4）Gradient Boosting 算法)
    • [（5）从Gradient Descent 到 Gradient Boosting](#（5）从Gradient Descent 到 Gradient Boosting)
    • [（6）Gradient Boosting --- 不同损失函数](#（6）Gradient Boosting — 不同损失函数)
    • • （6.1）L2Boosting
      • • 例：回归
      • （6.2）logitBoosting
      • • 导数计算
        • LogitBoosting算法
        • Shrinkage

前文链接

前文链接

三、提升法（Boosting）

1、Boosting

Boosting是一种集成学习算法，它通过组合多个弱学习器来构建一个强分类器。

• Boosting ：将弱学习器组合成强分类器
  • 构造一个性能很高的预测（强学习器）是一件很困难的事情
  • 但构造一个性能一般的预测（弱学习器）并不难
    • 弱学习器：性能比随机猜测略好（如层数不深的决策树）

Boosting学习框架：

• 学习第一个弱学习器 ϕ 1 \phi_1 ϕ1
• 学习第二个弱学习器 ϕ 2 \phi_2 ϕ2， ϕ 2 \phi_2 ϕ2要能帮助 ϕ 1 \phi_1 ϕ1（ ϕ 2 \phi_2 ϕ2和 ϕ 1 \phi_1 ϕ1互补）
• ...
• 组合所有的弱学习器： f ( x ) = ∑ m = 1 M α m ϕ m ( x ) f(x) = \sum_{m=1}^{M} \alpha_m \phi_m(x) f(x)=m=1∑Mαmϕm(x)

弱学习器是按顺序学习的。

Boosting的核心思想是逐步提高模型的性能。首先，我们训练一个基础的弱学习器，然后我们训练第二个弱学习器，它专注于第一个模型预测错误的样本。这个过程不断重复，每个新的弱学习器都试图纠正前一个模型的错误。最后，我们将所有弱学习器的预测结果加权组合，形成最终的强学习器。

这种方法的优点是它可以显著提高模型的准确性，特别是当弱学习器的性能略优于随机猜测时。然而，Boosting也有缺点，如对异常值敏感，以及可能过拟合训练数据。为了缓解这些问题，通常需要对Boosting算法进行适当的调整，如调整学习率或使用正则化技术。

（1）Boosting与Bagging的对比

Bagging和Boosting是两种流行的集成学习技术，它们在构建基学习器的方式上有所不同。

（2）Bagging（自助法）

• Parallel（并行）：Bagging中的基学习器是并行构建的。
• 在Bagging中，每个基学习器都是独立地从原始数据集的Bootstrap样本中训练得到的。这意味着每个学习器都可能看到不同的数据子集，从而增加了模型的多样性。
• 这种方法不依赖于前一个模型的表现，所有模型都是同时训练的。

（3）Boosting（提升法）

• Sequential（顺序）：Boosting中的基学习器是顺序构建的。
• 在Boosting中，每个基学习器的训练都依赖于前一个模型的错误。每个后续模型都试图纠正前一个模型的错误，从而逐步提升整体模型的性能。
• 这种方法通过调整数据权重或关注难以分类的样本，使得后续模型更加关注前模型的不足。

总结来说，Bagging通过并行构建多个独立的模型来降低方差，而Boosting通过顺序构建模型并逐步纠正前一个模型的错误来降低偏差。两者都是有效的集成学习方法，但适用的场景和原理有所不同。

3、AdaBoost

（1）怎样得到互补的学习器？

为了构建互补的学习器，即让不同的学习器专注于数据的不同方面，从而提高整体模型的性能，我们可以采取以下几种方法：

• 在不同的训练集上训练学习器。
• 怎么得到不同的训练集？
  • 对原始训练集重采样
  • 改变训练集的标签（基于梯度的提升法）
  • 对原始训练集重新加权（AdaBoost）
    • 在实际操作中，改变目标函数即可。

以下是AdaBoost算法中的目标函数变化的数学表达：

原始目标函数：
J ( f , λ ) = ∑ i = 1 N L ( y i , f ( x i ) ) + λ R ( f ) J(f, \lambda) = \sum_{i=1}^{N} L(y_i, f(x_i)) + \lambda R(f) J(f,λ)=i=1∑NL(yi,f(xi))+λR(f)

加权后的目标函数：
J ( f , λ ) = ∑ i = 1 N w i L ( y i , f ( x i ) ) + λ R ( f ) J(f, \lambda) = \sum_{i=1}^{N} w_i L(y_i, f(x_i)) + \lambda R(f) J(f,λ)=i=1∑NwiL(yi,f(xi))+λR(f)

其中， ( x 1 , y 1 , w 1 ) , ... , ( x N , y N , w N ) (x_1, y_1, w_1), \ldots, (x_N, y_N, w_N) (x1,y1,w1),...,(xN,yN,wN) 表示加权后的训练样本。

在AdaBoost中，每个样本的权重 w i w_i wi 会根据前一个模型的表现进行调整。如果一个样本被前一个模型错误分类，那么它的权重会增加，从而使得后续模型更加关注这些难以分类的样本。通过这种方式，每个模型都在努力纠正前一个模型的错误，从而实现学习器之间的互补。

这种方法不仅可以提高模型的准确性，还可以帮助模型更好地泛化到未见过的数据。通过关注不同的数据特征和模式，互补的学习器可以减少整体模型的偏差和方差，从而提高模型的稳定性和鲁棒性。

（2）AdaBoost的基本思想

AdaBoost（Adaptive Boosting）是一种迭代的集成学习算法，它通过关注前一轮学习器的错误来提高模型的性能。

• 在弱学习器 ϕ 1 \phi_1 ϕ1失败的样本上，学习第二个弱学习器 ϕ 2 \phi_2 ϕ2

弱学习器 ϕ 1 \phi_1 ϕ1在其训练集上的误差定义为：
ε 1 = ∑ i = 1 N w 1 , i I ( y i ≠ ϕ 1 ( x i ) ) < 1 2 \varepsilon_1 = \sum_{i=1}^{N} w_{1,i} \mathbb{I}(y_i \neq \phi_1(x_i)) < \frac{1}{2} ε1=i=1∑Nw1,iI(yi=ϕ1(xi))<21

其中， I ( condition ) \mathbb{I}(\text{condition}) I(condition) 是示性（Indicator）函数，满足条件值为1，否则为0。

• 将权重由 w 1 w_1 w1 变成 w 2 w_2 w2，使得
  ∑ i = 1 N w 2 , i I ( y i ≠ ϕ 1 ( x i ) ) = 1 2 \sum_{i=1}^{N} w_{2,i} \mathbb{I}(y_i \neq \phi_1(x_i)) = \frac{1}{2} i=1∑Nw2,iI(yi=ϕ1(xi))=21

• 根据权重 w 2 w_2 w2 训练弱学习器 ϕ 2 \phi_2 ϕ2

在AdaBoost中，每个样本的权重会根据其被前一个模型正确或错误分类的情况动态调整。如果一个样本被错误分类，它的权重会增加，使得后续模型更加关注这些难以分类的样本。

通过这种方式，AdaBoost算法能够逐步减少模型的误差，提高整体的预测性能。每个弱学习器都在努力解决前一个模型的不足，从而实现模型性能的逐步提升。

需要注意的是，AdaBoost算法对弱学习器的性能要求不高，只要其性能略优于随机猜测即可。通过迭代地训练多个弱学习器并组合它们的预测结果，AdaBoost能够构建出一个强学习器，显著提高模型的准确性和鲁棒性。

（3）样本重新加权

在AdaBoost算法中，样本的权重会根据模型在这些样本上的表现进行调整。以下是样本权重调整的详细步骤：

如何加权？

• 分对的样本 ，其权重除以 d 1 d_1 d1 ------ 权重减小
• 分错的样本 ，其权重乘以 d 1 d_1 d1 ------ 权重增大

d 1 d_1 d1的值？

为了确保 w 2 w_2 w2仍然是一个分布， w 1 w_1 w1乘以/除以 d 1 d_1 d1后的权重，再除以归一化因子 Z 1 Z_1 Z1：
Z 1 = ∑ i = 1 N w 1 , i d 1 I ( y i ≠ ϕ 1 ( x i ) ) + ∑ i = 1 N w 1 , i / d 1 I ( y i = ϕ 1 ( x i ) ) Z_1 = \sum_{i=1}^{N} w_{1,i} d_1 \mathbb{I}(y_i \neq \phi_1(x_i)) + \sum_{i=1}^{N} w_{1,i} / d_1 \mathbb{I}(y_i = \phi_1(x_i)) Z1=i=1∑Nw1,id1I(yi=ϕ1(xi))+i=1∑Nw1,i/d1I(yi=ϕ1(xi))

即：

• 分对的样本的权重： w 2 , i = w 1 , i / d 1 Z 1 w_{2,i} = \frac{w_{1,i} / d_1}{Z_1} w2,i=Z1w1,i/d1
• 分错的样本的权重： w 2 , i = w 1 , i d 1 Z 1 w_{2,i} = \frac{w_{1,i} d_1}{Z_1} w2,i=Z1w1,id1

计算 d 1 d_1 d1

根据AdaBoost算法， d 1 d_1 d1的计算公式为：
d 1 ε 1 = 1 d 1 ( 1 − ε 1 ) ⇒ d 1 = 1 − ε 1 ε 1 > 1 d_1 \varepsilon_1 = \frac{1}{d_1} (1 - \varepsilon_1) \Rightarrow d_1 = \sqrt{\frac{1 - \varepsilon_1}{\varepsilon_1}} > 1 d1ε1=d11(1−ε1)⇒d1=ε11−ε1 >1

其中， ε 1 \varepsilon_1 ε1是弱学习器 ϕ 1 \phi_1 ϕ1在其训练集上的误差：
ε 1 = ∑ i = 1 N w 1 , i I ( y i ≠ ϕ 1 ( x i ) ) \varepsilon_1 = \sum_{i=1}^{N} w_{1,i} \mathbb{I}(y_i \neq \phi_1(x_i)) ε1=i=1∑Nw1,iI(yi=ϕ1(xi))

通过这种方式，AdaBoost算法能够逐步调整样本的权重，使得后续的弱学习器更加关注前一个模型错误分类的样本，从而逐步提高整体模型的性能。

具体来说，对于每个样本 i i i，如果它被弱学习器 ϕ 1 \phi_1 ϕ1正确分类，那么它的权重会被减小；如果它被错误分类，那么它的权重会被增大。这样，后续的弱学习器就会更加关注那些难以分类的样本，从而提高模型的准确性和鲁棒性。

（4）AdaBoost M1算法

AdaBoost M1算法是一种迭代的集成学习方法，用于构建强分类器。以下是AdaBoost M1算法的步骤：

1. 给定训练集 ： ( x 1 , y 1 ) , . . . , ( x N , y N ) (x_1, y_1), ..., (x_N, y_N) (x1,y1),...,(xN,yN)，其中 y i ∈ { − 1 , 1 } y_i \in \{-1, 1\} yi∈{−1,1} 表示 x i x_i xi的类别标签。

2. 训练集上样本的初始分布 ： w 1 , i = 1 N w_{1,i} = \frac{1}{N} w1,i=N1

3. 对 m = 1 : M m = 1 : M m=1:M

   • 对训练样本采用权重 w m , i w_{m,i} wm,i，计算错误率最小的弱分类器 ϕ m ( x ) \phi_m(x) ϕm(x)
   • 计算该弱分类器 ϕ m ( x ) \phi_m(x) ϕm(x)在分布 w m w_m wm上的误差： ε m = ∑ i = 1 N w m , i I ( ϕ m ( x i ) ≠ y i ) \varepsilon_m = \sum_{i=1}^{N} w_{m,i} \mathbb{I}(\phi_m(x_i) \neq y_i) εm=∑i=1Nwm,iI(ϕm(xi)=yi)
   • 计算： d m = 1 − ε m / ε m , α m = 1 2 log ⁡ 1 − ε m ε m d_m = \sqrt{1 - \varepsilon_m / \varepsilon_m}, \alpha_m = \frac{1}{2} \log \frac{1 - \varepsilon_m}{\varepsilon_m} dm=1−εm/εm ,αm=21logεm1−εm
   • 更新训练样本的分布： w m + 1 , i = { w m , i / d m Z m if y i ϕ m ( x i ) = 1 (对分样本) w m , i d m Z m if y i ϕ m ( x i ) = − 1 (分错样本) w_{m+1,i} = \begin{cases} \frac{w_{m,i} / d_m}{Z_m} & \text{if } y_i \phi_m(x_i) = 1 \text{ (对分样本)} \\ \frac{w_{m,i} d_m}{Z_m} & \text{if } y_i \phi_m(x_i) = -1 \text{ (分错样本)} \end{cases} wm+1,i={Zmwm,i/dmZmwm,idmif yiϕm(xi)=1 (对分样本)if yiϕm(xi)=−1 (分错样本)
     其中 Z m Z_m Zm为归一化常数，使得 w m + 1 w_{m+1} wm+1是个分布。

4. 最后的强分类器为 ： f ( x ) = sgn ( ∑ m = 1 M α m ϕ m ( x ) ) f(x) = \text{sgn}(\sum_{m=1}^{M} \alpha_m \phi_m(x)) f(x)=sgn(∑m=1Mαmϕm(x))

准确率越高的弱学习机权重越高。这意味着在后续的迭代中，表现更好的弱分类器将对最终的强分类器有更大的影响。

通过这种方式，AdaBoost M1算法能够逐步提高模型的性能，使得最终的强分类器在处理复杂数据时更加准确和鲁棒。

（5）例：AdaBoost

第一个弱学习器 ϕ 1 ( x ) \phi_1(x) ϕ1(x)

对于 m = 1 m=1 m=1，计算如下：

• 误差 ε m = ∑ i = 1 N w m , i I ( ϕ m ( x i ) ≠ y i ) \varepsilon_m = \sum_{i=1}^{N} w_{m,i} \mathbb{I}(\phi_m(x_i) \neq y_i) εm=∑i=1Nwm,iI(ϕm(xi)=yi)
• 调整因子 d m = 1 − ε m / ε m d_m = \sqrt{1 - \varepsilon_m / \varepsilon_m} dm=1−εm/εm
• 权重更新系数 α m = 1 2 log ⁡ 1 − ε m ε m \alpha_m = \frac{1}{2} \log \frac{1 - \varepsilon_m}{\varepsilon_m} αm=21logεm1−εm

给定：

• ε 1 = 0.30 \varepsilon_1 = 0.30 ε1=0.30
• d 1 = 1.53 d_1 = 1.53 d1=1.53
• α 1 = 0.42 \alpha_1 = 0.42 α1=0.42

更新样本权重：

• 对于正确分类的样本，权重更新为 w 1 , i / d 1 Z 1 \frac{w_{1,i} / d_1}{Z_1} Z1w1,i/d1
• 对于错误分类的样本，权重更新为 w 1 , i d 1 Z 1 \frac{w_{1,i} d_1}{Z_1} Z1w1,id1

第二个弱学习器 ϕ 2 ( x ) \phi_2(x) ϕ2(x)

对于 m = 2 m=2 m=2，计算如下：

• ε 2 = 0.21 \varepsilon_2 = 0.21 ε2=0.21
• d 2 = 1.94 d_2 = 1.94 d2=1.94
• α 2 = 0.66 \alpha_2 = 0.66 α2=0.66

再次更新样本权重。

第三个弱学习器 ϕ 3 ( x ) \phi_3(x) ϕ3(x)

对于 m = 3 m=3 m=3，计算如下：

• ε 3 = 0.13 \varepsilon_3 = 0.13 ε3=0.13
• d 3 = 2.59 d_3 = 2.59 d3=2.59
• α 3 = 0.95 \alpha_3 = 0.95 α3=0.95

继续更新样本权重。

最终强分类器

强分类器定义为：

f ( x ) = sgn ( ∑ m = 1 M α m ϕ m ( x ) ) f(x) = \text{sgn}\left(\sum_{m=1}^{M} \alpha_m \phi_m(x)\right) f(x)=sgn(m=1∑Mαmϕm(x))

其中， sgn ( ⋅ ) \text{sgn}(\cdot) sgn(⋅)表示符号函数， α m \alpha_m αm是第 m m m个弱学习器的权重， ϕ m ( x ) \phi_m(x) ϕm(x)是第 m m m个弱学习器。

通过迭代地训练多个弱学习器并调整样本权重，AdaBoost算法能够逐步提高分类器的性能。每个弱学习器都专注于前一个学习器未能正确分类的样本，从而实现整体性能的提升。

（6）训练误差（证明）

可以证明：随着弱学习器数目增多，训练误差越来越小。

证明过程：

1. 对 w M + 1 w_{M+1} wM+1 进行迭代展开

我们首先对 w M + 1 w_{M+1} wM+1进行迭代展开：

w M + 1 , i = w M , i exp ⁡ ( − α M y i ϕ m ( x i ) ) Z M = w 1 , i exp ⁡ ( − y i ∑ m = 1 M α m ϕ m ( x i ) ) ∏ m = 1 M Z m = w 1 , i exp ⁡ ( − y i f ( x i ) ) ∏ m = 1 M Z m w_{M+1,i} = w_{M,i} \frac{\exp(-\alpha_M y_i \phi_m(x_i))}{Z_M} = w_{1,i} \frac{\exp(-y_i \sum_{m=1}^{M} \alpha_m \phi_m(x_i))}{\prod_{m=1}^{M} Z_m} = w_{1,i} \frac{\exp(-y_i f(x_i))}{\prod_{m=1}^{M} Z_m} wM+1,i=wM,iZMexp(−αMyiϕm(xi))=w1,i∏m=1MZmexp(−yi∑m=1Mαmϕm(xi))=w1,i∏m=1MZmexp(−yif(xi))

• 由于 w M + 1 w_{M+1} wM+1是一个分布，所以 ∑ i = 1 N w M + 1 , i = 1 \sum_{i=1}^{N} w_{M+1,i} = 1 ∑i=1NwM+1,i=1
• 所以 ∑ i = 1 N w 1 , i exp ⁡ ( − y i f ( x i ) ) ∏ m = 1 M Z m = 1 \sum_{i=1}^{N} w_{1,i} \frac{\exp(-y_i f(x_i))}{\prod_{m=1}^{M} Z_m} = 1 ∑i=1Nw1,i∏m=1MZmexp(−yif(xi))=1
• ∏ m = 1 M Z m = ∑ i = 1 N w 1 , i exp ⁡ ( − y i f ( x i ) ) = 1 N ∑ i = 1 N exp ⁡ ( − y i f ( x i ) ) \prod_{m=1}^{M} Z_m = \sum_{i=1}^{N} w_{1,i} \exp(-y_i f(x_i)) = \frac{1}{N} \sum_{i=1}^{N} \exp(-y_i f(x_i)) ∏m=1MZm=∑i=1Nw1,iexp(−yif(xi))=N1∑i=1Nexp(−yif(xi))。

形式与训练误差很像。

2. 训练误差为： E R R t r a i n ( f ( x ) ) = 1 N ∣ { i : y i ≠ sgn ( f ( x i ) ) } ∣ ERR_{train}(f(x)) = \frac{1}{N} | \{ i: y_i \neq \text{sgn}(f(x_i)) \} | ERRtrain(f(x))=N1∣{i:yi=sgn(f(xi))}∣

训练误差可以表示为：

= 1 N ∑ i = 1 N { 1 y i ≠ sgn ( f ( x i ) ) 0 else 0-1损失 = \frac{1}{N} \sum_{i=1}^{N} \begin{cases} 1 & y_i \neq \text{sgn}(f(x_i)) \\ 0 & \text{else} \end{cases} \quad \text{0-1损失} =N1i=1∑N{10yi=sgn(f(xi))else0-1损失

≤ 1 N ∑ i = 1 N exp ⁡ ( − y i f ( x i ) ) 指数损失 \leq \frac{1}{N} \sum_{i=1}^{N} \exp(-y_i f(x_i)) \quad \text{指数损失} ≤N1i=1∑Nexp(−yif(xi))指数损失

= ∏ m = 1 M Z m = \prod_{m=1}^{M} Z_m =m=1∏MZm

相当于损失函数为指数损失函数： L ( f ( x ) , y ) = exp ⁡ ( − y f ( x ) ) L(f(x), y) = \exp(-y f(x)) L(f(x),y)=exp(−yf(x))，训练误差为：

E R R t r a i n ( f ( x ) ) = 1 N ∑ i = 1 N exp ⁡ ( − y i f ( x i ) ) ERR_{train}(f(x)) = \frac{1}{N} \sum_{i=1}^{N} \exp(-y_i f(x_i)) ERRtrain(f(x))=N1i=1∑Nexp(−yif(xi))

3. Z m Z_m Zm的计算公式为：对 m = 1 , . . . , M m = 1, ..., M m=1,...,M，

Z m = ∑ i = 1 N w m , i d m I ( y i ≠ ϕ m ( x i ) ) + ∑ i = 1 N w m , i / d m I ( y i = ϕ m ( x i ) ) Z_m = \sum_{i=1}^{N} w_{m,i} d_m \mathbb{I}(y_i \neq \phi_m(x_i)) + \sum_{i=1}^{N} w_{m,i} / d_m \mathbb{I}(y_i = \phi_m(x_i)) Zm=i=1∑Nwm,idmI(yi=ϕm(xi))+i=1∑Nwm,i/dmI(yi=ϕm(xi))

= d m ∑ i = 1 N w m , i I ( y i ≠ ϕ m ( x i ) ) + 1 d m ∑ i = 1 N w m , i I ( y i = ϕ m ( x i ) ) = d_m \sum_{i=1}^{N} w_{m,i} \mathbb{I}(y_i \neq \phi_m(x_i)) + \frac{1}{d_m} \sum_{i=1}^{N} w_{m,i} \mathbb{I}(y_i = \phi_m(x_i)) =dmi=1∑Nwm,iI(yi=ϕm(xi))+dm1i=1∑Nwm,iI(yi=ϕm(xi))

= ( d m ε m + 1 d m ( 1 − ε m ) ) = \left( d_m \varepsilon_m + \frac{1}{d_m} (1 - \varepsilon_m) \right) =(dmεm+dm1(1−εm))

= ε m 1 − ε m / ε m + ( 1 − ε m ) ε m / ( 1 − ε m ) = \varepsilon_m \sqrt{1 - \varepsilon_m / \varepsilon_m} + (1 - \varepsilon_m) \sqrt{\varepsilon_m / (1 - \varepsilon_m)} =εm1−εm/εm +(1−εm)εm/(1−εm)

= ε m ( 1 − ε m ) + ε m ( 1 − ε m ) = \sqrt{\varepsilon_m (1 - \varepsilon_m)} + \sqrt{\varepsilon_m (1 - \varepsilon_m)} =εm(1−εm) +εm(1−εm)

= 2 ε m ( 1 − ε m ) = 2 \sqrt{\varepsilon_m (1 - \varepsilon_m)} =2εm(1−εm)

其中 d m = 1 − ε m / ε m d_m = \sqrt{1 - \varepsilon_m / \varepsilon_m} dm=1−εm/εm 。

4. 训练误差为：

1 N ∑ i = 1 N exp ⁡ ( − y i f ( x i ) ) = ∏ m = 1 M Z m \frac{1}{N} \sum_{i=1}^{N} \exp(-y_i f(x_i)) = \prod_{m=1}^{M} Z_m N1i=1∑Nexp(−yif(xi))=m=1∏MZm

• 由于 0 < ε m < 1 2 0 < \varepsilon_m < \frac{1}{2} 0<εm<21， 0 < 1 − ε m < 1 0 < 1 - \varepsilon_m < 1 0<1−εm<1， Z m < 1 Z_m < 1 Zm<1，
• 所以训练误差随着 M M M的增加越来越小。

（7）测试误差

训练误差随着 M M M的增加而减小。测试误差呢？

上图展示了随着迭代次数 T T T的增加，训练误差和测试误差的变化情况。可以看到，随着迭代次数的增加，训练误差迅速下降并趋于零，而测试误差在初期下降后趋于平稳。

下图展示了C4.5算法在"letter"数据集上的测试误差变化情况。可以看到，随着迭代次数的增加，测试误差逐渐减小。

表格展示了不同迭代次数下的训练误差、测试误差以及分类间隔（margin）的统计数据：

# rounds	5	100	1000
train error	0.0	0.0	0.0
test error	8.4	3.3	3.1

测试误差随着 M M M的增加而减小可以用间隔来解释。上述训练误差（0-1损失）只考虑了分类是否正确，还应该考虑分类的置信度。

分类的置信度：判别函数的值 y f ( x ) yf(x) yf(x)

margin小的样本很少，即样本的margin都很大，泛化性能好

（8）前向分步加法模型解释

假设前 m − 1 m-1 m−1个学习器已经已知，则训练误差为：

E = ∑ i = 1 N exp ⁡ ( − y i f m ( x i ) ) E = \sum_{i=1}^{N} \exp(-y_i f_m(x_i)) E=i=1∑Nexp(−yifm(xi))

= ∑ i = 1 N exp ⁡ ( − y i f m − 1 ( x i ) − y i α m ϕ m ( x i ) ) = \sum_{i=1}^{N} \exp(-y_i f_{m-1}(x_i) - y_i \alpha_m \phi_m(x_i)) =i=1∑Nexp(−yifm−1(xi)−yiαmϕm(xi))

= ∑ i = 1 N w m , i ′ exp ⁡ ( − y i α m ϕ m ( x i ) ) = \sum_{i=1}^{N} w'_{m,i} \exp(-y_i \alpha_m \phi_m(x_i)) =i=1∑Nwm,i′exp(−yiαmϕm(xi))

其中， w m , i ′ = exp ⁡ ( − y i f m − 1 ( x i ) ) w'{m,i} = \exp(-y_i f{m-1}(x_i)) wm,i′=exp(−yifm−1(xi))。

= ∑ i = 1 N w m , i ′ exp ⁡ ( α m ) I ( y i ≠ ϕ m ( x i ) ) + ∑ i = 1 N w m , i ′ exp ⁡ ( − α m ) I ( y i = ϕ m ( x i ) ) = \sum_{i=1}^{N} w'{m,i} \exp(\alpha_m) \mathbb{I}(y_i \neq \phi_m(x_i)) + \sum{i=1}^{N} w'_{m,i} \exp(-\alpha_m) \mathbb{I}(y_i = \phi_m(x_i)) =i=1∑Nwm,i′exp(αm)I(yi=ϕm(xi))+i=1∑Nwm,i′exp(−αm)I(yi=ϕm(xi))

ϕ m \phi_m ϕm只在第一项出现，可以单独优化 ϕ m \phi_m ϕm而不受 α m \alpha_m αm的影响。

因此第 m m m个学习器 ϕ m \phi_m ϕm的目标函数是：

J = ∑ i = 1 N w m , i ′ I ( y i ≠ ϕ m ( x i ) ) ϕ m 为最小加权错误率的模型 J = \sum_{i=1}^{N} w'_{m,i} \mathbb{I}(y_i \neq \phi_m(x_i)) \quad \phi_m \text{为最小加权错误率的模型} J=i=1∑Nwm,i′I(yi=ϕm(xi))ϕm为最小加权错误率的模型

一旦 ϕ m \phi_m ϕm确定下来了，就可以对 E E E求导得到最优的 α m \alpha_m αm：

∂ E ∂ α m = ( exp ⁡ ( α m ) + exp ⁡ ( − α m ) ) ∑ i = 1 N w m , i ′ I ( y i ≠ ϕ m ( x i ) ) − ∑ i = 1 N w m , i ′ exp ⁡ ( − α m ) = 0 \frac{\partial E}{\partial \alpha_m} = (\exp(\alpha_m) + \exp(-\alpha_m)) \sum_{i=1}^{N} w'{m,i} \mathbb{I}(y_i \neq \phi_m(x_i)) - \sum{i=1}^{N} w'_{m,i} \exp(-\alpha_m) = 0 ∂αm∂E=(exp(αm)+exp(−αm))i=1∑Nwm,i′I(yi=ϕm(xi))−i=1∑Nwm,i′exp(−αm)=0

exp ⁡ ( − α m ) exp ⁡ ( α m ) + exp ⁡ ( − α m ) = ∑ i = 1 N w m , i ′ I ( y i ≠ ϕ m ( x i ) ) ∑ i = 1 N w m , i ′ = ε m ⇒ α m = 1 2 log ⁡ 1 − ε m ε m \frac{\exp(-\alpha_m)}{\exp(\alpha_m) + \exp(-\alpha_m)} = \frac{\sum_{i=1}^{N} w'{m,i} \mathbb{I}(y_i \neq \phi_m(x_i))}{\sum{i=1}^{N} w'_{m,i}} = \varepsilon_m \Rightarrow \alpha_m = \frac{1}{2} \log \frac{1 - \varepsilon_m}{\varepsilon_m} exp(αm)+exp(−αm)exp(−αm)=∑i=1Nwm,i′∑i=1Nwm,i′I(yi=ϕm(xi))=εm⇒αm=21logεm1−εm

4、Gradient Boosting Decision Tree (GBDT)

（1）Boosting的一般框架

1. 初始化模型 f 0 ( x ) f_0(x) f0(x)

2. 对于 m = 1 : M m = 1:M m=1:M 执行以下步骤：

   • 找到一个弱学习器 ϕ m ( x ) \phi_m(x) ϕm(x)，使得 ϕ m ( x ) \phi_m(x) ϕm(x) 能够改进 f m − 1 ( x ) f_{m-1}(x) fm−1(x)；
   • 更新模型 f m ( x ) = f m − 1 ( x ) + α m ϕ m ( x ) f_m(x) = f_{m-1}(x) + \alpha_m \phi_m(x) fm(x)=fm−1(x)+αmϕm(x)

3. 返回最终模型 f ( x ) = f M ( x ) f(x) = f_M(x) f(x)=fM(x)

以上是Boosting算法的基本流程。Boosting是一种集成学习方法，通过逐步添加弱学习器来提高模型的预测性能。每个弱学习器都是在前一个模型的基础上进行改进，最终通过加权求和的方式得到一个强学习器。

（2）Gradient Boosting

目标：使损失函数 J ( f ) = ∑ i = 1 N L ( f ( x i ) , y i ) J(f) = \sum_{i=1}^{N} L(f(x_i), y_i) J(f)=∑i=1NL(f(xi),yi) 最小化。

若已有 f m ( x ) f_m(x) fm(x)，如何在 f m ( x ) f_m(x) fm(x) 的基础上改进 f ( x ) f(x) f(x) 呢？

梯度下降：
f m ( x ) = f m − 1 ( x ) − η [ ∂ J ( f ) ∂ f ] f ( x ) = f m − 1 ( x ) f_m(x) = f_{m-1}(x) - \eta \left[ \frac{\partial J(f)}{\partial f} \right]{f(x) = f{m-1}(x)} fm(x)=fm−1(x)−η[∂f∂J(f)]f(x)=fm−1(x)

对比：
f m ( x ) = f m − 1 ( x ) + η ϕ m ( x ) f_m(x) = f_{m-1}(x) + \eta \phi_m(x) fm(x)=fm−1(x)+ηϕm(x)

用弱学习器来拟合目标函数的负梯度。（回归问题）

在梯度提升（Gradient Boosting）中，我们通过迭代地添加弱学习器来逐步优化模型。每一步，我们都计算当前模型的梯度，并用一个弱学习器来拟合这个梯度的负值，以此来更新模型。这种方法特别适用于回归问题，因为它能够有效地减少模型的损失。

（3）Gradient Boosting 算法

1. 初始化 f 0 ( x ) = arg ⁡ min ⁡ f 1 N ∑ i = 1 N L ( y i , f ( x i ) ) f_0(x) = \arg\min_f \frac{1}{N} \sum_{i=1}^{N} L(y_i, f(x_i)) f0(x)=argminfN1∑i=1NL(yi,f(xi))

2. 对于 m = 1 : M m = 1:M m=1:M 执行以下步骤：

• 计算梯度残差 r m , i = − [ ∂ L ( y i , f ( x i ) ) ∂ f ] f = f m − 1 r_{m,i} = -\left[ \frac{\partial L(y_i, f(x_i))}{\partial f} \right]{f=f{m-1}} rm,i=−[∂f∂L(yi,f(xi))]f=fm−1
• 使用弱学习器最小化 ∑ i = 1 N ( r m , i − ϕ m ( x i ) ) 2 \sum_{i=1}^{N} \left( r_{m,i} - \phi_m(x_i) \right)^2 ∑i=1N(rm,i−ϕm(xi))2
• 更新 f m ( x ) = f m − 1 ( x ) + η ϕ m ( x ) f_m(x) = f_{m-1}(x) + \eta \phi_m(x) fm(x)=fm−1(x)+ηϕm(x)

3. 返回 f ( x ) = f M ( x ) f(x) = f_M(x) f(x)=fM(x)

在梯度提升算法中，我们首先初始化一个模型 f 0 ( x ) f_0(x) f0(x)，然后通过迭代地添加弱学习器来逐步优化模型。每一步，我们计算当前模型的梯度残差，并用一个弱学习器来拟合这个残差，以此来更新模型。这个过程重复进行，直到达到预定的迭代次数 M M M。最终，我们得到的模型是所有弱学习器的加权和。

（4）Gradient Boosting 算法

1. 初始化 f 0 ( x ) = arg ⁡ min ⁡ f 1 N ∑ i = 1 N L ( y i , f ( x i ) ) f_0(x) = \arg\min_f \frac{1}{N} \sum_{i=1}^{N} L(y_i, f(x_i)) f0(x)=argminfN1∑i=1NL(yi,f(xi))

2. 对于 m = 1 : M m = 1:M m=1:M 执行以下步骤：

• 计算梯度残差 r m , i = − [ ∂ L ( y i , f ( x i ) ) ∂ f ] f = f m − 1 r_{m,i} = -\left[ \frac{\partial L(y_i, f(x_i))}{\partial f} \right]{f=f{m-1}} rm,i=−[∂f∂L(yi,f(xi))]f=fm−1
• 使用弱学习器最小化 ∑ i = 1 N ( r m , i − ϕ m ( x i ) ) 2 \sum_{i=1}^{N} \left( r_{m,i} - \phi_m(x_i) \right)^2 ∑i=1N(rm,i−ϕm(xi))2
• 更新 f m ( x ) = f m − 1 ( x ) + η ϕ m ( x ) f_m(x) = f_{m-1}(x) + \eta \phi_m(x) fm(x)=fm−1(x)+ηϕm(x)

3. 返回 f ( x ) = f M ( x ) f(x) = f_M(x) f(x)=fM(x)

在梯度提升算法中，我们首先初始化一个模型 f 0 ( x ) f_0(x) f0(x)，然后通过迭代地添加弱学习器来逐步优化模型。每一步，我们计算当前模型的梯度残差，并用一个弱学习器来拟合这个残差，以此来更新模型。这个过程重复进行，直到达到预定的迭代次数 M M M。最终，我们得到的模型是所有弱学习器的加权和。

（5）从Gradient Descent 到 Gradient Boosting

（6）Gradient Boosting --- 不同损失函数

• 对分类问题，损失函数取负log似然损失，得到logitBoosting。
• 对回归问题，损失函数可取L2损失，得到L2boosting。

（6.1）L2Boosting

对于L2损失，定义为： L ( f ( x ) , y ) = 1 2 ( f ( x ) − y ) 2 L(f(x), y) = \frac{1}{2}(f(x) - y)^2 L(f(x),y)=21(f(x)−y)2

损失函数关于 f f f的导数是预测残差：
∂ L ( f ) ∂ f = f ( x i ) − y i \frac{\partial L(f)}{\partial f} = f(x_i) - y_i ∂f∂L(f)=f(xi)−yi

初始化模型为： f 0 ( x ) = y ˉ f_0(x) = \bar{y} f0(x)=yˉ

在第 m m m步，第 i i i个样本的负梯度为：
r m , i = − [ ∂ L ( f ) ∂ f ] f = f m − 1 = − ( f m − 1 ( x i ) − y i ) = y i − f m − 1 ( x i ) r_{m,i} = -\left[ \frac{\partial L(f)}{\partial f} \right]{f=f{m-1}} = -(f_{m-1}(x_i) - y_i) = y_i - f_{m-1}(x_i) rm,i=−[∂f∂L(f)]f=fm−1=−(fm−1(xi)−yi)=yi−fm−1(xi)

不失一般性，假设学习率 η = 1 \eta = 1 η=1，因此用弱学习器来预测残差 r m r_m rm，称为L2Boosting。

在L2Boosting中，我们使用L2损失函数，即均方误差，来衡量模型预测值与真实值之间的差距。通过计算损失函数关于模型预测的导数，我们可以得到每个样本的残差，即预测值与真实值之间的差异。然后，我们用弱学习器来拟合这些残差，以此来更新模型。这种方法在每一步都直接针对残差进行优化，从而逐步提高模型的预测准确性。

例：回归

数据：薪水（Salary）与工作年限（Years）之间的关系

- 损失函数：MSE（均方误差）

- 初始化（最小化MSE）： f 0 ( x ) = y ˉ = 1 N ∑ i = 1 N y i = 134 f_0(x) = \bar{y} = \frac{1}{N} \sum_{i=1}^{N} y_i = 134 f0(x)=yˉ=N1∑i=1Nyi=134

Years( x x x)	Salary( y y y)	f 0 f_0 f0	y − f 0 y - f_0 y−f0
5	82	134	-52
7	80	134	-54
12	103	134	-31
23	118	134	-16
25	172	134	38
28	127	134	-7
29	204	134	70
34	189	134	55
35	99	134	-35
40	166	134	32

训练数据

- 初始化（最小化MSE）： f 0 ( x ) = y ˉ f_0(x) = \bar{y} f0(x)=yˉ

- 训练数据 { x i , r i } i = 1 N \{x_i, r_i\}_{i=1}^{N} {xi,ri}i=1N， ϕ 1 ( x ) = { − 38.5 x ≤ 23 25.5 x > 23 \phi_1(x) = \begin{cases} -38.5 & x \leq 23 \\ 25.5 & x > 23 \end{cases} ϕ1(x)={−38.525.5x≤23x>23， f 1 ( x ) = f 0 ( x ) + ϕ 1 ( x ) f_1(x) = f_0(x) + \phi_1(x) f1(x)=f0(x)+ϕ1(x)

Years( x x x)	Salary( y y y)	f 0 f_0 f0	y − f 0 y - f_0 y−f0	ϕ 1 \phi_1 ϕ1	f 1 f_1 f1	y − f 1 y - f_1 y−f1
5	82	134	-52	-38.25	95.75	-13.75
7	80	134	-54	-38.25	95.75	-15.75
12	103	134	-31	-38.25	95.75	7.25
23	118	134	-16	-38.25	95.75	22.25
25	172	134	38	25.5	159.5	12.5
28	127	134	-7	25.5	159.5	-32.5
29	204	134	70	25.5	159.5	44.5
34	189	134	55	25.5	159.5	29.5
35	99	134	-35	25.5	159.5	-60.5
40	166	134	32	25.5	159.5	6.5

训练数据（继续）

- 训练数据 { x i , r i } i = 1 N \{x_i, r_i\}_{i=1}^{N} {xi,ri}i=1N， ϕ 2 ( x ) = { 6.75 x ≤ 34 − 27 x > 34 \phi_2(x) = \begin{cases} 6.75 & x \leq 34 \\ -27 & x > 34 \end{cases} ϕ2(x)={6.75−27x≤34x>34， f 2 ( x ) = f 1 ( x ) + ϕ 2 ( x ) f_2(x) = f_1(x) + \phi_2(x) f2(x)=f1(x)+ϕ2(x)

Years( x x x)	Salary( y y y)	f 0 f_0 f0	y − f 0 y - f_0 y−f0	ϕ 1 \phi_1 ϕ1	f 1 f_1 f1	y − f 1 y - f_1 y−f1	ϕ 2 \phi_2 ϕ2	f 2 f_2 f2	y − f 2 y - f_2 y−f2
5	82	134	-52	-38.25	95.75	-13.75	6.75	102.50	-20.50
7	80	134	-54	-38.25	95.75	-15.75	6.75	102.50	-22.50
12	103	134	-31	-38.25	95.75	7.25	6.75	102.50	0.50
23	118	134	-16	-38.25	95.75	22.25	6.75	102.50	15.60
25	172	134	38	25.5	159.5	12.5	6.75	166.25	5.75
28	127	134	-7	25.5	159.5	-32.5	6.75	166.25	-39.25
29	204	134	70	25.5	159.5	44.5	6.75	166.25	37.75
34	189	134	55	25.5	159.5	29.5	6.75	166.25	22.75
35	99	134	-35	25.5	159.5	-60.5	-27.00	132.50	-33.50
40	166	134	32	25.5	159.5	6.5	-27.00	132.50	33.50

训练数据（继续）

- 训练数据 { x i , r i } i = 1 N \{x_i, r_i\}_{i=1}^{N} {xi,ri}i=1N， ϕ 3 ( x ) = { − 10.083333 x ≤ 28 15.125000 x > 28 \phi_3(x) = \begin{cases} -10.083333 & x \leq 28 \\ 15.125000 & x > 28 \end{cases} ϕ3(x)={−10.08333315.125000x≤28x>28， f 3 ( x ) = f 2 ( x ) + ϕ 3 ( x ) f_3(x) = f_2(x) + \phi_3(x) f3(x)=f2(x)+ϕ3(x)

Years( x x x)	Salary( y y y)	f 0 f_0 f0	y − f 0 y - f_0 y−f0	ϕ 1 \phi_1 ϕ1	f 1 f_1 f1	y − f 1 y - f_1 y−f1	ϕ 2 \phi_2 ϕ2	f 2 f_2 f2	y − f 2 y - f_2 y−f2	ϕ 3 \phi_3 ϕ3	f 3 f_3 f3
5	82	134	-52	-38.25	95.75	-13.75	6.75	102.50	-20.50	-10.083333	92.416667
7	80	134	-54	-38.25	95.75	-15.75	6.75	102.50	-22.50	-10.083333	92.416667
12	103	134	-31	-38.25	95.75	7.25	6.75	102.50	0.50	-10.083333	92.416667
23	118	134	-16	-38.25	95.75	22.25	6.75	102.50	15.60	-10.083333	92.416667
25	172	134	38	25.5	159.5	12.5	6.75	166.25	5.75	-10.083333	156.166667
28	127	134	-7	25.5	159.5	-32.5	6.75	166.25	-39.25	-10.083333	156.166667
29	204	134	70	25.5	159.5	44.5	6.75	166.25	37.75	15.125000	181.375000
34	189	134	55	25.5	159.5	29.5	6.75	166.25	22.75	15.125000	181.375000
35	99	134	-35	25.5	159.5	-60.5	-27.00	132.50	-33.50	15.125000	147.625000
40	166	134	32	25.5	159.5	6.5	-27.00	132.50	33.50	15.125000	147.625000

结果分析

- f 1 f_1 f1、 f 2 f_2 f2和 f 3 f_3 f3 的MSE分别为875, 692、540

- 弱学习器 ϕ m \phi_m ϕm：学习残差（负梯度）与输入之间的关系

最后残差倾向于白噪声，没有模式，无需再学习器

（6.2）logitBoosting

对于 K K K类分类问题，对标签 y = k y = k y=k进行独热编码为向量： y = ( 0 , 0 , . . . , 1 , 0 , . . . , 0 ) T y = (0, 0, ..., 1, 0, ..., 0)^T y=(0,0,...,1,0,...,0)T，其中 y k = 1 y_k = 1 yk=1， y k ′ = 0 y_{k'} = 0 yk′=0， k ′ = 1 , 2 , . . . , K k' = 1, 2, ..., K k′=1,2,...,K且 k ′ ≠ k k' \neq k k′=k。

交叉熵损失： L ( f ( x ) , y ) = − ∑ k = 1 K y k ln ⁡ ( p k ) L(f(x), y) = -\sum_{k=1}^{K} y_k \ln(p_k) L(f(x),y)=−∑k=1Kykln(pk)，

其中
p m ( x ) = exp ⁡ ( f m ( x ) ) ∑ j = 1 K exp ⁡ ( f j ( x ) ) m = 1 , 2 , . . . , K , f ( x ) = ( f 1 ( x ) , f 2 ( x ) , . . . , f K ( x ) ) p_m(x) = \frac{\exp(f_m(x))}{\sum_{j=1}^{K} \exp(f_j(x))} \quad m = 1, 2, ..., K, f(x) = (f_1(x), f_2(x), ..., f_K(x)) pm(x)=∑j=1Kexp(fj(x))exp(fm(x))m=1,2,...,K,f(x)=(f1(x),f2(x),...,fK(x))

损失函数关于 f m f_m fm的导数为：
∂ L ( f ( x ) , y ) ∂ f m = ∑ k = 1 K ∂ L ( f ( x ) , y ) ∂ p k ∂ p k ∂ f m = − ∑ k = 1 K y k p k ∂ p k ∂ f m = p m − y m \frac{\partial L(f(x), y)}{\partial f_m} = \sum_{k=1}^{K} \frac{\partial L(f(x), y)}{\partial p_k} \frac{\partial p_k}{\partial f_m} = -\sum_{k=1}^{K} \frac{y_k}{p_k} \frac{\partial p_k}{\partial f_m} = p_m - y_m ∂fm∂L(f(x),y)=k=1∑K∂pk∂L(f(x),y)∂fm∂pk=−k=1∑Kpkyk∂fm∂pk=pm−ym

导数计算

当 k = m k = m k=m时，
∂ p m ∂ f m = ∂ ∂ f m ( exp ⁡ ( f m ( x ) ) ∑ j = 1 K exp ⁡ ( f j ( x ) ) ) = exp ⁡ ( f m ( x ) ) ∑ j = 1 K exp ⁡ ( f j ( x ) ) − exp ⁡ ( f m ( x ) ) exp ⁡ ( f m ( x ) ) ( ∑ j = 1 K exp ⁡ ( f j ( x ) ) ) 2 = p m ( 1 − p m ) \frac{\partial p_m}{\partial f_m} = \frac{\partial}{\partial f_m} \left( \frac{\exp(f_m(x))}{\sum_{j=1}^{K} \exp(f_j(x))} \right) = \frac{\exp(f_m(x)) \sum_{j=1}^{K} \exp(f_j(x)) - \exp(f_m(x)) \exp(f_m(x))}{\left( \sum_{j=1}^{K} \exp(f_j(x)) \right)^2} = p_m(1 - p_m) ∂fm∂pm=∂fm∂(∑j=1Kexp(fj(x))exp(fm(x)))=(∑j=1Kexp(fj(x)))2exp(fm(x))∑j=1Kexp(fj(x))−exp(fm(x))exp(fm(x))=pm(1−pm)
当 k ≠ m k \neq m k=m时，
∂ p k ∂ f m = ∂ ∂ f m ( exp ⁡ ( f k ( x ) ) ∑ j = 1 K exp ⁡ ( f j ( x ) ) ) = 0 − exp ⁡ ( f k ( x ) ) exp ⁡ ( f m ( x ) ) ( ∑ j = 1 K exp ⁡ ( f j ( x ) ) ) 2 = − p k p m \frac{\partial p_k}{\partial f_m} = \frac{\partial}{\partial f_m} \left( \frac{\exp(f_k(x))}{\sum_{j=1}^{K} \exp(f_j(x))} \right) = \frac{0 - \exp(f_k(x)) \exp(f_m(x))}{\left( \sum_{j=1}^{K} \exp(f_j(x)) \right)^2} = -p_k p_m ∂fm∂pk=∂fm∂(∑j=1Kexp(fj(x))exp(fk(x)))=(∑j=1Kexp(fj(x)))20−exp(fk(x))exp(fm(x))=−pkpm
总结

因此，
∂ L ( f ( x ) , y ) ∂ f m = − ∑ k = 1 K y k p k ∂ p k ∂ f m \frac{\partial L(f(x), y)}{\partial f_m} = -\sum_{k=1}^{K} \frac{y_k}{p_k} \frac{\partial p_k}{\partial f_m} ∂fm∂L(f(x),y)=−k=1∑Kpkyk∂fm∂pk
= − y m p m p m ( 1 − p m ) + ∑ k ≠ m y k p k p k p m = -\frac{y_m}{p_m} p_m(1 - p_m) + \sum_{k \neq m} \frac{y_k}{p_k} p_k p_m =−pmympm(1−pm)+k=m∑pkykpkpm
= − y m ( 1 − p m ) + ∑ k ≠ m y k p m = -y_m(1 - p_m) + \sum_{k \neq m} y_k p_m =−ym(1−pm)+k=m∑ykpm
= ∑ k = 1 K y k p m − y m = p m − y m = \sum_{k=1}^{K} y_k p_m - y_m = p_m - y_m =k=1∑Kykpm−ym=pm−ym

LogitBoosting算法

初始化： f 0 , k ( x ) = 0 , k = 1 , 2 , . . . , K f_{0,k}(x) = 0, k = 1, 2, ..., K f0,k(x)=0,k=1,2,...,K

在第 m m m步，第 i i i个样本负梯度为：

• 用当前的强学习器预测每个样本为第 k k k类的概率： p k ( x ) = exp ⁡ ( f m , k ( x ) ) ∑ j = 1 K exp ⁡ ( f m , j ( x ) ) p_k(x) = \frac{\exp(f_{m,k}(x))}{\sum_{j=1}^{K} \exp(f_{m,j}(x))} pk(x)=∑j=1Kexp(fm,j(x))exp(fm,k(x))
• 对每个类别 k = 1 , 2 , . . . , K k = 1, 2, ..., K k=1,2,...,K
• 计算负梯度： − g m , i = − ∂ L ( f m , k ( x ) , y ) ∂ f k = y i , k − p m , k ( x i ) -g_{m,i} = -\frac{\partial L(f_{m,k}(x), y)}{\partial f_k} = y_{i,k} - p_{m,k}(x_i) −gm,i=−∂fk∂L(fm,k(x),y)=yi,k−pm,k(xi)（预测残差）
• 以 { x i , − g m , i } i = 1 N \{x_i, -g_{m,i}\}_{i=1}^{N} {xi,−gm,i}i=1N为训练数据，训练一个弱学习器（如用于回归的决策树）

Shrinkage

通常对系数增加一个小的收缩因子(亦被称为学习率)，测试性能更好
f m ( x i ) = f m − 1 ( x i ) + η ϕ m ( x i ) f_m(x_i) = f_{m-1}(x_i) + \eta \phi_m(x_i) fm(xi)=fm−1(xi)+ηϕm(xi)

其中 0 < η < 1 0 < \eta < 1 0<η<1，通常取一个较小的值，如 η = 0.01 \eta = 0.01 η=0.01。

较小的收缩因子通常意味着更多弱分学习器。