（七）统计学习方法 | 提升方法

---

1. 提升算法AdaBoost算法

1.1 简介与定义

提升方法基于这样一个思想：对于一个复杂任务来说，将多个专家的判断进行适当的综合所得出的判断，要比其中任何一个专家单独的判断好。对于分类问题而言，给定一个训练数据集，求比较粗糙的分类规则（弱分类器）要比求景区的分类规则（强分类器）容易得多。提升方法就是从若学习算法出发，反复学习，得到一系列弱分类器，然后组合这些弱分类器，构成一个强分类器。这样，对提升方法而言，存在两个需要回答的问题：每一轮如何改变训练数据的权值或概率分布；如何将弱分类器组成一个强分类器。

1.2 AdaBoost算法

给定一个二分类的训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}

其中，每个样本点由实例与标记组成。实例$x_i\in \mathcal{X}\subset {\mathbf{R}}^n$，标记 y i ∈ Y = { − 1 , + 1 } y_i\in\mathcal Y=\{-1,+1\} yi​∈Y={−1,+1}，$\mathcal{X}$是实例空间，$\mathcal{Y}$是标记集合。$\mathrm{A}\mathrm{d}\mathrm{a}\mathrm{B}\mathrm{o}\mathrm{o}\mathrm{s}\mathrm{t}$利用以下算法，从训练数据中学习一系列弱分类器或基本分类器，并将这些弱分类器线性组成为一个强分类器。

AdaBoost

输入 训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}，其中$x_i\in \mathcal{X}\subset {\mathbf{R}}^n$， y i ∈ Y = { − 1 , + 1 } y_i\in\mathcal Y=\{-1,+1\} yi​∈Y={−1,+1}；弱学习算法；

输出 最终分类器$G(x)$。

（1）初始化训练数据的权值分布：$$D_1=(w_{11},...,w_{1i},...,w_{1N}),w_{1i}=\frac{1}{N},i=1,2,...,N$$

（2）对$m=1,2,...,M$

（2-1）使用具有权值分布$D_m$的训练数据集学习，得到基本分类器： G m ( x ) : X → { − 1 , + 1 } G_m(x):\mathcal X\rightarrow\{-1,+1\} Gm​(x):X→{−1,+1}

（2-2）计算$G_m(x)$在训练数据集上的分类误差率：$$e_m=\sum _{i=1}^{N}P(G_m(x_i)\ne y_i)=\sum _{i=1}^N{w}_{mi}I(G_m(x_i)\ne y_i)\text{\hspace{1em}(1)}$$

（2-3）计算$G_m(x)$的系数：$${\alpha }_m=\frac{1}{2}\log \frac{1-e_m}{e_m}$$

（2-4）更新训练数据集的权值分布：$$D_{m+1}=(w_{m+1,1},...,w_{m+1,i},...,w_{m+1,N})$$

$$w_{m+1,i}=\frac{w_{mi}}{Z_m}\exp (-{\alpha }_m{y}_i{G}_m(x_i)),i=1,2,...,N\text{\hspace{1em}(2)}$$

这里，$Z_m$是规范化因子：$$Z_m=\sum _{i=1}^N\exp (-{\alpha }_m{y}_i{G}_m(x_i))\text{\hspace{1em}(3)}$$

它使$D_{m+1}$称为一个概率分布。

（3）构建基本分类器的线性组合：$$f(x)=\sum _{m=1}^M{\alpha }_m{G}_m(x)\text{\hspace{1em}(4)}$$

得到最终分类器：
$$\begin{array}{rl}G(x)& =\mathrm{s}\mathrm{i}\mathrm{g}\mathrm{n}(f(x))\\ & =\mathrm{s}\mathrm{i}\mathrm{g}\mathrm{n}\left(\sum _{m=1}^N{\alpha }_m{G}_m(x)\right)\end{array}\text{\hspace{1em}(5)}$$

