【机器学习】集成学习

最新推荐文章于 2024-05-16 08:29:31 发布

S大幕

最新推荐文章于 2024-05-16 08:29:31 发布

阅读量662

点赞数

分类专栏：机器学习

本文链接：https://blog.csdn.net/qq_34784753/article/details/79577688

版权

机器学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

集成学习（ensemble learning）通过构建并结合多个学习起来完成学习任务，有时也被称为多分类器系统（multi-classifer system)、基于委员会的学习等等。

通过不同的方式来将多个分类器结合成为一个强分类器，具体可以分为“同质集成”和“异质集成”。其中，同质指的是最后构建的分类器系统仅仅由一种相同的基分类器构成，而异质指的是最后构建的分类器系统由不仅一种基分类器构成，这时候基分类器一般也不叫基分类器，而是“组件学习器”。

需要说明的是，将一系列的若学习器结合在一起构成想要构成一个更强的学习器（分类器）也是有要求的，也就是说，想要获得好的集成，应当：

个体学习器应该有一定的 “准确性”
个体学习器之间应该有一定的 ”差异“

总的来说，就是要个体分类器之间做到 ”好而不同“。

但是，所有用来集成的个体学习器都是为了解决同一个问题训练得来的，因此它们显然不可能相互独立，事实上，个体学习器之间的 “准确性” 与 “多样性” 本身就存在着冲突。一般的，在准确性很高之后，想要增加多样性，就要牺牲一定的准确性。

根据个体学习器的生成方式，目前的集成学习方法大致可以分成两大类：

个体学习器之间存在前依赖关系，必须穿串行生成的序列化方法
个体学习器之间不存在强依赖关系、可同时生成的并行化方法；

第一种的代表方法是 “boosting”，后面一中的代表方法是 “Bagging” 和 “随机森林”。

1. 结合策略

这部分参考集成学习原理小结

假设用来进行集成学习的几个分类器分别为 $\{h_1,h_2,...,h_m\}$

平均结合法：

对于数值类的回归问题，通常使用的结合策略是平均法，也就是说，对于若干和若学习器的输出进行平均得到最终的预测输出。
- 算术平均，即为：
  
  $H (x) = 1 T \sum 1 T h i (x)$ $H(x)=\frac{1}{T}\sum_1^Th_i(x)$
- 加权结合，假设每个学习器有一个权重 $w$
$H (x) = \sum_{i = 1}^{T} w_{i} h_{i} (x)$

其中 $w_i$ 是个体学习器 $h_i$ 的权重，通常有：

wi≥0, ∑i=1Twi=1
投票法：

对于分类问题的预测，我们通常使用的是投票法，假设我们的预测类别是 $\{c_1,c_2,...,c_k\}$ ，对于任意一个预测样本 $x$ ，我们的 $T$ 个若学习器的预测结果是 $\{h_1(x),h_2(x),...,h_T(x)\}$ 。

a. 相对多数投票法，也就是我们常说的少数服从多数。如果最后不止一个类别获得了最高票数，则随机选择一个做最终的类别。

b. 绝对多数投票法，也就是我们常说的票数必须要过半。在上面相对多数投票法的基础上，不光要求获得最高票数，同时要求票数必须过半，否则学习器会拒绝预测。

c. 加权投票法，与健全平均法一样，每个若学习器的分类票数要乘以一个权重，最终将各个来别的加权票数进行求和，最大的值对应的类别为最重类别。
学习法：

上面的方法都是对弱学习器的结果做平均或者投票，相对比较简单，但是可能学习误差较大，于是就有了学习法这种方法，对于学习法，代表方法是stacking，当使用stacking的结合策略时，我们不是对弱学习器的结果做简单的逻辑处理，而是 再加上一层学习器，也就是说，我们将训练集弱学习器的学习结果作为输入，将训练集的输出作为输出，重新训练一个学习器来得到最终结果。

在这种情况下，我们将弱学习器称为初级学习器，将用于结合的学习器称为次级学习器。对于测试集，我们首先用初级学习器预测一次，得到次级学习器的输入样本，再用次级学习器预测一次，得到最终的预测结果。

2. Boosting

Boosting 算法是一族可以将若学习器提升为强学习器的算法。工作机制大致如下：

首先从出事训练集训练出一个及学习期。
在根据基学习器的表现对训练样本进行调整，使得新签基学习器做错的训练样本在后续受到更多的关注
基于调整后的样本分布来训练下一个基学习器
如此冲进行，直到基学习器数目达到了事先指定的数目 $T$ ，最终将这 $T$ 个基学习器进行加权结合

上面的步骤中最后一个写到了 “进行加权结合”，这种加权结合是一种平均结合方法。关于结合方法在上面已经进行了相关的介绍。

2.1 Adaboost

对于所有的 Boosting 算法来说，都有两个问题需要解答：

在每一轮如何改变训练数据的权值或概率分布？
如何将弱分类器组合成为一个强分类器？

关于问题一，Adaboost 的做法是：

提高那些前一轮被错误分类样本的权值，而降低那些前一轮被正确分类的样本的权值。

关于问题二，Adaboost 的做法是：

