提升树(Boosting Tree)原理与案例

1. 提升树模型

提升方法实际采用加法模型（即基函数的线性组合）与前向分步算法。以决策树为基函数的提升方法称为提升树（boosting tree）。对分类问题决策树是二叉分类树，对回归问题决策树是二叉回归树。提升树模型可以表示为决策树的加法模型：
$$f_M(x)=\sum _{m=1}^{M}T(x;{\theta }_m)$$
其中，$T(x;{\theta }_m)$表示决策树；${\theta }_m$为决策树参数；$M$为树的个数。

2. 提升树算法

提升树算法采用前向分步算法。首先确定初始提升树 $f_0(x)=0$ ，第m步的模型是:
$$f_m(x)=f_{m-1}(x)+T\left(x;{\Theta }_m\right)$$
其中， $f_{m-1}(x)$ 为当前模型，通过经验风险极小化确定下一棵决策树的参数 ${\Theta }_m$ ：
${\hat{\Theta }}_m={\mathrm{argmin}}_{\left({\Theta }_n\right)}{\sum }_{i=1}^{N}L\left(y_i,f_{m-1}\left(x_i\right)+T\left(x_i;{\Theta }_m\right)\right)$
由于树的线性组合可以很好地拟合训练数据，即使数据中的输入与输出之间的关系很复杂也是如此，所以提升树是一个高功能的学习算法。

下面讨论针对不同问题的提升树学习算法，其主要区别在于使用的损失函数不同。包括用平方误差 损失函数的回归问题，用指数损失函数的分类问题，以及用一般损失函数的一般决策问题。

2.1 二叉分类提升树

对于二分类问题，提升树算法只需将AdaBoost算法中的基本分类器限制为二类分类树即可，可以说这时的提升树算法是AdaBoost算法的特殊情况，这里不再细述。下面叙述回归问题的提升树。

2.2 二叉回归提升树

已知一个训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , … , ( x N , y N ) } , x i ∈ X ⊆ R n ， x T=\left\{\left(x_1, y_1\right),\left(x_2, y_2\right), \ldots,\left(x_N, y_N\right)\right\}, x_i \in X \subseteq R^n ， \mathrm{x} T={(x1​,y1​),(x2​,y2​),…,(xN​,yN​)},xi​∈X⊆Rn，x 为输入空 间， $y_i\in Y\subseteq R，\mathrm{y}$ 为输出空间。如果将输入空间$x$划分为$J$个互不相交的区域 $R_1,R_2,\dots ,R_J$ , 并且在每个区域上确定输出的常量 $c_j$ ，那么树可表示为:
$$T(x;\Theta )=\sum _{j=1}^J{c}_{j}I\left(x\in R_j\right)$$
其中，参数 Θ = { ( R 1 , c 1 ) , ( R 2 , c 2 ) , … , ( R J , c J ) } \Theta=\left\{\left(R_1, c_1\right),\left(R_2, c_2\right), \ldots,\left(R_J, c_J\right)\right\} Θ={(R1​,c1​),(R2​,c2​),…,(RJ​,cJ​)} 表示树的区域划分和各区域上的常数。J 是回归树的复杂度即叶结点个数。
回归问题提升树使用以下前向分步算法:
$$\begin{array}{rl}& f_0(x)=0\\ & f_m(x)=f_{m-1}(x)+T\left(x;{\Theta }_m\right),m=1,2,\dots ,M\\ & f_M(x)=\sum _{m=1}^{M}T\left(x;{\Theta }_m\right)\end{array}$$
在前向分步算法的第 $m$ 步，给定当前模型 $f_{m-1}(x)$ ，需求解:
$${\hat{\Theta }}_m={\mathrm{argmin}}_{\left({\Theta }_n\right)}\sum _{i=1}^{N}L\left(y_i,f_{m-1}\left(x_i\right)+T\left(x_i;{\Theta }_m\right)\right)$$
得到 ${\hat{\Theta }}_m$ ，即第 $\mathrm{m}$ 棵树的参数。
当采用平方误差损失函数时， $L(y,f(x))=(y-f(x){)}^2$ ，其损失变为:
$$L\left(y,f_{m-1}(x)+T\left(x;{\Theta }_m\right)\right)={\left[y-f_{m-1}(x)-T\left(x;{\Theta }_m\right)\right]}^2={\left[r-T\left(x;{\Theta }_m\right)\right]}^2$$
这里， $r=y-f_{m-1}(x)$ ，是当前模型拟合数据的残差 (residual) 。所以，对回归问题的提升树算法来说，只需简单地拟合当前模型的残差。这样，算法是相当简单的。