例题 给定下表训练数据集，假设弱分类器由$x<v$或$x>v$产生，其阈值$v$使该分类器在训练数据集上分类误差率最低。

序号	1	2	3	4	5	6	7	8	9	10
x	0	1	2	3	4	5	6	7	8	9
y	1	1	1	-1	-1	-1	1	1	1	-1

解 初始化权重分布：$$D_1=(w_{11},w_{12},...,w_{110})$$

$$w_{1i}=0.1,i=1,2,...,10$$

对$m=1$，在权值分布$D_1$的训练数据上，阈值$v$取$2.5$时分类误差率最低，故基本分类器为$$G_1(x)=\{\begin{array}{rlr}1,& & x<2.5\\ -1,& & x>2.5\end{array}$$

$G_1(x)$在训练数据集上的误差率$e_1=P(G_1(x_i)\ne y_i)=0.3$。计算$G_1(x)$的系数：${\alpha }_1=1/2\log (1-e_1)/e_1=0.4236$。更新训练数据的权值分布：$$D_2=(w_{21},...,w_{2i},...,w_{210})$$

$$w_{2i}=\frac{w_{1i}}{Z_1}\exp (-{\alpha }_1{y}_i{G}_1(x_i)),i=1,2,...,N$$

$$D_2=(0.07143,0.07143,0.07143,0.07143,0.07143,0.07143,0.16667,0.16667,0.16667,0.07143)$$

$$f_1(x)=0.4236G_1(x)$$

分类器$\mathrm{s}\mathrm{i}\mathrm{g}\mathrm{n}[f_1(x)]$在训练数据集上有$3$个误分类点。

对$m=2$，在权值分布$D_2$的训练数据上，阈值$v$是$8.5$时分类误差率最低，基本分类器为$$G_2(x)=\{\begin{array}{rlr}1,& & x<8.5\\ -1,& & x>8.5\end{array}$$

$G_2(x)$在训练数据集上的误差率为$e_2=0.2143$。计算${\alpha }_2=0.6496$。更新训练数据权值分布：
$$D_3=(0.0455,0.0455,0.0455,0.1667,0.1667,0.1667,0.1060,0.1060,0.1060,0.0455)$$

$$f_2(x)=0.4236G_1(x)+0.6496G_2(x)$$

分类器$\mathrm{s}\mathrm{i}\mathrm{g}\mathrm{n}[f_2(x)]$在训练数据集上有$3$个误分类点。

对$m=3$，在权值分布$D_3$的训练数据上，阈值$v$是$5.5$时分类误差率最低，基本分类器为$$G_3(x)=\{\begin{array}{rlr}1,& & x<5.5\\ -1,& & x>5.5\end{array}$$

$G_3(x)$在训练数据集上的误差率为$e_3=0.1820$。计算${\alpha }_3=0.7514$。更新训练数据权值分布：
$$D_3=(0.125,0.125,0.125,0.102,0.102,0.102,0.065,0.065,0.065,0.065,0.125)$$

分类器$\mathrm{s}\mathrm{i}\mathrm{g}\mathrm{n}[f_3(x)]$在训练数据集上的误分类点个数为$0$。于是，最终的分类器为：

$$G(x)=\mathrm{s}\mathrm{i}\mathrm{g}\mathrm{n}[f_3(x)]=\mathrm{s}\mathrm{i}\mathrm{g}\mathrm{n}[0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x)]$$

1.3 AdaBoost算法的训练误差分析

$\mathrm{A}\mathrm{d}\mathrm{a}\mathrm{B}\mathrm{o}\mathrm{o}\mathrm{s}\mathrm{t}$最基本的性质是它能在学习过程中不断减少训练误差，即在训练数据集上的数据的分类误差率。

AdaBoost的训练误差界 $\mathrm{A}\mathrm{d}\mathrm{a}\mathrm{B}\mathrm{o}\mathrm{o}\mathrm{s}\mathrm{t}$算法最终分类器的训练误差界为：$$\frac{1}{N}\sum _{i=1}^{N}I(G_i(x_i)\ne y_i)\le \frac{1}{N}\sum _i\exp (-y_{i}f(x_i))=\prod _m{Z}_m\text{\hspace{1em}(6)}$$

证明 当$G(x_i)\ne y_i$时，$y_{i}f(x_i)<0$，因而$\exp (-y_{i}f(x_i))\ge 1$，由此前半部分的不等式得证。由$Z_m$的定义，有：$$w_{mi}\exp (-{\alpha }_m{y}_i{G}_m(x_i))=Z_m{w}_{m+1,i}$$

$$\begin{array}{rl}\frac{1}{N}\sum _i\exp (-y_{i}f(x_i))& =\frac{1}{N}\sum _i\exp \left(-\sum _{m=1}^M{\alpha }_m{y}_i{G}_m(x_i)\right)\\ & =\sum _i{w}_{1i}\prod _{m=1}^M\exp (-{\alpha }_m{y}_i{G}_m(x_i))\\ & =Z_1\sum _i{w}_{2i}\prod _{m=2}^M\exp (-{\alpha }_m{y}_i{G}_m(x_i))\\ & =Z_1{Z}_2\sum _i{w}_{3i}\prod _{m=2}^M\exp (-{\alpha }_m{y}_i{G}_m(x_i))\\ & =...\\ & =Z_1{Z}_2...Z_{M-1}\sum _i{w}_{2i}\prod _{m=2}^M\exp (-{\alpha }_m{y}_i{G}_m(x_i))\\ & =\prod _{m=1}^M{Z}_m\end{array}$$

二分类问题AdaBoost的训练误差界$$\begin{array}{rl}\prod _{m=1}^M{Z}_m& =\prod _{m=1}^M[2\sqrt{e_m(1-e_m)}]\\ & =\prod _{m=1}^M\sqrt{1-4{\gamma }_m^2}\\ & \le \exp \left(-2\sum _{m=1}^M{\gamma }_m^2\right)\end{array}\text{\hspace{1em}(7)}$$

证明 由$Z_m$的定义及式（1）：$$\begin{array}{rl}{Z}_m& =\sum _{i=1}^N{w}_{mi}\exp (-{\alpha }_m{y}_i{G}_m(x_i))\\ & =\sum _{y_i=G_m(x_i)}{w}_{mi}{e}^{-{\alpha }_m}\sum _{y_i\ne G_m(x_i)}{w}_{mi}{e}^{{\alpha }_m}\\ & =(1-e_m)e^{-{\alpha }_m}+e_m{e}^{{\alpha }_m}\\ & =2\sqrt{e_m(1-e_m)}\\ & =\sqrt{1-4{\gamma }_m^2}\end{array}$$

对于不等式：$$\prod _{m=1}^M\sqrt{(1-4{\gamma }_m^2)}\le \exp \left(-2\sum _{m=1}^M{\gamma }_m^2\right)$$

则可先由$e^x$和$\sqrt{1-x}$在$x=0$的泰勒展开推出不等式$\sqrt{(1-4{\gamma }_m^2)}\le \exp (-2{\gamma }_m^2)$，进而得到。

推论 如果存在$\gamma >0$，对所有$m$有${\gamma }_m\ge \gamma$，则：$$\frac{1}{N}\sum _{i=1}^{N}I(G(x_i)\ne y_i)\le \exp (-2M{\gamma }^2)$$

1.4 AdaBoost算法的解释

$\mathrm{A}\mathrm{d}\mathrm{a}\mathrm{B}\mathrm{o}\mathrm{o}\mathrm{s}\mathrm{t}$算法还有另外一个解释：即模型为加法模型、损失函数为指数函数、学习算法为前向分步算法时的二分类学习方法。

1.4.1 前向分步算法

考虑加法模型：$$f(x)=\sum _{m=1}^M{\beta }_{m}b(x;{\gamma }_m)$$

其中，$b(x;{\gamma }_m)$为基函数，${\gamma }_m$为基函数的参数，${\beta }_m$为基函数的系数。在给定训练数据及损失函数$L(y,f(x))$的条件下，学习加法模型成为经验风险极小化：$$\underset{{\beta }_m,{\gamma }_m}{\min }\sum _{i=1}^{N}L\left(y_i,\sum _{m=1}^M{\beta }_{m}b(x_i;{\gamma }_m)\right)\text{\hspace{1em}(8)}$$

这时一个复杂的优化问题，前向分步算法的思路是：因为学习的时加法模型，如果能够从前往后，每一步只学习一个基函数及其系数，逐步逼近优化目标函数式，那么就可以简化优化的复杂度。具体地，每一步只需优化以下函数：$$\underset{\beta ,\gamma }{\min }\sum _{i=1}^{N}L(y_i,\beta b(x_i;\gamma ))\text{\hspace{1em}(9)}$$

前向分步算法

输入 训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}；损失函数$L(y,f(x))$；基函数集 { b ( x ; γ ) } \{b(x;\gamma)\} {b(x;γ)}；

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

（1）初始化$f(x_0)=0$；

（2）对$m=1,2,...,M$

（2-1）极小化损失函数：$$({\beta }_m,{\gamma }_m)=\arg \underset{\beta ,\gamma }{\min }\sum _{i=1}^{N}L(y_i,f_{m-1}(x_i)+\beta b(x_i;\gamma ))$$

得到参数${\beta }_m$，$\gamma$；

（2-2）更新：$$f_m(x)=f_{m-1}(x)+{\beta }_{m}b(x;{\gamma }_m)$$

（3）得到加法模型：$$f(x)=f_M(x)=\sum _{m=1}^M{\beta }_{m}b(x;{\gamma }_m)$$

1.4.2 前向分步算法与AdaBoost

定理 $\mathrm{A}\mathrm{d}\mathrm{a}\mathrm{B}\mathrm{o}\mathrm{o}\mathrm{s}\mathrm{t}$算法是前向分步加法算法的特例。这时，模型是由基本分类器组成的加法模型，损失函数是指数函数。

---

2. 提升树

2.1 提升树模型

提升方法实际采用加法模型与前向分步算法。以决策树为基函数的提升方法称为提升树。基本分类器如$x<v$或$x>v$，可以看作是由一个根结点直接连接两个叶结点的简单决策树，即所谓的决策树桩。提升树模型可以表示为决策树的加法模型：$$f_M(x)=\sum _{m=1}^{M}T(x;{\Theta }_m)$$

其中，$T(x;{\Theta }_m)$表示决策树，${\Theta }_m$为决策树参数，$M$为树的个数。

2.2 提升树算法

提升树算法采用前向分步算法。首先确定初始提升树$f_0(x)=0$，第$m$步的模型是：$$f_m(x)=f_{m-1}(x)+T(x;{\Theta }_m)$$

其中，$f_{m-1}(x)$表示当前模型，通过经验风险最小化确定下一棵决策树的参数${\Theta }_m$：$${\hat{\Theta }}_m=\arg \underset{{\Theta }_m}{\min }\sum _{i=1}^{N}L(y_i,f_{m-1}(x_i)+T(x_i;{\Theta }_m))$$

由于树的线性组合可以很好地拟合训练数据，即使数据的输入与输出之间的关系很复杂也是如此，所以提升树是一个高功能的学习算法。而对于二分类问题，提升树算法只需将基本分类器限制为二分类树即可。这里介绍回归问题的提升树。已知一个训练集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}，$x_i\in \mathcal{X}\subset {\mathbf{R}}^n$，$\mathcal{X}$为输入空间，$y_i\in \mathcal{Y}\subset {\mathbf{R}}^n$，$\mathcal{Y}$为输出空间。现在，如果将输入空间$\mathcal{X}$划分为$J$个互不相交的区域$R_1,R_2,...,R_J$，并且在每个区域上确定输出的常量$c_j$，那么树可以表示为：$$T(x;\Theta )=\sum _{j=1}^J{c}_{j}I(x\in R_j)$$