采用加权多数表决的方法。也就是说，加大分类误差率小的弱分类器的权值，使其在表决中起较大的作用，减小分类误差率大的弱分类器的权值，使其在表决中起比较小的作用。

2.1.1 Adaboost 算法

假设给定一个二分类的训练数据集：

T = {(x 1, y 1), (x 2, y 2) m, . . ., (x N, y N)}

$T=\{(x_1,y_1),(x_2,y_2)m,...,(x_N,y_N)\}$
其中，每个样本点由实例与标记组成。其中，实例

x∈X⊆Rn x ∈ X ⊆ R n $x\in\mathcal{X}\subseteq \textbf{R}^n$ ，标记

y∈Y={−1,+1} y ∈ Y = { − 1 , + 1 } $y\in\mathcal{Y}=\{-1,+1\}$ ，其中

X X $\mathcal{X}$ 是实例空间，

Y Y $\mathcal{Y}$ 是标记集合。Adaboost 使用下面的算法，从训练数据中学习出一系列弱分类器或是基本分类器，并将这些弱分类器 线性组合 成为一个强分类器。

输入：训练数据集 $T=\{(x_1,y_1),(x_2,y_2)m,...,(x_N,y_N)\}$ ，其中 $x\in\mathcal{X}\subseteq \textbf{R}^n, y\in\mathcal{Y}=\{-1,+1\}$ ；弱学习算法；
输出：最终分类器 $G(x)$ ；
1. 初始化训练数据的权值分布：
  
  $D 1 = (w 11, . . ., w 1 i, . . ., w 1 N), w 1 i = 1 N, i = 1, 2, . . N$ $D_1=(w_{11},...,w_{1i},...,w_{1N}),\ \ \ \ \ w_{1i}=\frac{1}{N},\ \ \ i=1,2,..N$
2. 对于 $m=1,2,...,M$
  - 使用具有权值分布 $D_m$ 的训练数据集学习，得到基本分类器：
    
    $G m (x) : X \to {- 1, + 1}$ $G_m(x):\mathcal{X}\rightarrow \{-1,+1\}$
  - 计算 $G_m$ 在训练数据机上的分类误差率：
em=P(Gm(xi)≠yi)=∑i=1NwmiI(Gm(xi)≠yi)
- 计算 $G_m(x)$ 的系数
  
  $α m = 1 2 l o g 1 - e m e m$ $\alpha_m=\frac{1}{2}log\frac{1-e_m}{e_m}$
  这里的对数指的是自然对数，也就是 $ln$ 。
- 更新训练数据集的权值分布：
  
  Dm+1=(wm+1,1,...,wm+1,i,...,wm+1,N)wm+1,i=wmiZmexp(−αmyiGm(xi)), i=1,2,...,N
  
  这里 Zm 是规范化因子：
  
  Zm=∑i=1Nwmiexp(−αmyiGm(xi))
  
  它的作用是使得 Dm+1 成为一个概率分布
  1. 构建基本分类器的线性组合

f (x) = \sum m = 1 M α m G m (x)

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

从而进一步得到最终的分类器：

G (x) = s i g n (f (x)) = s i g n (\sum m = 1 M α m G m (x))

$G(x)=sign(f(x))=sign\left(\sum_{m=1}^M\alpha_mG_m(x)\right)$

2.1.2 算法说明

步骤 1：假设悬链数据基友均匀的权值分布，也就是每个训练样本在基本分类器的学习中作用相同，这一假设保证了第一步能够在原始数据上学习基本分类器 $G_1(x)$ 。

步骤 2：Adaboost 反复学习基本分类器，在每一轮 $m=1,2,...,M$ 顺序地执行下面的操作：

使用当前分布 $D_m$ 加权的训练数据集，学习基本分类器 $G_m(x)$ .
计算基本分类器 $G_m(x)$ 在加权训练数据集上的分类误差率：

$e m = P (G m (x i) \neq y i) = \sum G m (x i) \neq y i w m i$ $e_m=P(G_m(x_i)\neq y_i)=\sum_{G_m(x_i)\neq y_i}w_{mi}$
这里， $w_{mi}$ 表示第 $m$ 轮中第 $i$ 个实例的权值， $\sum_{i=1}^{N}w_{mi}=1$ 。这表明， $G_m$ 在加权的训练数据集上的分类误差率是被 $G_m(x)$ 误分类样本的权值之和，由此可以看出权值分布 $D_m$ 与基本分类器 $G_m(x)$ 的分类误差率的关系。
计算基本分类器 $G_m(x)$ 的系数 $\alpha_m$ 。这个 $\alpha_m$ 表示 $G_m(x)$ 在最终分类器中的重要性。由上面的表达式可以知道，当 $e_m<\frac{1}{2}$ 时， $\alpha_m \geq 0$ 。并且 $\alpha_m$ 随着 $e_m$ 的减小而增大，所以分类误差率越小的基本分类器在最终分类器中的作用越大。

给出图像：

这里写图片描述

更新训练数据的取值分布为下一轮做准备，上面的更新公式可以化简为：

w m + 1, i = ⎧ ⎩ ⎨ ⎪ ⎪ ⎪ ⎪ w m i Z m e - α m, G m (x i) = y i w m i Z m e α m, G m (x i) \neq y i (1) (2)