回归提升树算法步骤：
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , … , ( x N , y N ) } , x i ∈ X , y i ∈ R T=\left\{\left(x_1, y_1\right),\left(x_2, y_2\right), \ldots,\left(x_N, y_N\right)\right\}, \quad x_i \in X, \quad y_i \in R T={(x1​,y1​),(x2​,y2​),…,(xN​,yN​)},xi​∈X,yi​∈R
输出：提升树 $f_M(x)$
(1) 初始化 $f_0(x)=0$
(2)对 $m=1,2,\dots ,\mathrm{M}(\mathrm{M}$ 棵树，对每个树进行遍历)
（a）计算残差:
$$r_{mi}=y_i-f_{m-1}\left(x_i\right),i=1,2,\dots ,N$$
（b） 拟合残差 $r_{mi}$ 学习一个回归树，得到 $T\left(x;{\Theta }_m\right)$
（c）更新 $f_m(x)=f_{m-1}(x)+T(x;\Theta m)$
(3) 得到回归问题的提升树
$$f_M(x)=\sum _{m=1}^{M}T\left(x;{\Theta }_m\right)$$

3. 回归提升树示例

提升树计算实例，以下实例来自于《统计机器学习》
数据集：

$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

对于上述训练样本，设定基本模型为只有一个节点回归树模型（树桩）。x的取值范围为区间[0.5, 10.5]，y的取值范围为区间[5.0, 10.0]。可能的切分点为1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5。

树桩是由一个根节点直接连接两个叶结点的简单决策树。

首先通过以下优化问题寻找回归树的最佳切分点：

3.1 求 $f_1(x)$ 即回归树 $T_1(x)$

样本输入空间划分的基本步骤如下:
首先通过以下优化问题:
${\min }_{(s)}\left[{\min }_{\left(c_1\right)}{\sum }_{x_i\in R_1}{\left(y_i-c_1\right)}^2+{\min }_{\left(c_2\right)}{\sum }_{x_i\in R_2}{\left(y_i-c_2\right)}^2\right]$
求解训练数据的切分点 $\mathrm{s}:$
R 1 = { x ∣ x ≤ s } , R 2 = { x ∣ x > s } R_1=\{x \mid x \leq s\}, R_2=\{x \mid 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) 求训练数据的切分点
这里的切分点指的是将x值划分界限，数据中x的范围是 $[1,10]$ ，假设我们考虑如下切分点:
$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(s)={\min }_{\left(c_1\right)}{\sum }_{x_i\in R_1}{\left(y_i-c_1\right)}^2+{\min }_{\left(c_2\right)}{\sum }_{x_i\in R_2}{\left(y_i-c_2\right)}^2$
例如: 当 $s=1.5$ 时， R 1 = { 1 } , R 2 = { 2 , 3 , … , 10 } R_1=\{1\}, R_2=\{2,3, \ldots, 10\} R1​={1},R2​={2,3,…,10} ，那么:
$$\begin{gathered} c_1=5.56 \\ {c}_2=\frac{1}{9}(5.70+5.91+6.40+6.80+7.05+8.90+8.70+9.00+9.05)=7.50 \end{gathered}$$
$m(1.5)={\min }_{\left(c_1\right)}{\sum }_{x_i\in R_1}{\left(y_i-c_1\right)}^2+{\min }_{\left(c_2\right)}{\sum }_{x_i\in R_2}{\left(y_i-c_2\right)}^2=0+15.72$ $=15.72$

现将s及m(s)的计算结果列表如下：

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