其中，参数 Θ = { ( 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)\} Θ={(R1​,c1​),(R2​,c2​),...,(RJ​,cJ​)}表示树的区域和各区域上的常数。$J$是回归树的复杂度也即叶结点个数。回归问题的提升树使用以下前向分步算法：$$f_0(x)=0$$

$$f_m(x)=f_{m-1}(x)=T(x;{\Theta }_m),m=1,2,...,M$$

$$f_M(x)=\sum _{i=1}^{M}T(x;{\Theta }_m)$$

在前向分步算法的第$m$步，给定当前模型$f_{m-1}(x)$，需求解：$${\hat{\Theta }}_m=\arg \underset{{\Theta }_m}{\min }\sum _{i=1}^{N}L(y_i,f_{m-1}(x_i)+T(x_i;{\Theta }_m))$$

得到${\hat{\Theta }}_m$，即第$m$棵树的参数。当采用平方误差损失函数时：$$L(y,f(x))=(y-f(x){)}^2$$

其损失变为：$$\begin{array}{rl}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{array}$$

这里，$r=y-f_{m-1}(x)$是当前模型拟合数据的残差。所以，对于回归问题的提升树算法来说，只需简单地拟合当前模型的残差。

回归问题的提升树算法

输入 训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}，$x_i\in \mathcal{X}\subset {\mathbf{R}}^n$，$y_i\in \mathcal{Y}\subset {\mathbf{R}}^n$；