$w_{m+1,i}=\left\{ \begin{align} \frac{w_{mi}}{Z_m}e^{-\alpha_m},\ \ \ G_m(x_i)=y_i \\ \frac{w_{mi}}{Z_m}e^{\alpha_m},\ \ \ G_m(x_i)\neq y_i \end{align} \right.$

从上面这个公式可以看出，被基本分类器 $G_m(x)$ 误分类样本的权值得以扩大，而被正确分类样本的权值却得以缩小。两者相互比较，误分类样本的权值被放大了 $e^{2\alpha_m}=\frac{e_m}{1-e_m}$ 倍，因此，误分类样本在下一轮学习中会起到更大的作用。

不改变所给的训练数据，而不断改变训练数据权值的分布，使得训练数据在基本分类器的学习中起不同的作用，这也正是 $Adaboost$ 的一个特点。

步骤 3：线性组合 $f(x)$ 实现 $M$ 个基本分类器的加权表决。系数 $\alpha_m$ 表示了基本分类器 $G_m(x)$ 的重要性，这里，所有的 $\alpha_m$ 之和并不为 1。其中， $f(x)$ 的符号决定实例 $x$ 的类， $f(x)$ 的绝对值标识分类的确信度。利用基本分类器的线性组合构建最终分类器是 $Adaboost$ 的另一个特点。

2.1.3 前向分步算法与 AdaBoost

由前向分步算法可以推导出 $Adaboost$ ，使用定理叙述这一关系。

定理： Adaboost 算法是前向分步加法算法的特例。这时，模型是有基本分类器组成的加法模型，损失函数是指数函数。

证明：前向分步算法学习的是加法模型，当基函数为基本分类器时，该加法模型等价于 $AdaBoost$ 的最终分类器：

f (x) = \sum m = 1 N α m G m (x)

$f(x)=\sum_{m=1}^N\alpha_mG_m(x)$
从上式可以看出，最终分类器是由基本分类器

Gm(x) G m ( x ) $G_m(x)$ 以及其系数

αm α m $\alpha_m$ 组成的，其中，

m=1,2,...,M m = 1 , 2 , . . . , M $m=1,2,...,M$

前向分步算法逐一学习基函数，这一过程与 Adaboost 算法逐一学习基本分类器的过程是一致的。下面给出证明，当前向分步算法的损失函数是指数损失函数的时候，其学习的具体操作等价于 $AdaBoost$ 算法学习的具体操作。其中，指数损失函数为：

L (y, f (x)) = e x p [- y f (x)]

$L(y,f(x))=exp[-yf(x)]$

假设经过 $m-1$ 轮的迭代前向分步算法已经得到了 $f_{m-1}(x)$ :

f m - 1 (x) = \sum i = 1 m - 1 α i G i (x)

$f_{m-1}(x)=\sum_{i=1}^{m-1}\alpha_iG_i(x)$
而第

m m $m$ 轮强学习器可以表述为：

f_{m} (x) = \sum_{i = 1}^{m} α_{i} G_{i} (x)

$f_m(x)=\sum_{i=1}^m\alpha_iG_i(x)$
通过上面两个式子可以的得到：

f m (x) = f m - 1 (x) α m G m (x)

$f_m(x)=f_{m-1}(x)\alpha_mG_m(x)$
学习的目标是使得前向分步算法得到的

αm,Gm(x) α m , G m ( x ) $\alpha_m,G_m(x)$ 使得

fm(x) f m ( x ) $f_m(x)$ 在训练数据集

T T $T$ 上的指数损失最小，也就是有：

(α_{m}, G_{m} (x)) = a r g m i n_{α, G} \sum_{i = 1}^{N} e x p [- y_{i} (f_{m - 1} x_{i}) + α G (x_{i})]

$(\alpha_m,G_m(x))=arg\ min_{\alpha,G}\sum_{i=1}^Nexp[-y_i(f_{m-1}x_i)+\alpha G(x_i)]$
上式可以表示为：

(α m, G m (x)) = a r g m i n α, G \sum i = 1 N w ¯ m i e x p (- y i α G (x i))

$(\alpha_m,G_m(x))=arg\ min_{\alpha,G}\sum_{i=1}^N\bar{w}_{mi}exp(-y_i\alpha G(x_i))$
其中，

w¯mi=exp(−yifm−1(xi)) w ¯ m i = e x p ( − y i f m − 1 ( x i ) ) $\bar{w}_{mi}=exp(-y_if_{m-1}(x_i))$ ，因为这个项既不依赖

α α $\alpha$ 也不依赖

G G $G$ ，因此与最小化无关。但是

{\bar{w}}_{m} i

$\bar{w}_mi$ 依赖于

fm−1(x) f m − 1 ( x ) $f_{m-1}(x)$ ，会随着每一轮的迭代而改变。

因此现在就是要证明上式中能够达到最小的 $\alpha, G$ 就是 $Adaboost$ 算法所得到的 $\alpha_m,G_m(x)$ 。

首先，求 $G_m^*(x)$ 。对于任意的 $\alpha>0$ ，上式中最小的 $G(x)$ 由下面的式子得到：

$G * m (x) = a r g m i n G \sum i = 1 N w ¯ m i I (y i \neq G (x x i))$ $G_m^*(x)=arg\ min_G\sum_{i=1}^N\bar{w}_{mi}I(y_i\neq G(x_xi))$
其中， $\bar{w}_{mi}=exp[-y_if_{m-1}(x_i)]$

这个分类器 $G_m^*(x)$ 也就是 $AdaBoost$ 算法的基本分类器 $G_m(x)$ ，因为它是使第 $m$ 轮家犬训练数据分类误差率最小的基本分类器
然后，求 $\alpha_m^*$ 。将上面 $G_m^*$ 的表达式带入到征途的损失中，可以得到：

$\sum i = 1 N w ¯ m i e x p [- y i α G (x i)] = \sum y = G m (x i) w ¯ m i e - α + \sum y \neq G m (x i) w ¯ m i e α = (e α - e - α) \sum i = 1 N w ¯ m i I (y i \neq G (x i)) + e - α \sum i = 1 N w ¯ m i$ $\sum_{i=1}^N\bar{w}_{mi}exp[-y_i\alpha G(x_i)]=\sum_{y=G_m(x_i)}\bar{w}_{mi}e^{-\alpha}+\sum_{y\neq G_m(x_i)}\bar{w}_{mi}e^{\alpha}\\ =(e^{\alpha}-e^{-\alpha})\sum_{i=1}^N\bar{w}_{mi}I(y_i\neq G(x_i))+e^{-\alpha}\sum_{i=1}^N\bar{w}_{mi}$
上式对 $\alpha$ 进行求导可得：

$α * m = 1 2 l o g 1 - e m e m$ $\alpha_m^*=\frac{1}{2}log\frac{1-e_m}{e_m}$
其中， $e_m$ 是分类误差率：
$e m = \sum N i = 1 w ¯ m i I ( y i \neq G m ( x i ) ) \sum N i = 1 w ¯ m i = \sum i = 1 N w m i I (y i \neq G m (x i))$ $e_m=\frac{\sum_{i=1}^N\bar{w}_{mi}I(y_i\neq G_m(x_i))}{\sum_{i=1}^{N}\bar{w}_{mi}}=\sum_{i=1}^Nw_{mi}I(y_i\neq G_m(x_i))$
可以看到，这里的 $\alpha_m^*$ 与 Adaboost 算法中的更新权重完全相同。

2.1.4 AdaBoost 算法的正则化

为了防止 Adaboost 算法的过拟合，通常情况下也会增加正则化项，这个正则化项我们通常称为 步长（learning rate）。定义为 $\mathcal{v}$ ，对于前面的若学习期的迭代：

f k (x) = f k - 1 (x) + α k G k (x)

$f_k(x)=f_{k-1}(x)+\alpha_kG_k(x)$
如果我们增加了正则化项，则有：

f k (x) = f k - 1 (x) + v α k G k (x)

$f_k(x)=f_{k-1}(x)+\mathcal{v}\alpha_kG_k(x)$
其中，

v v $\mathcal{v}$ 的取值范围是

0<v<1 0 < v < 1 $0<\mathcal{v}<1$ 。对于同样的训练集学习效果，较小的

v v $\mathcal{v}$ 意味着我们需要更多地弱学习器的迭代次数。通常我们使用补偿和迭代最大次数一起来决定算法的拟合效果。

2.1.5 Adaboost 总结

这里需要说明，构成 Adaboost 的若学习器的理论上可以使用任何学习器。但是一般来说，使用最广泛的 Adaboost 若学习器是决策树和神经网络。对于决策树，Adaboost 分类使用的是 CART 分类树，而回归分体使用的是 CART 的回归树。

优点：
1. 作为分类器时，分类的精度很高；
2. 在 Adaboost 的框架下，可以使用各种分类回归模型来构建弱学习器，非常灵活。
3. 作为简单的二元分类器时，构造简单，结果可以理解。
4. 不容易发生过拟合
缺点：
1. 对异常样本十分敏感，异常样本在迭代中可能会获得比较高的权重，影响最终的强学习期的准确性能。

2.2 GBDT

GBDT —— 梯度提升树。

GBDT 也是集成学习中属于 Boosting 范畴的内容，确实和传统的 Adaboost 也有区别。GBDT 是使用前向分步算法进行迭代，组成最后强学习器的弱学习器也被限定为只能使用 CART 回归树模型，同事迭代思路也和之前的 Adaboost 不同。

在 GBDT 的迭代过程中没假设前一轮迭代得到的强学习器是 $f_{t-1}(x)$ ，且有损失函数 $L(y,f_{t-1}(x))$ 。那么，这一轮迭代的目标就是找到一个 CART 回归树模型的弱学习器 $h_t(x)$ ，使得本轮的损失的损失 $L(y,f_t(x))=L(y,f_{t-1}(x)+h_t(x))$ 最小。也就是说，本轮迭代要找到的决策树，要使得样本的损失尽量变得更小。

2.2.1 负梯度拟合

现在的问题也就变成了如何才能拟合损失函数的问题。通常的做法是使用 损失函数的负梯度来拟合本轮损失的近似值，进而拟合成为一个 CART 回归树。第 $t$ 轮的第 $i$ 个样本的损失函数的负梯度可以表示为：

r t i = - [\partial L ( y i , f ( x i ) ) \partial f ( x i )] f (x) - f t - 1 (x)

$r_{ti}=-\left[\frac{\partial L(y_i,f(x_i))}{\partial f(x_i)}\right]_{f(x)-f_{t-1}(x)}$
这样我们使用

(xi,rti) (i=1,2,..,m) ( x i , r t i ) ( i = 1 , 2 , . . , m ) $(x_i,r_{ti})\ \ \ (i=1,2,..,m)$ ，我们可以拟合一棵 CART 回归树，到了第

t t $t$ 棵回归树，其对应的叶节点区域

R_{t j}, j = 1, 2, . . ., J

$R_{tj},j=1,2,...,J$ ，其中

J J $J$ 为叶子结点的个数。

针对每一个叶子结点里的样本，我们求出是损失函数最小，也就是拟合叶子结点最好的输出值 $c_{tj}$ 如下所示：

c t j = a r g m i n c \sum x i \in R t j L (y i, f t - 1 (x i) + c)

$c_{tj}=arg\ min_c\sum_{x_i\in R_{tj}}L(y_i,f_{t-1}(x_i)+c)$

这样我们也就得到了本轮的决策树拟合函数如下所示：

h t (x) = \sum j = 1 J c t j I (x \in R t j)

$h_t(x)=\sum_{j=1}^Jc_{tj}I(x\in R_{tj})$

从而本轮最终得到的强学习器的表达式如下所示：

f t (x) = f t - 1 (x) + \sum j = 1 J c t j I (x \in R t j)

$f_t(x)=f_{t-1}(x)+\sum_{j=1}^Jc_{tj}I(x\in R_{tj})$
通过使用损失函数的负梯度来进行拟合，找到了一种通用的用来拟合损失误差的方法，这样无论是分类问题还是回归问题，我么能通过其损失函数的负梯度进行拟合，就可以用 GBDT 来解决我们的分类回归问题。区别仅仅在于损失函数不同导致的负梯度不同而已。

2.2.2 GBDT 的回归算法

一直一个训练数据集 $T={(x_1,y_1),(x_2,y_2),...,(x_N,y_N)},x_i\in\mathcal{X}\subseteq \textbf{R}^n$ ，其中 $\mathcal{X}$ 为输入空间， $y_i\in \mathcal{Y}\subseteq \textbf{R}$ ，其中 $\mathcal{Y}$ 是输出空间。

对于回归树来说，如果将输入空间 $\mathcal{X}$ 划分为 $J$ 个互不相交的区域 $R_1,R_2,...,R_J$ ，并且在每个区域上确定输出的常量 $c_j$ ，那么这个回归树可以表示为：

T (x; Θ) = \sum j = 1 J c j I (x \in R j)

$T(x;\Theta)=\sum_{j=1}^Jc_jI(x\in R_j)$
其中，参数

Θ={(R1,c1),(R2,c2),...,(RJ,cJ),} Θ = { ( R 1 , c 1 ) , ( R 2 , c 2 ) , . . . , ( R J , c J ) , } $\Theta = \{(R_1,c_1),(R_2,c_2),...,(R_J,c_J),\}$ 表示树的区域划分和各个区域上的常数。

J J $J$ 是回归树的复杂度，也就是叶节点的个数。

回归问题提升树使用以下前向分步算法：

\begin{aligned} (3) & f_{0} (x) & = 0 \\ (4) & f_{m} (x) & = f_{m - 1} (x) + T (x; Θ), m = 1, 2, . . ., M \\ (5) & f_{M} (x) & = \sum_{m = 1}^{M} T (x; Θ_{m}) \end{aligned}

$\begin{align} f_0(x)&=0\\ f_m(x)&=f_{m-1}(x)+T(x;\Theta),\ \ \ m=1,2,...,M\\ f_M(x)&=\sum_{m=1}^MT(x;\Theta_m) \end{align}$
在当前分布算法的第

m m $m$ 步，给定当前模型

f_{m - 1} (x)

$f_{m-1}(x)$ ，需要求解

Θ^m = a r g m i n Θ m \sum i = 1 N L (y i, f m - 1 (x i) + T (x i; Θ m))

$\hat\Theta_m=arg\ min_{\Theta_m}\ \sum_{i=1}^{N}L(y_i,f_{m-1}(x_i)+T(x_i;\Theta_m))$
从而进一步得到

Θ^m Θ ^ m $\hat\Theta_m$ ，也就是第

m m $m$ 棵树的参数。

当采用平方误差函数时，

L (y, f (x)) = (y - f (x))^{2}

$L(y,f(x))=(y-f(x))^2$
所以其损失变为：

L (y, f m - 1 (x) + T (X; Θ m)) = [y - f m - 1 (x) - T (x, Θ m)] 2 = [r - T (x; Θ m)] 2 (6) (7)

$\begin{align} L(y,f_{m-1}(x)+T(X;\Theta_m))&=[y-f_{m-1}(x)-T(x,\Theta_m)]^2\\ &=[r-T(x;\Theta_m)]^2 \end{align}$

其中，

r = y - f m - 1 (x)

$r=y-f_{m-1}(x)$
这是当前模型拟合数据的 残差（residual）。所以，对于回归问题的提升树算法来说，只需要简单的拟合当前模型的残差，这样，算法是相当简单的。现在我们将回归问题的提升树算法叙述如下：

回归问题的提升树算法
- 输入：训练数据集 $T={(x_1,y_1),(x_2,y_2),...,(x_N,y_N)},x_i\in\mathcal{X}\subseteq \textbf{R}^n，y_i\in \mathcal{Y}\subseteq \textbf{R}$
- 输出：提升树 $f_M(x)$
  1. 初始化 $f_0(x)=0$
  2. 对于 $m=1,2,...,M$
    - 计算残差：
    - $r m i = y i - f m - 1 (x i), i = 1, 2, . . ., N$ $r_{mi}=y_i-f_{m-1}(x_i),\ \ \ i=1,2,...,N$
    - 拟合残差 $r_mi$ 学习一个回归树，得到 $T(x;\Theta_m)$
    - 更新 $f_m(x)=f_{m-1}(x)+T(x;\Theta_m)$
  3. 得到回归问题提升树：
    
    $f M (x) = \sum m = 1 M T (x; Θ m)$ $f_M(x)=\sum_{m=1}^MT(x;\Theta_m)$
    这里给出《统计学习方法》上的一个例题：
  如下数据:
  
  其中 x 的取值范围是 $[0.5,10.5]$ ，y 的取值范围是 [5.0, 10.0]。学习这个回归问题的提升树模型，考虑只用树桩作为基函数。
  
  解：
  - 首先通过以下优化问题：
    
    $m i n s [m i n c 1 \sum x i \in R 1 (y i - c 1) 2 + m i n c 2 \sum x i \in R 2 (y i - c 2) 2]$ $min_s[min_{c_1}\sum_{x_i\in R_1}(y_i-c_1)^2+min_{c_2}\sum_{x_i\in R_2}(y_i-c_2)^2]$
    求解训练数据的切分点 $s$ ：
    $R_{1} = {x | x \leq s}, R_{2} = {x | x > s}$ $R_1=\{x|x\leq s\},\ \ \ R_2=\{x|x>s\}$
    容易求得在 $R_1,R_2$ 内部使平方损失误差达到最小值的 $c_1,c_2$ 为：
    $c 1 = 1 N 1 \sum x i \in R 1 y i, c 2 = 1 N 2 \sum x i \in R 2 y i$ $c_1=\frac{1}{N_1}\sum_{x_i\in R_1}y_i,\ \ \ \ c_2=\frac{1}{N_2}\sum_{x_i\in R_2}y_i$
    这里 $N_1,N_2$ 是 $R_1,R_2$ 的样本点数
  - 求解训练数据的切分点。根据所给的数据，考虑如下切分点：
    
    $1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5$ $1.5,\ 2.5,\ 3.5,\ 4.5,\ 5.5,\ 6.5,\ 7.5,\ 8.5,\ 9.5$
    对于各个切分点，求出相应的 $R_1,R_2,c_1,c_2$ 以及 $m(s)$ :
    $m (s) = m i n c 1 \sum x i \in R 1 (y i - c 1) 2 + m i n c 2 \sum x i \in R 2 (y i - c 2) 2$ $m(s)=min_{c_1}\sum_{x_i\in R_1}(y_i-c_1)^2+min_{c_2}\sum_{x_i\in R_2}(y_i-c_2)^2$
    例如当 $s=1.5$ 时， $R_1=\{1\},\ R_2=\{2,3,..,10\},\ c_1=5.56,\ c_2=7.50$
    $m (s) = m i n c 1 \sum x i \in R 1 (y i - c 1) 2 + m i n c 2 \sum x i \in R 2 (y i - c 2) 2 = 0 + 15.72 = 15.72$ $m(s)=min_{c_1}\sum_{x_i\in R_1}(y_i-c_1)^2+min_{c_2}\sum_{x_i\in R_2}(y_i-c_2)^2=0+15.72=15.72$
    将 $s$ 以及 $m(s)$ 的计算结果列表如下：
    
    由上表中数据可以看出，当 $s=6.5$ 时取到最小值，这时 $R_1=\{1,2,...,6\},R_2=\{7,8,9,10\},c_1=6.24,c_2=8.91$ ，所以此时的回归树为：
    
    $T 1 (x) = {6.24, x < 6.5 8.91, x \geq 6.5 (8) (9) f 1 (x) = T 1 (x)$ $T_1(x)=\left\{\begin{align} 6.24, \ \ \ \ \ \ x<6.5\\ 8.91, \ \ \ \ \ \ x\geq 6.5 \end{align} \right.\\ f_1(x)=T_1(x) \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \$
    使用上面的 $f_1(x)$ 来拟合训练数据的残差，得到下表：
    
    其中 $r_{2i}=y_i-f_1(x_i),\ \ \ i=1,2,...,10$
    
    使用 $f_1(x)$ 来拟合训练数据平方损失误差：
    
    $L (y, f 1 (x)) = \sum i = 1 10 (y i - f 1 (x i)) 2 = 1.93$ $L(y,f_1(x))=\sum_{i=1}^{10}(y_i-f_1(x_i))^2=1.93$
  - 第二步求 $T_2(x)$ 。方法和求 $T_1(x)$ 相同，只不过此时是拟合上表中的残差，可以得到：
    
    $T 2 (x) = {- 0.52, x < 3.5 0.22, x \geq 3.5 (10) (11) >$ $T_2(x)=\left\{\begin{align} -0.52, \ \ \ \ \ \ x<3.5\\ 0.22, \ \ \ \ \ \ x\geq 3.5 \end{align} \right. >$
    进一步得到 $f_2(x)$
    $f 2 (x) = f 1 (x) + T 1 (x) = ⎧ ⎩ ⎨ ⎪ ⎪ 5.72, x < 3.5 6.46, 3.5 \leq x < 6.5 9.13, x > 6.5 (12) (13) (14)$ $f_2(x)=f_1(x)+T_1(x)=\left\{\begin{align} 5.72, \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ x<3.5\\ 6.46, \ \ \ \ \ \ 3.5\leq x< 6.5\\ 9.13, \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ x>6.5 \end{align} \right.\\$
    再使用 $f_2(x)$ 拟合训练数据的平方损失误差为：
    $L (y, f 2 (x)) = \sum i = 1 10 (y i - f 2 (x i)) 2 = 0.79$ $L(y,f_2(x))=\sum_{i=1}^{10}(y_i-f_2(x_i))^2=0.79$
  - 之后我们可以继续得到相对于每一个数据的残差表，然后继续求得 $T_3(x),T_4(x),...,T_n(x)$ ，直到拟合训练数据的平方损失误差达到相应的要求即可

2.2.3 GBDT 的分类算法

下面讨论一下 GBDT 的分类算法，GBDT 的分类算法从思想上和 GBDT 的回归算法没有区别，但是由于样本输出不是连续的值，而是离散的类别，导致我们无法直接从输出类别去拟合类别输出的误差。

为了解决这个问题，主要有两个方法，一个是用指数损失函数，此时 GBDT 退化为 $Adaboost$ 算法。另一张方法使用类似于逻辑回归的对数似然损失函数的方法。也就是说，我们用的是类别的预测概率值和真实概率值的差来拟合损失。下面主要介绍利用对数似然损失函数的 GBDT 分类。而这种方法，又有二元分类和多元分类的区别。

二元 GBDT 分类算法
- 对于二元的 GBDT，如果类似与逻辑回归的对数似然损失函数，则损失函数为：
  $L (y, f (x)) = l o g (1 + e x p (- y f (x)))$ $L(y,f(x))=log(1+exp(-yf(x)))$
  其中， $y\in \{+1,-1\}$ ，此时的负梯度误差为：
  $r t i = - [\partial L ( y , f ( x ) ) \partial f ( x i )] f (x) = f t - 1 (x) = y i / (1 + e x p (y i f (x i)))$ $r_{ti}=-\left[\frac{\partial L(y,f(x))}{\partial f(x_i)}\right]_{f(x)=f_{t-1}(x)}=y_i/(1+exp(y_if(x_i)))$
  对于生成的决策树，我们各个叶子节点的最佳残差拟合值为：
  $c t j = a r g m i n c \sum x i \in R t j l o g (1 + e x p (- y i (f t - 1 (x i) + c)))$ $c_{tj}=arg\ min_c \sum_{x_i{\in R_{tj}}}log(1+exp(-y_i(f_{t-1}(x_i)+c)))$
  由于上面的式子优化比较困难，因此一般使用下面这个式子的值进行代替：
  $c t j = \sum x i \in R t j r t j \sum x i \in R t j | r t j | ( 1 - | r t j | )$ $c_{tj}=\frac{\sum_{x_i\in R_{tj}}r_{tj}}{\sum_{x_i\in R_{tj}}|r_{tj}|(1-|r_{tj}|)}$
  可以看出除了负梯度计算和叶子节点的最佳残差拟合的线性搜索，二元 GBDT 分类和 GBDT 回归算法过程相同。

2.2.4 GBDT 常用的损失函数

下面对常用的 GBDT 损失函数做一个总结。

对于分类算法，其损失函数一般有对数损失函数和指数损失函数两种：
- 若为指数损失函数，则损失函数表达式为：
  
  $L (y, f (x)) = e x p (- y f (x))$ $L(y,f(x))=exp(-yf(x))$
  其负梯度计算和叶子节点的最佳残差拟合可以参考 Adaboost 相关内容
- 若为对数损失函数，分为二元分类和多元分类两种
对于回归算法，常用的损失函数有下面 4 种：
- 均方差：
  
  $L (y, f (x)) = (y - f (x)) 2$ $L(y,f(x))=(y-f(x))^2$
- 绝对损失：
  
  $L (y, f (x)) = | y - f (x |$ $L(y,f(x))=|y-f(x|$
  对应的负梯度为：
  $s i g n (y i - f (x i))$ $sign(y_i-f(x_i))$
- Huber 损失，它是均方差和绝对损失的折中产物，对于远离中心的异常点，采用绝对损失，而中心附近的点采用均方差。这个界限一般用分位数点度量。
- 分位数损失。它对应的是分位数回归的损失函数

Bagging 与随机森林

想要得到性能比较好的集成，那么在集成中的个体学习器应该尽可能相互独立；真正意义上的”独立“在现实应用中是很难实现的，但是我们可以设法让基学习器尽可能的具有比较大的差异性。如果已经给定了一个数据集，那么一种方法就是对训练数据进行采样，产生出若干个不同的子集，再从每个子数据集中训练出一个基学习器。这样，由于训练数据不同，我们获得的基学习器可望具有比较大的差异。

当然，为了最后集成的学习器效果不至于太差，我们也不能选择效果太差的基学习器，如果每个基学习器仅仅用了很小一部分训练数据进行训练，那么很显然，不会产生效果很好的基学习器。因此，可以考虑机器学习中对选出验证集的一种策略，也就是考虑使用相互有交叠的采样子集。（交叉验证）

3. Bagging

Bagging 是一种并行式集成学习方法，它是直接基于机器学习中的 “自助采样法（bootstrp sampling）”进行的。也就是进行下面的操作：

给定包含 m 个样本的数据集，我们先随机取出一个样本放入采样集中，再把该样本放回初始数据，使得下次采样时该样本仍然有可能被选中，这样，经过 m 次随机采样，我们得到含有 m 个样本的采样集。

此时，初始训练集中有的样本在采样集里会多次出现，有的则不会出现。可以证明，初始训练集中大约有 $63.2%$ 的样本出现在采样集中。

依据上面的采样方法，我们可以基于每个采样集训练处一个基学习器，再讲这些基学习器进行结合。这就是 Bagging 的基本流程。在对预测输出进行结合时，Bagging 通常对分类任务使用简单投票法，对回归任务是用简单平均法。如果分类预测时出现两个类收到同样票数的情形，则最简单的做法就是随机选择一个，当然也可以进一步考察学习器投票的置信度来确定最终的“获胜者”。

之前提到过，标准的 Adaboost 算法只适用于二分类，而 Bagging 能够不经修改的用于多分类、回归等任务。从偏差-方差分解的角度看，Bagging 主要关注的是降低方差，因此在不剪枝决策树、神经网络等易受样本扰动的学习器上效果更为明显。

下面给出 Bagging 算法的流程：

输入：样本集 $D=\{(x_1,y_1),(x_2,y_2),...,(x_m,y_m)\}$ ，若学习器算法，弱分类器爹迭代次数 $T$ .

输出：最终的强分类器 $f(x)$

对于 $t=1,2,...,T$ :

a) 对训练集进行第 $t$ 次随机采样，一共采集 $m$ 次，得到包含 $m$ 个样本的采样集 $D_m$ ，

b) 用采样集 $D_m$ 训练第 $m$ 个若学习器 $G_m(x)$
如果是分类算法预测，则 $T$ 个若学习器透出最多票数的类别或者是类别之一为最终类别。如果是回归算法，T 个若学习器得到的回归结果进行算术平均得到的值为最终的模型输出。

3.1. 随机森林

随机森林（Random Forest）继承了上面提到的 Bagging 的思想，但是又加以改进。

随机森林使用的是 CART 决策树作为弱学习器，且在决策树的基础上，随机森林对决策树建立做了相关的改进，对于普通的决策树来说，在节点上所有的 n 个样本特征中选择一个最优的特征来做决策树的左右子树的划分，但是孙集森林是通过随机选择节点上的一部分样本特征，这个数字小于 $n$ ，假设为 $n_{sub}$ ，然后在这些随机选择的 $n_{sub}$ 个样本特征中，选择一个最优的特征来做决策树的左右子树划分。这样进一步增强了模型的泛化能力。

如果 $n_{sub}=n$ ，则此时的随机森林和普通的 CART 决策树没有区别， $n_{sub}$ 越小，则模型也就越简装，当然此时对于训练集的拟合程度会变差，也就是说， $n_{sub}$ 越小，模型的方差会减小，但是偏差会增大。在实际应用种，一般会通过交叉验证调参获取一个合适的 $n_{sub}$ 的值。

除了上面提到的以外，随机森林和普通的 Bagging 算法并没有什么不同，下面给出随机森林算法：

输入：样本集 $D=\{(x_1,y_1),(x_2,y_2),...,(x_m,y_m)\}$ ，弱分类器迭代次数 $T$

输出：最终的强分类器 $f(x)$

对于 $t=1,2,...,T:$

对训练集进行第 $t$ 次随机采样，共采集 $m$ 次，得到包含 $m$ 个样本的采样集 $D_m$
用采样集 $D_m$ 训练第 $m$ 个决策树模型 $G_m(x)$ ，在训练决策树模型的节点的时候，在节点上所有的样本特征中最忌选择一部分样本特征，在这些随机选择的部分样本特征中选择一个最优的特征来做决策树的左右子树划分。
如果是分类算法预测，则 $T$ 个弱学习器投票出最多票数的类别或者类别之一作为最终类别。如果是回顾算法， $T$ 个弱学习器得到的回归结果进行算术平均得到的值为最终的模型输出。