(2)求回归树
由上表可知，当 $\mathrm{s}=6.5$ 时， $\mathrm{m}(\mathrm{s})$ 达到最小值，此时 R 1 = { 1 , 2 , … , 6 } , R 2 = { 7 , 8 , 9 , 10 } R_1=\{1,2, \ldots, 6\}, R_2=\{7,8,9,10\} R1​={1,2,…,6},R2​={7,8,9,10} ， 且:
$$\begin{array}{rl}& c_1=\frac{1}{6}(5.56+5.70+5.91+6.40+6.80+7.05)=6.24\\ & c_2=\frac{1}{4}(8.90+8.70+9.00+9.05)=8.91\end{array}$$
因此，回归树 $T_1(x)$ 为:
$$T_1(x)=\{\begin{array}{ll}6.24,& x<6.5\\ 8.91,& x\ge 6.5\end{array}$$
(3)求当前加法模型 $f_1(x)$
当前的加法模型为:
$$f_1(x)=T_1(x)$$
(4)求当前加法模型的残差
用 $f_1(x)$ 拟合训练数据的残差如表所示 ，表中 $r_{2i}=y_i-f_1\left(x_i\right),i=1,2,\dots ,10$ 。

$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\left(y,f_1(x)\right)=\sum _{i=1}^{10}{\left(y_i-f_1\left(x_i\right)\right)}^2=1.93$$
这里的误差为 $1.93$ ，如果我们定义终止时候的误差比这个误差要小，那么算法继续执行以上步骤， 直到满足误差为止。

3.2 求回归树 $T_2(x)$

方法与求 $T_1(x)$ 一样，只是拟合的数据是残差表。
(1)求解数据的切分点
仍然对区域 R = { 1 , 2 , … , 10 } R=\{1,2, \ldots, 10\} R={1,2,…,10} 求解数据的切分点。当 $\mathrm{s}=1.5$ 时， R 1 ′ = { 1 } , R 2 ′ = { 2 , 3 , … , 10 } R_{1^{\prime}}=\{1\}, R_{2^{\prime}}=\{2,3, \ldots, 10\} R1′​={1},R2′​={2,3,…,10} ，那么:
$$\begin{array}{rl}& c_{1^{\prime }}=-0.68\\ & c_{2^{\prime }}=\frac{1}{9}(-0.54-0.33+0.16+0.56+0.81-0.01-0.21+0.09+0.14)=0.07\\ & m(1.5)=\underset{\left(c_1\right)}{\min }\sum _{x_i\in R_1}{\left(r_{2i}-c_1\right)}^2+\underset{\left(c_2\right)}{\min }\sum _{x_i\in R_2}{\left(r_{2i}-c_2\right)}^2=0+1.42\\ & =1.42\end{array}$$
现将 $s$ 及 $m(s)$ 的计算结果列表如下 (见表4)：
表4 $\text{ s 、 m(s)}$计算结果

s	1.5	2.5	3.5	4.5	5.5	6.5	7.5	8.5	9.5
$m(s)$	1.42	1.01	0.80	1.14	1.67	1.93	1.93	1.90	1.91

(2)求回归树
由表4可知，当 $s=3.5$ 时 $m(s)$ 达到最小值，此时
R 1 ′ = { 1 , 2 , 3 } , R 2 ′ = { 4 , 5 , … , 10 } , c 1 = − 0.52 , c 2 = 0.22 R_{1^{\prime}}=\{1,2,3\}, R_{2^{\prime}}=\{4,5, \ldots, 10\}, c_1=-0.52, c_2=0.22 R1′​={1,2,3},R2′​={4,5,…,10},c1​=−0.52,c2​=0.22 ，所以回归树 $T_2(x)$ 为:
$$T_2(x)=\{\begin{array}{ll}-0.52,& x<3.5\\ 0.22,& x\ge 3.5\end{array}$$
(3) 求当前加法模型 $f_2(x)$
$$f_2(x)=f_1(x)+T_2(x)=\{\begin{array}{ll}5.72,& x<3.5\\ 6.46,& 3.5⩽x<6.5\\ 9.13,& x⩾6.5\end{array}$$
（4）求当前加法模型的残差
用 $f_2(x)$ 拟合训练数据的残差如表5，表中 $r_{3i}=y_i-f_2\left(x_i\right),i=1,2,\dots ,10$ 。

$x_i$	1	2	3	4	5	6	7	8	9	10
$r_{3i}$	-0.16	-0.02	0.19	-0.06	0.34	0.59	-0.23	-0.43	-0.13	-0.08

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

之后的过程同步骤2一样，我就不在这里故述啦! 最后，给出完整的回归提升树模型。
$$\begin{array}{rl}{T}_3(x)& =\{\begin{array}{ll}0.15,& x<6.5\\ -0.22,& x⩾6.5\end{array}L\left(y,f_3(x)\right)=0.47,\\ T_4(x)& =\{\begin{array}{ll}-0.16,& x<4.5\\ 0.11,& x⩾4.5\end{array}L\left(y,f_4(x)\right)=0.30,\\ T_5(x)& =\{\begin{array}{ll}0.07,& x<6.5\\ -0.11,& x⩾6.5\end{array}L\left(y,f_5(x)\right)=0.23,\\ T_6(x)& =\{\begin{array}{ll}-0.15,& x<2.5\\ 0.04,& x⩾2.5\end{array}\\ f_6(x)& =f_5(x)+T_6(x)=T_1(x)+\cdots +T_5(x)+T_6(x)\\ & =\{\begin{array}{ll}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\end{array}\end{array}$$
用 $f_6(x)$ 拟合训练数据的平方损失误差是
$$L\left(y,f_6(x)\right)=\sum _{i=1}^{10}{\left(y_i-f_6\left(x_i\right)\right)}^2=0.17$$
假设此时已满足误差要求, 那么 $f(\mathrm{x})=f_6(\mathrm{x})$ 即为所求提升树。

4. python代码

import numpy as np

label = np.array([5.56, 5.7, 5.91, 6.4, 6.8, 7.05, 8.9, 8.7, 9, 9.05])

# 已经排好序了。实际情况中单一特征的数据或者多特征的数据，选择切分点的时候也像决策树一样选择
feature = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


class Tree_model:
    def __init__(self, stump, mse, left_value, right_value, residual):
        '''
        :param stump: 为feature最佳切割点
        :param mse: 为每棵树的平方误差
        :param left_value: 为决策树左值
        :param right_value: 为决策树右值
        :param residual: 为每棵决策树生成后余下的残差
        '''
        self.stump = stump
        self.mse = mse
        self.left_value = left_value
        self.right_value = right_value
        self.residual = residual


'''根据feature准备好切分点。例如:
feature为[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
切分点为[1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]
'''


def Get_stump_list(feature):
    # 特征值从小到大排序好,错位相加
    tmp1 = list(feature.copy())
    tmp2 = list(feature.copy())
    tmp1.insert(0, 0)
    tmp2.append(0)
    stump_list = ((np.array(tmp1) + np.array(tmp2)) / float(2))[1:-1]
    return stump_list


# 此处的label其实是残差
def Get_decision_tree(stump_list, feature, label):
    best_mse = np.inf
    best_stump = 0  # min(stump_list)
    residual = np.array([])
    left_value = 0
    right_value = 0
    for i in range(np.shape(stump_list)[0]):
        left_node = []
        right_node = []
        for j in range(np.shape(feature)[0]):
            if feature[j] < stump_list[i]:
                left_node.append(label[j])
            else:
                right_node.append(label[j])
        left_mse = np.sum((np.average(left_node) - np.array(left_node)) ** 2)
        right_mse = np.sum((np.average(right_node) - np.array(right_node)) ** 2)
        # print("decision stump: %d, left_mse: %f, right_mse: %f, mse: %f" % (i, left_mse, right_mse, (left_mse + right_mse)))
        if best_mse > (left_mse + right_mse):
            best_mse = left_mse + right_mse
            left_value = np.average(left_node)
            right_value = np.average(right_node)
            best_stump = stump_list[i]
            left_residual = np.array(left_node) - left_value
            right_residual = np.array(right_node) - right_value
            residual = np.append(left_residual, right_residual)
            # print("decision stump: %d, residual: %s"% (i, residual))
    Tree = Tree_model(best_stump, best_mse, left_value, right_value, residual)
    return Tree, residual


# Tree_num就是树的数量
def BDT_model(feature, label, Tree_num=100):
    feature = np.array(feature)
    label = np.array(label)
    stump_list = Get_stump_list(feature)
    Trees = []
    residual = label.copy()
    # 产生每一棵树
    for num in range(Tree_num):
        # 每次新生成树后，还需要再次更新残差residual
        Tree, residual = Get_decision_tree(stump_list, feature, residual)
        Trees.append(Tree)
    return Trees


def BDT_predict(Trees, feature):
    predict_list = [0 for i in range(np.shape(feature)[0])]
    # 将每棵树对各个特征预测出来的结果进行相加，相加的最后结果就是最后的预测值
    for Tree in Trees:
        for i in range(np.shape(feature)[0]):
            if feature[i] < Tree.stump:
                predict_list[i] = predict_list[i] + Tree.left_value
            else:
                predict_list[i] = predict_list[i] + Tree.right_value
    return predict_list


# 计算误差
def Get_error(predict, label):
    predict = np.array(predict)
    label = np.array(label)
    error = np.sum((label - predict) ** 2)
    return error


Trees = BDT_model(feature, label)
predict = BDT_predict(Trees, feature)
print("The error is ", Get_error(predict, label))
print(predict)