输出 提升树$f_M(x)$。

（1）初始化$f_0(x)=0$；

（2）对$m=1,2,...,M$

（2-1）计算残差$r_{mi}=y_i-f_{m-1}(x_i),i=1,2,...,N$；

（2-2）拟合残差$r_{mi}$学习一个回归树，得到$T(x;{\Theta }_m)$；

（3）得到回归问题提升树：$$f_M(x)=\sum _{i=1}^{M}T(x;{\Theta }_m)$$

例题 使用以下数据学习这个回归问题的提升树模型，只用树桩作为基函数。

$x_i$	1	2	3	4	5	6	7	8	9	10
$y_i$	5.56	5.70	5.91	6.40	6.80	7.05	8.90	8.70	9.00	9.05

解 首先求$f_1(x)$，即回归树$T_1(x)$。根据以下最优化问题：$$\underset{s}{\min }\left[\underset{c_1}{\min }\sum _{x_i\in R_1}(y_i-c_1{)}^2+\underset{c_2}{\min }\sum _{x_i\in R_2}(y_i-c_2{)}^2\right]$$

求解训练数据的切分点$s$： R 1 = { x ∣ x ≤ s } ,    R 2 = { x ∣ x > s } R_1=\{x|x\leq s\},\ \ R_2=\{x|x>s\} R1​={x∣x≤s},  R2​={x∣x>s}

容易求得在$R_1,R_2$内部使平方损失误差达到最小值的$c_1$，$c_2$为：$$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$$

对各切分点，依次求出$R_1,R_2,c_1,c_2$以及：$$m(s)=\underset{c_1}{\min }\sum _{x_i\in R_1}(y_i-c_1{)}^2+\underset{c_2}{\min }\sum _{x_i\in R_2}(y_i-c_2{)}^2$$

如，当取切分点为$1.5$时， R 1 = { 1 } ,   R 2 = { 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } ,   c 1 = 5.56 ,   c 2 = 7.50 R_1=\{1\},\ R_2=\{2,3,4,5,6,7,8,9,10\}, \ c_1=5.56,\ c_2=7.50 R1​={1}, R2​={2,3,4,5,6,7,8,9,10}, c1​=5.56, c2​=7.50。先将各切分点的计算结果列表如下：

$s$	1.5	2.5	3.5	4.5	5.5	6.5	7.5	8.5	9.5
$m(s)$	15.72	12.07	8.36	5.78	3.91	1.93	8.01	11.73	15.74

有表结果可知，$s=6.5$时$m(s)$达到最小值，此时 R 1 = { 1 , 2 , 3 , 4 , 5 , 6 } ,   R 2 = { 7 , 8 , 9 , 10 } ,   c 1 = 6.24 ,   c 2 = 8.91 R_1=\{1,2,3,4,5,6\},\ R_2=\{7,8,9,10\}, \ c_1=6.24,\ c_2=8.91 R1​={1,2,3,4,5,6}, R2​={7,8,9,10}, c1​=6.24, c2​=8.91，此时的回归树为：$$T_1(x)=\{\begin{array}{rlr}& 6.24,& x<6.5\\ & 8.91,& x\ge 6.5\end{array}$$

$$f_1(x)=T_1(x)$$

用$f_1(x)$拟合训练数据的残差如下：

$x_i$	1	2	3	4	5	6	7	8	9	10
$r_{2i}$	-0.68	-0.54	-0.33	0.16	0.56	0.81	-0.01	-0.21	0.09	0.14

用$f_1(x)$拟合训练数据的平方损失误差：$$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)=\{\begin{array}{rl}-0.52,& x<3.5\\ 0.22,& x\ge 3.5\end{array}$$

$$f_2(x)=f_1(x)+T_2(x)=\{\begin{array}{rlr}& 5.72,x<3.5& \\ & 6.46,3.5\le x<6.5& \\ & 9.13,x\ge 6.5& \end{array}$$

用$f_2(x)$拟合训练数据的平方损失误差：$$L(y,f_1(x))=\sum _{i=1}^{10}(y_i-f_1(x_i){)}^2=0.79$$

继续求得：
$$T_3(x)=\{\begin{array}{rl}0.15,& x<6.5\\ -0.22,& x\ge 6.5\end{array}L(y,f_3(x))=0.47$$

$$T_4(x)=\{\begin{array}{rl}-0.16,& x<4.5\\ 0.11,& x\ge 4.5\end{array}L(y,f_3(x))=0.30$$

$$T_5(x)=\{\begin{array}{rl}0.07,& x<6.5\\ -0.11,& x\ge 6.5\end{array}L(y,f_3(x))=0.23$$

$$T_6(x)=\{\begin{array}{rl}-0.15,& x<2.5\\ 0.04,& x\ge 2.5\end{array}$$

f 6 ( x ) = f 5 ( x ) + T 6 ( x ) = T 1 ( x ) + . . . + T 5 ( x ) + T 6 ( x ) = { 5.63 ,   x < 2.5 5.82 ,   2.5 ≤ x < 3.5 6.56 ,   3.5 ≤ x < 4.5 6.83 ,   4.5 ≤ x < 6.5 8.95 ,   x ≥ 6.5 \begin{aligned} f_6(x)&=f_5(x)+T_6(x)=T_1(x)+...+T_5(x)+T_6(x)\\&=\left\{ \begin{aligned} & 5.63,\ & &x<2.5 \\ & 5.82,\ &&2.5\leq x<3.5 \\ & 6.56,\ &&3.5\leq x<4.5 \\ & 6.83,\ &&4.5\leq x<6.5 \\ & 8.95,\ &&x\geq 6.5 \end{aligned} \right. \end{aligned} f6​(x)​=f5​(x)+T6​(x)=T1​(x)+...+T5​(x)+T6​(x)=⎩⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎧​​5.63, 5.82, 6.56, 6.83, 8.95, ​​x<2.52.5≤x<3.53.5≤x<4.54.5≤x<6.5x≥6.5​​

用$f_6(x)$拟合训练数据的平方损失误差：$$L(y,f_1(x))=\sum _{i=1}^{10}(y_i-f_1(x_i){)}^2=0.17$$

假设此时已经满足误差要求，那么$f(x)=f_6(x)$即为所求提升树。

2.3 梯度提升

提升树利用加法模型与前向分步算法实现学习的优化过程。当损失函数是平方损失和指数函数时，每一步优化是很简单的。但对于一般的损失函数而言，往往采用梯度上升算法。这是利用最速下降法的近似方法，其关键是利用损失函数的负梯度在当前模型的值：$$-{\left[\frac{\partial L(y,f(x_i))}{\partial f(x_i)}\right]}_{f(x)=f_{m-1}(x)}$$

作为回归问题提升树算法中的残差的近似值，拟合一个回归树。

梯度提升算法

输入 训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}，$x_i\in \mathcal{X}\subset {\mathbf{R}}^n$，$y_i\in \mathcal{Y}\subset {\mathbf{R}}^n$；

输出 回归树$\hat{f}(x)$。

（1）初始化：$$f_0(x)=\arg \underset{c}{\min }\sum _{i=1}^{N}L(y_i,c)$$

（2）对$m=1,2,...,M$

（2-1）对$i=1,2,...,N$，计算：$$r_{mi}=-{\left[\frac{\partial L(y_i,f(x_i))}{\partial f(x_i)}\right]}_{f(x)=f_{m-1}(x)}$$

（2-2）对$r_{mi}$拟合一个回归树，得到第$m$棵树的叶结点区域$R_{mj},j=1,2,...,J$；

（2-3）对$j=1,2,...,J$，计算：$$c_{mj}=\arg \underset{c}{\min }\sum _{c_i\in R_{mj}}L(y_i,f_{m-1}(x_i)+c)$$

（2-4）更新：$$f_m(x)=f_{m-1}(x)+\sum _{j=1}^J{c}_{mj}I(x\in R_{mj})$$

（3）得到回归树：$$\hat{f}(x)=f_M(x)=\sum _{m=1}^M\sum _{j=1}^J{c}_{mj}I(x\in R_{mj})$$

---

3. Python实现提升方法

首先加载数据集：

def load_data(file):
    # 定义空列表
    dataArr = []
    labelArr = []
    # 打开并处理文件
    with open(file, "r") as f:
        lines = f.readlines()
        for line in lines:
            # 针对csv文件格式，使用','分割数据
            curLine = line.strip().split(',')
            # csv文件第一列存放着具体类别
            if int(curLine[0]) < 5:
                labelArr.append(-1)
            else:
                labelArr.append(1)
            # 处理具体数据，为了简化计算量，将像素取值限制在01两个部分
            # 如果不简化，处理的数据量是10×784×256，现在是10×784×2
            dataArr.append([int(int(num) > 128) for num in curLine[1:]])
        # 返回
        return dataArr, labelArr

计算错误率：

def cal_e_gx(train_data, train_label, n, div, relu, d):
    # 计算分类错误率，首先初始化为零
    e = 0
    # 抽取第n列特征
    x = train_data[:, n]
    y = train_label

    predict = []

    if relu == "LisOne":
        L = 1
        H = -1
    else:
        L = -1
        H = 1
    # 遍历样本
    for i in range(train_data.shape[0]):
        if x[i] < div:
            # 如果小于切分点，则预测为L
            predict.append(L)
            # 累计错误
            if y[i] != L:
                e += d[i]
        else:
            # 如果大于切分点，则预测为H
            predict.append(H)
            if y[i] != H:
                e += d[i]
    # 返回
    return np.array(predict), e

创建单层决策树：

def cal_single_boosting_tree(train_data, train_label, d):
    # 创建单层提升树
    m, n = np.shape(train_data)
    # 定义单层树的字典，用于存放该提升树的参数并初始化分类错误率
    single_boost_tree = {'e': 1}
    # 遍历寻找最佳切分点
    for i in range(n):
        # 由于特征经过了二值化后为0和1，切分点为-0.5，0.5和1.5
        for div in [-0.5, 0.5, 1.5]:
            for relu in ["LisOne", "HisOne"]:
                # 第i个特征，以div值进行切分，得到预测结果和分类错误率
                gx, e = cal_e_gx(train_data, train_label, i, div, relu, d)
                # 是否为最小分类错误率，如果是则更新切分点等信息
                if e < single_boost_tree['e']:
                    single_boost_tree['e'] = e
                    # 同时存储切分点、切分规则、预测结果、特征索引
                    single_boost_tree['div'] = div
                    single_boost_tree['relu'] = relu
                    single_boost_tree['gx'] = gx
                    single_boost_tree['feature'] = i
    # 返回单层提升树
    return single_boost_tree

创建整棵树：

# https://github.com/Dod-o/Statistical-Learning-Method_Code/blob/master/AdaBoost/AdaBoost.py#L166
def create_boosting_tree(train_data, train_label, tree_num=50):
    # 创建提升树
    train_data = np.array(train_data)
    train_label = np.array(train_label)
    m, n = np.shape(train_data)
    # 根据AdaBoost算法，首先初始化权值分布为1/N
    d = [1 / m] * m
    # 初始化提升树列表，每个位置为一层
    tree = []
    # 循环创建提升树
    for i in range(tree_num):
        # 当前层的提升树
        curr_tree = cal_single_boosting_tree(train_data, train_label, d)
        # 计算G(x)的系数为alpha
        alpha = 1 / 2 * np.log((1 - curr_tree['e']) / curr_tree['e'])
        # 当前层的预测结果结果用于更新权值分布
        gx = curr_tree["gx"]
        d = np.multiply(d, np.exp(-1 * alpha * np.multiply(train_label, gx))) / sum(d)
        # 增加alpha参数
        curr_tree["alpha"] = alpha
        # 将当前层添加到树中
        tree.append(curr_tree)
    # 返回整个提升树
    return tree

根据给定输入产生预测结果：

def predict(x, div, relu, feature):
    # 输出单层的预测结果，relu表示不同分类规则
    if relu == "LisOne":
        L = 1
        H = -1
    else:
        L = -1
        H = 1
    # 判断预测结果
    if x[feature] < div:
        return L
    else:
        return H

测试集上的表现：

def model_test(test_data, test_label, tree):
    errCnt = 0
    # 遍历
    for i in range(len(test_data)):
        # 预测结果值，初始化为0
        result = 0
        # 遍历每层树
        for curr_tree in tree:
            # 该层树的信息参数
            div = curr_tree["div"]
            relu = curr_tree["relu"]
            feature = curr_tree["feature"]
            alpha = curr_tree["alpha"]
            # 将当前层结果加入预测中
            result += alpha * predict(test_data[i], div, relu, feature)
        # 预测错误
        if np.sign(result) != test_label[i]:
            errCnt += 1
    return 1 - errCnt / len(test_data)

---

4. 提升方法总结

提升方法是将弱学习算法提升为强学习算法的统计学习方法。在分类学习中，提升方法通过反复修改训练数据的权值分布，构建一系列基本分类器，并将这些基本分类线性组合以构成一个强分类器。其中较经典的提升方法是$\mathrm{A}\mathrm{d}\mathrm{a}\mathrm{B}\mathrm{o}\mathrm{o}\mathrm{s}\mathrm{t}$算法，它是一种加法模型，损失函数是指数函数，算法是前向分步算法。

---

参考

1. 统计学习方法/李航著。—2版。—北京：清华大学出版社，2019（2019.6重印）.
2. https://github.com/Dod-o/Statistical-Learning-Method_Code（提升方法代码）.

---

完

---