树模型学习笔记整理

决策树是一种基本算法，可以解决分类和回归问题。在分类问题中，类似 if-then的规则，基于样本特征对其进行空间划分并分类，其优点是可读性强、分类速度快。

一、原理

1. 决策树由结点和有向边组成，结点分为内部结点(表示一个特征)、叶节点(表示一个分类)，有向边代表了划分规则。
2. 决策树还表示给定特征条件下类的条件概率分布。假设$X$为表示特征的随机变量，$Y$表示类的随机变量，这个条件概率就可表示为$P(Y|X)$。各叶节点上的条件概率往往偏向于某一类，即属于某一类的概率较大。决策树分类时将该结点的实例强行分到条件概率大的那一类。
3. 决策树学习本质上是从训练数据集中归纳出一组分类规则，这组规则对应的条件概率模型不仅对训练数据有很好的拟合能力，对未知数据也需要有很好的泛化能力。
4. 决策树学习用损失函数表示目标。决策树学习的损失函数通常是正则化的极大似然函数。决策树学习的策略是最小化损失函数。
5. 决策树生成算法：
   ① 构建根结点：将所有训练数据放在根结点。
   ② 选择一个最优特征，根据这个特征将训练数据分割成子集，使得各个子集有一个在当前条件下最好的分类。若这些子集已能够被基本正确分类，则将该子集构成叶结点。若某个子集不能够被基本正确分类，则对该子集选择新的最优的特征，继续对该子集进行分割，构建相应的结点。
   ③ 如此递归下去，直至所有训练数据子集都被基本正确分类，或者没有合适的特征为止。
6. 上述生成的决策树可能对训练数据有很好的分类能力，但是对于未知的测试数据却未必有很好要的分类能力，即可能发生过拟合的现象。
7. 过拟合解决的方法是：对生成的决策树进行剪枝，从而使得决策树具有更好的泛化能力。
8. 决策树学习算法包含特征选择、决策树的生成、决策树的剪枝过程。决策树的生成对应着模型的局部最优，决策树的剪枝则考虑全局最优。

二、特征选择

1. 特征选择在于选取对训练数据有较强分类能力的特征。若一个特征的分类结果与随机分类的结果没有什么差别，则称这个特征是没有分类能力的。通常特征选择的准则是信息增益或者信息增益比。
2. 直观上，如果一个特征具有更好的分类能力，或者说，按照这一特征将训练集分割成子集，使得各个子集在当前条件下有最好的分类，那么就更应该选择这个特征。
3. 在信息论和概率统计中，熵是表示随机变量不确定性的度量。假设$X$的概率分布为$P(X=x_i)=p_i$，则熵为$$H(X)=-\sum _{i=0}^n{p}_i\log p_i$$
   由定义可知，熵只依赖于$X$的分布，而与$X$的取值无关，所以也可将$X$的熵记作$H(p)$，即$$H(p)=-\sum _{i=0}^n{p}_i\log p_i$$
   条件熵$H(Y|X)$表示在已知随机变量$X$的条件下随机变量$Y$的不确定性，定义为$X$给定条件$Y$下的条件概率分布的熵对的数学期望$$H(Y|X)=-\sum _{i=0}^n{p}_{i}H(Y|X=x_i)$$
   其中，$p_i=P(X=x_i)，i=1,2,...,n.$

2.1信息增益

      信息增益表示得知特征$X$的信息而使得类$Y$的信息的不确定性减少的程度。
      特征$A$对训练数据集$D$的信息增益$g(D,A)$，定义为集合$D$的经验熵与特征$A$给定条件下的经验条件熵$H(D|A)$之差，即$$g(D,A)=H(D)-H(D|A)$$
      一般地，熵$H(Y)$与条件熵$H(Y|X)$之差成为互信息，决策树学习中的信息增益等价于训练数据集中类与特征的互信息。
      决策树学习应用信息增益准则选择特征。对于数据集$D$而言，信息增益依赖于特征，不同的特征往往具有不同的信息增益。信息增益大的特征具有更强的分类能力。
      根据信息增益准则的特征选择方法是$D$：对训练数据集，计算器每个特征的信息增益，并比较它们的大小，选择信息增益最大的特征。
      设训练数据集$D$，表示$|D|$其样本容量，即样本个数。设有$K$个类$C_k,k=1,2,...K$，$|K|$为属于类$C_k$的样本个数，${\sum }_{k=1}^K|C_k|=|D|$。设特征$A$有$n$个不同的取值 { a 1 , a 2 , . . . , a n } \{a_1,a_2,...,a_n\} {a1​,a2​,...,an​}，根据特征$A$的取值将$D$划分为$n$个子集$D_1,D_2,...,D_n$，$|D_i|$为$D_i$的样本个数，${\sum }_{i=1}^n|D_i|=|D|.$记子集$D_i$中属于$C_k$类的样本集合为$D_{ik}$，即$D_{ik}=D_i\bigcap C_k$，$|D_{ik}|$为$D_{ik}$的样本个数。于是信息增益的算法如下：
     （1）输入：训练数据集$D$和特征$A$；
     （2）输出：特征$A$对训练数据集$D$的信息增益$g(D,A).$
               ① 计算数据集$D$的经验熵$H(D)$ $$H(D)=-\sum _{k=1}^K\frac{|C_k|}{D}{\log }_2\frac{|C_k|}{D}$$
               ② 计算特征$A$对数据集$D$的经验条件熵$H(D|A)$ $$H(D|A)=\sum _{i=1}^n\frac{|D_i|}{D}H(D_i)=-\sum _{i=1}^n\frac{|D_i|}{D}\sum _{k=1}^K\frac{|D_{ik}|}{|D_i|}{\log }_2\frac{|C_k|}{D}\frac{|D_{ik}|}{|D_i|}$$
               ③ 计算信息增益 $$g(D,A)=H(D)-H(D|A)$$

2.2信息增益比

      以信息增益作为划分训练数据集的特征，存在偏向于选择取值较多的特征的问题。使用信息增益 比可以对这一问题进行校正，这是特征选择的另一准则。
      特征$A$对训练数据集$D$的信息增益比$g_R(D,A)$定义为其信息增益$g(D,A)$与训练数据集$D$关于特征$
A$的值的熵$H_A(D)$之比，即$$g_R(D,A)=\frac{g(D,A)}{H_A(D)}$$
      其中$H_A(D)=-{\sum }_{i=1}^n\frac{|D_i|}{D}{\log }_2\frac{|D_i|}{D}$，$n$是特征$A$取值的个数。

三、生成算法

3.1 ID3算法

      ID3算法的核心是在决策树各个结点上应用信息增益准则选择特征，递归地构建决策树。具体方法是：从根结点开始，对结点计算所有可能的特征的信息增益，选择信息增益最大的特征作为结点的特征，由该特征的不同取值建立子结点；再对子结点递归地调用以上方法，构建决策树；直到所有特征的信息增益均很小或没有特征可以选择为止。最后得到一个决策树，ID3相当于用极大似然法进行概率模型的选择。
      ID3算法：
      输入：训练数据集$D$，特征集$A$，阈值$ϵ$
      输出：决策树$T.$
      （1）若$D$中所有实例属于同一类$C_k$，则$T$为单结点树，并将类$C_k$作为该结点的类标记，返回$T$；
      （2）若$A=\varnothing$，则$T$为单结点树，并将$D$中实例数最大的类$C_k$作为该结点的类标记，返回$T$；
      （3）否则，按信息增益计算算法计算$A$中各特征对$D$的信息增益，选择信息增益最大的特征$A_g$；
      （4）如果$A_g$的信息增益小于阈值$ϵ$，则置$T$为单结点树，并将$D$中实例数最大的类$C_k$作为该结点的类标记，返回$T$；
      （5）否则，对$A_g$的每一可能值$a_i$，依$A_g=a_i$将$D$分割为若干非空子集$D_i$，将$D_i$中实例数最大的类作为标记，构建子结点，由结点及其子结点构成树$T$，返回$T$；
      （6）对第$i$个子结点，以$D_i$为训练集，以 A − { A g } A-\{A_g\} A−{Ag​}为特征集，递归地调用步(1)~步(5)，得到子树$T_i$，返回$T_i$。

3.2 C4.5的生成算法

      C4.5算法与ID3算法相似，C4.5算法对ID3算法进行了改进。C4.5在生成的过程中，用信息增益比来选择特征。
      输入：训练数据集$D$，特征集$A$，阈值$ϵ$
      输出：决策树$T.$
      （1）若$D$中所有实例属于同一类$C_k$，则$T$为单结点树，并将类$C_k$作为该结点的类标记，返回$T$；
      （2）若$A=\varnothing$，则$T$为单结点树，并将$D$中实例数最大的类$C_k$作为该结点的类标记，返回$T$；
      （3）否则，按信息增益比计算算法计算$A$中各特征对$D$的信息增益比，选择信息增益比最大的特征$A_g$；
      （4）如果$A_g$的信息增益比小于阈值$ϵ$，则置$T$为单结点树，并将$D$中实例数最大的类$C_k$作为该结点的类标记，返回$T$；
      （5）否则，对$A_g$的每一可能值$a_i$，依$A_g=a_i$将$D$分割为若干非空子集$D_i$，将$D_i$中实例数最大的类作为标记，构建子结点，由结点及其子结点构成树$T$，返回$T$；
      （6）对第$i$个子结点，以$D_i$为训练集，以 A − { A g } A-\{A_g\} A−{Ag​}为特征集，递归地调用步(1)~步(5)，得到子树$T_i$，返回$T_i$。

四、决策树的剪枝

      决策树生成算法递归地产生决策树，直到不能继续下去为止。这样产生的树往往对训练数据的分类很准确，但对未知的测试数据的分类却没有那么准确，即出现过拟合现象。解决这个问题的办法是考虑决策树的复杂度，对已生成的决策树进行简化。
      在决策树学习中将已生成的树进行简化的过程称为剪枝。
      决策树的剪枝往往通过极小化决策树整体的损失函数来实现。设树$T$的叶结点个数为$|T|$，$t$是树$T$的叶结点，该叶结点有$N_t$个样本点，其中$k$类的样本点有$N_{tk}$个，$k=1,2,...,K$，$H_t(T)$为叶结点$t$上的经验熵，$\alpha \ge 0$为参数，则决策树学习的损失函数可以定义为$$C_{\alpha }(T)=\sum _{t=1}^{|T|}{N}_t{H}_t(T)+\alpha |T|$$
      其中经验熵为$$H_t(T)=-\sum _k\frac{N_{tk}}{N_t}{\log }_2\frac{N_{tk}}{N_t}$$
      另外，损失函数还可以表示为$$C_{\alpha }(T)=C(T)+\alpha |T|$$
      其中，$$C(T)=\sum _{t=1}^{|T|}{N}_t{H}_t(T)=-\sum _{t=1}^{|T|}\sum _{k=1}^K{N}_{tk}\log \frac{N_{tk}}{N_t}$$
      $C(T)$表示模型对训练数据的预测误差，即模型与训练数据的拟合程度，$|T|$表示模型复杂度，参数$\alpha \ge 0$控制两者之间的影响，较大的$\alpha$促使选择较简单的模型，较小的$\alpha$促使选择较复杂的模型，$\alpha =0$意味着只考虑模型与训练数据的拟合程度，不考虑模型的复杂度。
      剪枝，就是当$\alpha$确定时，选择损失函数最小的模型，即损失函数最小的子树。当$\alpha$值确定时，子树越大，往往与训练数据的拟合越好，但是模型的复杂度越高；相反，子树越小，模型的复杂度越低，但是往往与训练数据的拟合不好。损失函数正好表示了对两者的平衡。
      决策树生成只考虑了通过提高信息增益（或信息增益比）对训练数据进行更好的拟合。而决策树剪枝通过优化损失函数还考虑了减小模型复杂度。决策树生成学习局部的模型，而决策树剪枝学习整体的模型。
      上面损失函数的极小化等价于正则化的极大似然估计。所以，利用损失函数最小原则进行剪枝就是用正则化的极大似然估计进行模型选择。
      剪枝算法介绍如下：
             输入：生成算法产生的整个树$T$，参数$\alpha$；
             输出：修剪后的子树$T_{\alpha }$。
             （1）计算每个结点的经验熵。
             （2）递归地从树的叶结点向上回缩。
             设一组叶结点回缩到其父结点之前与之后的整体树分别为$T_B$与$T_A$，其对应的损失函数值分别是$C_{\alpha }(T_B)$与$C_{\alpha }(T_A)$，如果$$C_{\alpha }(T_A)\le C_{\alpha }(T_B)$$
             则进行剪枝，即将父结点变为新的叶结点。
             （3）返回（2），直至不能继续为止，得到损失函数最小的子树$T_A$。

五、CART算法

      CART同样由特征选择、树的生成及剪枝组成，既可以用于分类也可以用于回归。
      CART是在给定输入随机变量$X$条件下输出随机变量$Y$的条件概率分布的学习方法。CART假设决策树是二叉树，内部结点特征的取值为“是”和“否”，左分支是取值为“是”的分支，右分支是取值为“否”的分支。这样的决策树等价于递归地二分每个特征，将输入空间即特征空间划分为有限个单元，并在这些单元上确定预测的概率分布，也就是在输入给定的条件下输出的条件概率分布。
      CART算法由以下两步组成：
      （1）决策树生成：基于训练数据集生成决策树，生成的决策树要尽量大；
      （2）决策树剪枝：用验证数据集对已生成的树进行剪枝并选择最优子树，这时用损失函数最小作为剪枝的标准。

5.1 CART生成

      决策树的生成及时递归地构建二叉决策树的过程。对回归树用平方误差最小化准则，对分类树用基尼系数最小化准则，进行特征选择，生成二叉树。
      1. 回归树的生成
      假设$X$与$Y$分别为输入和输出变量，并且$Y$是连续变量，给定训练数据集 D = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } D = \{ (x_1,y_1),(x_2,y_2),...,(x_N,y_N) \} D={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}
      一个回归树对应着输入空间的一个划分以及在划分的单元上的输出值。假设已将输入空间划分为$M$个单元$R_1,R_2,...,R_M$，并且在每个单元$R_M$上有一个固定的输出值$c_m$，于是回归树模型可表示为$$f(x)=\sum _{m=1}^M{c}_{m}I(x\in R_m)$$
      当输入空间的划分确定时，可以用平方误差${\sum }_{x_i\in R_m}(y_i-f(x_i){)}^2$来表示回归树对于训练数据的预测误差，用平方误差最小的准则求解每个单元上的最优输出值。易知，单元$R_M$上的$c_m$的最优估计值${\hat{c}}_m$是$R_M$上的所有输入实例$x_i$对应的输出$y_i$的均值，即$${\hat{c}}_m=ave(y_i|x_i\in R_m)$$
      问题是怎样对输入空间进行划分。这里采用启发式的方法，选择第$j$个变量$x^j$和它取的值$s$，作为切分变量和切分点，并定义两个区域： R 1 ( j , s ) = { x ∣ x j ≤ s } 和 R 2 ( j , s ) = { x ∣ x j > s } R_1(j,s) = \{ x | x^j \le s \} 和 R_2(j,s) = \{ x | x^j \gt s \} R1​(j,s)={x∣xj≤s}和R2​(j,s)={x∣xj>s}
      然后寻找最优切分变量$j$和最优切分点$s$。具体地，求解$$\underset{j,s}{\min }[\underset{c_1}{\min }\sum _{x_i\in R_1(j,s)}(y_i-c_1{)}^2+\underset{c_2}{\min }\sum _{x_i\in R_2(j,s)}(y_i-c_2{)}^2]$$
      对固定输入变量$j$可以找到最优切分点$s$。$${\hat{c}}_1=ave(y_i|x_i\in R_1(j,s))和{\hat{c}}_2=ave(y_i|x_i\in R_2(j,s))$$
      遍历所有输入变量$j$，找到最优的切分变量，构成一个对$(j,s)$。依次将输入空间划分为两个区域。接着，对每个区域重复上述划分过程，直到满足停止条件为止。这样就生成一颗回归树。这样的回归树通常称为最小二乘回归树，现将算法整理如下：
      最小二乘回归树生成算法：
      输入，训练数据集$D$；
      输出：回归树$f(x)$。
      在训练数据集所在的输入空间中，递归地将每个区域划分为两个子区域并决定每个子区域上的输出值，构建二叉决策树；
      （1）选择最优切分变量$j$与切分点$s$，求解$$\underset{j,s}{\min }[\underset{c_1}{\min }\sum _{x_i\in R_1(j,s)}(y_i-c_1{)}^2+\underset{c_2}{\min }\sum _{x_i\in R_2(j,s)}(y_i-c_2{)}^2]$$
      遍历变量$j$，对固定的切分变量$j$扫描切分点$s$，选择使上式达到最小值的对$(j,s)$.
      （2）用选定的对$(j,s)$划分区域并决定相应的输出值： R 1 ( j , s ) = { x ∣ x j ≤ s } ， R 2 ( j , s ) = { x ∣ x j > s } R_1(j,s) = \{ x | x^j \le s \} ，R_2(j,s) = \{ x | x^j \gt s \} R1​(j,s)={x∣xj≤s}，R2​(j,s)={x∣xj>s} $${\hat{c}}_m=\frac{1}{N_m}\sum (x_i\in R_m(j,s))y_i,x\in R_m,m=1,2$$
      （3）继续对两个子区域调用步骤（1）,（2），直至满足停止条件。
      （4）将输入空间划分为$M$个区域$R_1,R_2,...R_M$，生成决策树：$$f(x)=\sum _{m=1}^M{\hat{c}}_{m}I(x\in R_m)$$

5.2 分类树的生成

      分类树用基尼指数选择最优特征，同时决定该特征的最优二值切分点。
      在分类问题中，假设有$K$个类，样本点属于第$k$类的概率为$p_k$，则概率分布的基尼指数定义为$$Gini(p)=\sum _{k=1}^K{p}_k(1-p_k)=1-\sum _{k=1}^K{p}_k^2$$
      对于二分类问题，弱样本点属于第1个类的概率是$p$，则概率分布的基尼指数为$$Gini(p)=2p(1-p)$$
      对于给定的样本集合$D$，其基尼指数为$$Gini(p)=1-\sum _{k=1}^K(\frac{|C_k|}{D}{)}^2$$
      这里，$C_k$是$D$中属于第$k$类的样本子集，$K$是类的个数。
      如果样本集合$D$根据特征$A$是否取某一可能值$a$被分割成$D_1$和$D_2$两部分，即 D 1 = { ( x , y ) ∈ D ∣ A ( x ) = α } , D 2 = D − D 1 D_1 = \{ (x,y) \in D | A(x) = \alpha \},D_2 = D - D_1 D1​={(x,y)∈D∣A(x)=α},D2​=D−D1​
      则在特征$A$的条件下，集合$D$的基尼指数定义为$$Gini(D,A)=\frac{|D_1|}{D}Gini(D_1)+\frac{|D_2|}{D}Gini(D_2)$$
      基尼指数$Gini(D)$表示集合$D$的不确定性，基尼指数$Gini(D,A)$表示经$A=\alpha$分割后集合$D$的不确定性。基尼指数值越大，样本集合的不确定性也就越大。
      CART生成算法：
      输入：训练数据集$D$，停止计算的条件：
      输出：CART决策树
      根据训练数据集，从根结点开始，递归地对每个结点进行操作，构建二叉决策树：
      （1）设结点的训练数据集为$D$，计算现有特征对该数据集的基尼指数。此时，对每一个特征$A$，对其可能取的每个值$\alpha$，根据样本点对$A=\alpha$ 的测试为“是”或“否”将$D$分割成$D_1$和$D_2$两部分，计算$A=\alpha$ 时的基尼指数。
      （2）在所有可能的特征$A$以及它们所有可能的切分点$\alpha$中，选择基尼指数最小的特征及其对应的切分点作为最优特征与最优切分点。依最优特征与最优切分点，从现结点生成两个子结点，将训练数据集依特征分配到两个子结点中去。
      （3）对两个子结点递归地调用（1），（2），直至满足停止条件。
      （4）生成CART决策树。
      算法停止计算的条件是结点中的样本个数小于预定阈值，或样本集的基尼指数小于预定阈值，或者没有更多特征。

5.3 CART剪枝

      CART剪枝算法：
      输入：CART算法生成的决策$T_0$；
      输出：最优决策树$T_{\alpha }$。
      （1）设$k=0,T=T_0$。
      （2）设$\alpha =+\infty$。
      （3）自下而上地对各内部结点$t$计算$C(T_t)$，$|T_t|$以及$$g(t)=\frac{C(t)-C(T_t)}{|T_t|-1}$$ $$\alpha =min(\alpha ,g(t))$$
      这里，$T_t$表示以$t$为根结点的子树，$C(T_t)$是对训练数据的预测误差，$|T_t|$是$T_t$的叶结点个数。
      （4）对$g(t)=\alpha$的内部结点$t$进行剪枝，并对叶结点$t$以多数表决法决定其类，得到树$T$。
      （5）设$k=k+1,{\alpha }_k=\alpha ,T_k=T$.
      （6）如果$T_k$不是由根结点及两个叶结点构成的树，则回到步骤（3）；否则令$T_k=T_n$.
      （7）采用交叉验证法在子树序列$T_0,T_1,...,T_n$中选取最优子树$T_{\alpha }$

六、提升树

6.1 AdaBoost算法

1. 原理介绍
   略
2. AdaBoost算法的解释
           AdaBoost算法还有另外一个解释，即可以认为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​)}；损失函数$L(y,f(x))$$；基函数集 { b ( x ; γ ) } \{b(x;\gamma)\} {b(x;γ)}；
   输出：加法模型$f(x)$。
   （1）初始化$f_0(x)=0$
   （2）对$m=1,2,...M$
   （a）极小化损失函数 $$({\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 }_m$
   （b）更新$$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)$$
   这样，前向分步算法将同时求解从$m=1$到$M$所有参数${\beta }_m,{\gamma }_m$，的优化问题简化为逐次求解各个${\beta }_m,{\gamma }_m$的优化问题。

6.2 提升树

      提升树是以分类树或回归树为基本分类器的提升方法。提升树被认为是统计学习性能最好的方法之一。

6.2.1 提升树模型

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

6.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;{\Theta }_m))$$
      这里没有引入正则化，而在xgboost中会引入正则化。
      针对不同问题的提升树学习算法，其主要区别在于使用的损失函数不同。包括用平方误差损失函数的回归问题，用指数损失函数的分类问题，以及用一般损失函数的一般决策问题。
      对于二分类问题，提升树算法只需要将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}\subseteq {\Re }^n$，$\mathcal{X}$为输入空间，$y_i\in \mathcal{Y}\subseteq \Re$，$\mathcal{Y}$为输出空间。如果将输入空间$\mathcal{X}$划分为$J$个互不相交的区域$R_1,R_2,...R_J$，并且在每个区域上确定输出的常量$c_j$，那么树可表示为 $$T(x;{\Theta }_m)=\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 _{m=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;{\Theta }_m))$$
      得到${\hat{\Theta }}_m$，即第$m$颗树的参数。
      当采用平方误差损失函数时，$$L(y,f(x))=(y-f(x){)}^2$$
      其损失变为$$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$$
      这里，$$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}\subseteq {\Re }^n，y_i\in \mathcal{Y}\subseteq \Re$
      提升树$f_M(x)$.
      （1）初始化$f_0(x)=0$
      （2）对$m=1,2,...,M$
      （a）计算残差$$r_{mi}=y_i-f_{m-1}(x_i)$$
      （b）拟合残差$r_{mi}$学习一个回归树，得到$T(x;{\Theta }_m)$
      （c）更新$f_m(x)=f_{m-1}(x)+T(x;{\Theta }_m)$
      （3）得到回归问题提升树$$f_M(x)=\sum _{m=1}^{M}T(x;{\Theta }_m)$$

6.2.3 梯度提升

      提升树利用加法模型与前向分步算法实现学习的优化过程。当损失函数是平方损失和指数损失时，每一步优化是简单的。但对一般损失函数而言，往往每一步优化并不容易。针对这一问题，Freidman提出了梯度提升算法。这是利用最速下降法的近似方法，其关键是利用损失函数的负梯度在当前模型的值$$-[\frac{\partial L(y,f(x_i)))}{\partial f(x_i)}{]}_{f(x)=f_{m-1}(x)}$$
      原因：
      根据：$$L(y,f_m(x))=L(y,f_{m-1}(x)+h_m(x;{\Theta }_m))=L(y,f_{m-1}(x))+\frac{\partial L(y,f_{m-1}(x))}{\partial f_{m-1}(x)}{h}_m(x;{\Theta }_m)$$
      其中$h_m(x;{\Theta }_m)$表示基函数。
      则有$$\Delta L=L(y,f_m(x))-L(y,f_{m-1}(x)=\frac{\partial L(y,f_{m-1}(x))}{\partial f_{m-1}(x)}{h}_m(x;{\Theta }_m)$$
      要使得损失函数降低，一个可选的方案就是：$h_m(x;{\Theta }_m)=-\frac{\partial L(y,f_{m-1}(x))}{\partial 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}\subseteq {\Re }^n，y_i\in \mathcal{Y}\subseteq \Re$；损失函数$L(y,f(x))$
      输出回归树$\hat{f}(x)$
      （1）初始化$$f_0(x)=arg\underset{c}{\min }\sum _{i=1}^{N}L(y_i,c)$$
      （2）对$m=1,2,...,M$
      （a）对$i=1,2,...,N$，计算$$r_{mi}=-[\frac{\partial L(y_i,f(x_i)))}{\partial f(x_i)}{]}_{f(x)=f_{m-1}(x)}$$
      （b）对$r_{mi}$拟合一个回归树，得到第颗树的叶结点区域$R_{mj},j=1,2,...,J$
      （c）对$j=1,2,...,J$，计算$$c_{mj}=arg\underset{c}{\min }\sum _{x_i\in R_{mj}}L(y_i,f_{m-1}(x_i)+c)$$
      （d）更新$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})$$
      算法第1步初始化，估计使损失函数极小化的常数值，它是只有一个根结点的树。第2(a)步计算损失函数的负梯度在当前模型的值，将它作为残差的估计。对于平方损失函数，它就是通常所说的残差；对于一般损失函数，它就是残差的近似值、第2(b)步估计回归树叶结点区域，以拟合残差的近似值。第2©步利用线性搜索估计叶结点区域的值，使损失函数极小化。第2(d)步得到输出的最终模型$\hat{f}(x)$。
      梯度提升树用于分类模型时，是梯度提升决策树GBDT；用于回归问题时，是梯度提升回归树GBRT。

6.2.4 随机森林 VS 梯度提升树

1. 从模型框架的角度来看：梯度提升树为boosting 模型，随机森林为bagging 模型。
2. 从偏差分解的角度来看：①梯度提升树采用弱分类器（高偏差，低方差）。梯度提升树综合了这些弱分类器，在每一步的过程中降低了偏差，但是保持低方差。②随机森林采用完全成长的子决策树（低偏差，高方差）。随机森林要求这些子树之间尽可能无关，从而综合之后能降低方差，但是保持低偏差。
3. 如果在梯度提升树和随机森林之间二选一，几乎总是建议选择梯度提升树。
4. 随机森林的优点：天然的支持并行计算，因为每个子树都是独立的计算。
5. 梯度提升树的优点：①梯度提升树采用更少的子树来获得更好的精度。因为在每轮迭代中，梯度提升树会完全接受现有树（投票权为1）。而随机森林中每棵树都是同等重要的（无论它们表现的好坏），它们的投票权都是$\frac{1}{N}$ ，因此不是完全接受的。②梯度提升树也可以修改从而实现并行化。③梯度提升树有一个明确的数学模型。因此任何能写出梯度的任务，都可以应用梯度提升树。而随机森林并没有一个明确的数学模型。

6.3 xgboost

1. xgboost 也是使用与提升树相同的前向分步算法。其区别在于：xgboost 通过结构风险极小化来确定下一个决策树的参数${\Theta }_m$：$${\hat{\Theta }}_m=arg\underset{{\Theta }_m}{\min }\sum _{i=1}^{N}L(y_i,f_m(x_i))+\Omega (h_m(x))$$
   其中：①$\Omega (h_m)$为第$m$个决策树的正则化项。这是xgboost与提升树的一个重要区别；② $LL={\sum }_{i=1}^{N}L(y_i,f_m(x_i))+\Omega (h_m(x))$ 为目标函数。
2. 定义：$${\hat{y}}_i^{m-1}=f_{m-1}(x_i),g_i=\frac{\partial L(y_i,{\hat{y}}_i^{m-1})}{\partial {\hat{y}}_i^{m-1}},h_i=\frac{{\partial }^{2}L(y_i,{\hat{y}}_i^{m-1})}{{\partial }^2{\hat{y}}_i^{m-1}}$$
   即：①$g_i$为$L(y_i,{\hat{y}}_i^{m-1})$在$y_i^{m-1}$的一阶导数；②$h_i$为$L(y_i,{\hat{y}}_i^{m-1})$在$y_i^{m-1}$的二阶导数。
   对目标函数$L$执行二阶泰勒展开：$$\begin{array}{rl}LL& =\sum _{i=1}^{N}L(y_i,f_m(x_i))+\Omega (h_m(x))=\sum _{i=1}^{N}L(y_i,{\hat{y}}_i^{m-1}+h_m(x_i))+\Omega (h_m(x))\\ & \approx \sum _{i=1}^N[L(y_i,{\hat{y}}_i^{m-1})+g_i{h}_m(x_i)+\frac{1}{2}{h}_i{h}_m^2(x_i)]+\Omega (h_m(x))+constant\end{array}$$
   提升树模型只采用一阶泰勒展开。这也是xgboost与提升树的另外一个区别。
3. 对一个决策树$h_m(x)$，假设不考虑复杂的推导过程，仅考虑决策树的效果：
   ①给定一个输入$x$，该决策树将该输入经过不断的划分，最终划分到某个叶结点上去；②给定一个叶结点，该叶结点有一个输出值。
   因此将决策树拆分成结构部分$q(\cdot )$，和叶结点权重部分$w=(w_1,w_2,...,w_T)$ ，其中$T$为叶结点的数量。
   ①结构部分$q(x)$的输出是叶结点编号$d$。它的作用是将输入$x$映射到编号为$d$的叶结点；②叶结点权重部分就是每个叶结点的值。它的作用是输出编号为$d$的叶结点的值$w_d$。
   因此决策树改写为:$h_m(x)=w_{q(x)}$。

6.3.1 结构分

1. 定义一个决策树的复杂度为：$$\Omega (h_m(x))=\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2$$
   其中：$T$为叶结点的个数;$w_j$为每个叶结点的输出值；$\gamma ,\lambda \ge 0$为系数，控制这两个部分的比重。
   ①叶结点越多，则决策树越复杂。②每个叶结点输出值的绝对值越大，则决策树越复杂。
   注意：该复杂度是一个经验公式。事实上还有很多其他的定义复杂度的方式，只是这个公式效果还不错。
2. 将树的拆分、树的复杂度代入$L$的二阶泰勒展开，有：$$LL\approx \sum _{i=1}^N[g_i{w}_{q_{(x_i)}}+\frac{1}{2}{h}_i{w}_{q_{(x_i)}}^2]+\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2+constant$$
   对每个样本$x_i$，它必然被划分到树$h_m$的某个叶结点。定义划分到叶结点$j$的样本的集合为： I j = { i ∣ q ( x i ) = j } I_j=\{i|q(x_i)=j\} Ij​={i∣q(xi​)=j}。则有：$$LL\approx \sum _{j=1}^T[(\sum _{i\in I_j}{g}_i)w_j+\frac{1}{2}(\sum _{i\in I_j}{h}_i+\lambda )w_j^2]+\gamma T+constant$$
3. 定义：$G_j={\sum }_{i\in I_j}{g}_i，H_j={\sum }_{i\in I_j}{h}_i$
   ①$G_j$刻画了隶属于叶结点$j$的那些样本的一阶偏导数之和。②$H_j$刻画了隶属于叶结点$j$的那些样本的二阶偏导数之和。③偏导数是损失函数$L$关于当前模型的输出${\hat{y}}_i^{m-1}$的偏导数。
   则上式简化为：$LL\approx {\sum }_{j=1}^T[G_j{w}_j+\frac{1}{2}(H_j+\lambda )w_j^2]+\gamma T+constant$
   假设$w_j$与$T,G_j,H_j$无关，对$w_j$求导等于0，则得到$w_j^{\ast }=-\frac{G_j}{H_j+\lambda }$
   忽略常数项，于是定义目标函数为：$$L\ast =-\frac{1}{2}\sum _{j=1}^T\frac{G_j^2}{H_j+\lambda }+\gamma T$$
4. 在推导过程中假设$w_j$与$T,G_j,H_j$无关，这其实假设已知树的结构。其实，$L\ast$是与$T$相关的，甚至与树的结构相关，因此定义$L\ast$为结构分。结构分刻画了：当已知树的结构时目标函数的最小值。

6.3.2 分解结点

1. 现在的问题是：如何得到最佳的树的结构，从而使得目标函数全局最小。

6.3.2.1 贪心算法

1. 第一种方法是对现有的叶结点加入一个分裂，然后考虑分裂之后目标函数降低多少。如果目标函数下降，则说明可以分裂。如果目标函数不下降，则说明该叶结点不宜分裂。
2. 对于一个叶结点，假如给定其分裂点，定义划分到左子结点的样本的集合为： I L = { i ∣ q ( x i ) = L } I_L=\{i|q(x_i)=L\} IL​={i∣q(xi​)=L}；定义划分到右子结点的样本的集合为： I R = { i ∣ q ( x i ) = R } I_R=\{i|q(x_i)=R\} IR​={i∣q(xi​)=R}。则有：$$G_L=\sum _{i\in I_L}{g}_i,G_R=\sum _{i\in I_R}{g}_i$$ $$H_L=\sum _{i\in I_L}{h}_i,H_R=\sum _{i\in I_R}{h}_i$$ $$G=\sum _{i\in I_L}{g}_i+\sum _{i\in I_R}{g}_i=G_L+G_R$$ $$H=\sum _{i\in I_L}{h}_i+\sum _{i\in I_R}{h}_i=H_L+H_R$$
3. 定义叶结点的分裂增益为：$$Gain=\frac{1}{2}[\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }-\frac{G^2}{H+\lambda }]-\lambda$$
   其中：
   ①$\frac{G_L^2}{H_L+\lambda }$表示：该叶结点的左子树的结构分。
   ②$\frac{G_R^2}{H_R+\lambda }$表示：该叶结点的右子树的结构分。
   ③$\frac{G^2}{H+\lambda }$表示：如果不分裂，则该叶结点本身的结构分。
   ④$-\lambda$表示：因为分裂导致叶结点数量增大1，从而导致增益的下降。
   每次分裂只一个叶结点，因此其它叶结点不会发生变化。因此：
   ①若$Gain>0$，则该叶结点应该分裂。
   ②若$Gain\le 0$，则该叶结点不宜分裂。
4. 现在的问题是：不知道分裂点。对于每个叶结点，存在很多个分裂点，且可能很多分裂点都能带来增益。
   解决的办法是：对于叶结点中的所有可能的分裂点进行一次扫描。然后计算每个分裂点的增益，选取增益最大的分裂点作为本叶结点的最优分裂点。
5. 最优分裂点贪心算法：
   （1）输入：
   ①数据集 D = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } D=\{ (x_1,y_1),(x_2,y_2),...,(x_N,y_N) \} D={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}，其中样本$x_i=(x_{i,1},x_{i,2},...,x_{i,n}{)}^T$.
   ②属于当前叶结点的样本集的下标集合$Ⅱ$
   （2）输出：当前叶结点最佳分裂点。
   （3）算法：
   ①初始化：$score\leftarrow 0,G\leftarrow {\sum }_{i\in Ⅱ}{g}_i,H\leftarrow {\sum }_{i\in Ⅱ}{h}_i$。
   ②遍历各维度：$k=1,2,...,n$
   (a)初始化:$G_L\leftarrow 0,H_L\leftarrow 0$。
   (b)遍历各拆分点：沿着第 $k$维：
   如果第$k$维特征为连续值，则将当前叶结点中的样本从小到大排序。然后用$j$顺序遍历排序后的样本下标：$$G_L\leftarrow G_L+g_j,H_L\leftarrow H_L+h_j$$ $$G_R\leftarrow G-G_L,H_R\leftarrow H-H_L$$ $$score\leftarrow max(score,\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }-\frac{G^2}{H+\lambda })$$
   如果第$k$维特征为离散值 { a 1 , a 2 , . . . , a m k } \{ a_1,a_2,...,a_{m_k} \} {a1​,a2​,...,amk​​}，设当前叶结点中第$k$维取值$a_j$样本的下标集和为${Ⅱ}_j$，则遍历$j=1,2,...,m_k$： $$G_L\leftarrow \sum _{i\in {Ⅱ}_j}{g}_i,H_L\leftarrow \sum _{i\in {Ⅱ}_j}{h}_i$$ $$G_R\leftarrow G-G_L,H_R\leftarrow H-H_L$$ $$score\leftarrow max(score,\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }-\frac{G^2}{H+\lambda })$$
   ③选取最大的$score$对应的维度和拆分点作为最优拆分点。
6. 分裂点贪心算法尝试所有特征和所有分裂位置，从而求得最优分裂点。
   当样本太大且特征为连续值时，这种暴力做法的计算量太大。

6.3.2.2 近似算法

1. 近似算法寻找最优分裂点时不会枚举所有的特征值，而是对特征值进行聚合统计，然后形成若干个桶。
   然后仅仅将桶边界上的特征的值作为分裂点的候选，从而获取计算性能的提升。
2. 假设数据集 D = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } D = \{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} D={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}，样本$x_i=(x_{i,1},x_{i,2},...,x_{i,n}{)}^T$.
   对第$k$个特征进行分桶：
   （1）如果第$k$个特征为连续特征，则执行百分位分桶，得到分桶的区间为： S k = { s k , 1 , s k , 2 , . . . , s k , l } S_k =\{s_{k,1},s_{k,2},...,s_{k,l}\} Sk​={sk,1​,sk,2​,...,sk,l​}，其中 $s_{k,1}<s_{k,2}<...<s_{k,l}$
   分桶的数量、分桶的区间都是超参数，需要仔细挑选。
   （2）如果第$k$个特征为离散特征，则执行按离散值分桶，得到的分桶为： S k = { s k , 1 , s k , 2 , . . . , s k , l } S_k =\{s_{k,1},s_{k,2},...,s_{k,l}\} Sk​={sk,1​,sk,2​,...,sk,l​}，其中 $s_{k,1},s_{k,2},...,s_{k,l}$为第$k$个特征的所有可能的离散值。
   分桶的数量$l$就是所有样本在第$k$个特征上的取值的数量。
3. 最优分裂点近似算法：
   （1）输入：
   ①数据集 D = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } D = \{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} D={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}，样本$x_i=(x_{i,1},x_{i,2},...,x_{i,n}{)}^T$。
   ②属于当前叶结点的样本集的下标集合$Ⅱ$。
   （2）输出：当前叶结点最佳分裂点。
   （3）算法：
   ①对每个特征进行分桶。 假设对第$k$个特征上的值进行分桶为： S k = { s k , 1 , s k , 2 , . . . , s k , l } S_k =\{s_{k,1},s_{k,2},...,s_{k,l}\} Sk​={sk,1​,sk,2​,...,sk,l​}。
   如果第$k$个特征为连续特征，则要求满足$s_{k,1}<s_{k,2}<...<s_{k,l}$
   ②初始化：$score\leftarrow 0,G\leftarrow {\sum }_{i\in Ⅱ}{g}_i,H\leftarrow {\sum }_{i\in Ⅱ}{h}_i$。
   ③遍历各维度：$k=1,2,...,n$
   (a)初始化：$G_L\leftarrow 0,H_L\leftarrow 0$。
   (b)遍历各拆分点：即遍历 $j=1,2,...,l$
   如果是连续特征，则设叶结点的样本中，第$k$个特征取值在区间$(s_{k,j},s_{k,j+1}]$的样本的下标集合为${Ⅱ}_j$，则：$$G_L\leftarrow G_L+\sum _{i\in {Ⅱ}_j}{g}_i,H_L\leftarrow H_L+\sum _{i\in {Ⅱ}_j}{h}_i$$ $$G_R\leftarrow G-G_L,H_R\leftarrow H-H_L$$ $$score\leftarrow max(score,\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }-\frac{G^2}{H+\lambda })$$
   如果是离散特征，则设叶结点的样本中，第 $k$个特征取值等于$s_{kj}$的样本的下标集合为${Ⅱ}_j$，则：$$G_L\leftarrow \sum _{i\in {Ⅱ}_j}{g}_i,H_L\leftarrow \sum _{i\in {Ⅱ}_j}{h}_i$$ $$G_R\leftarrow G-G_L,H_R\leftarrow H-H_L$$ $$score\leftarrow max(score,\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }-\frac{G^2}{H+\lambda })$$
   ③选取最大的$score$对应的维度和拆分点作为最优拆分点。
4. 分桶有两种模式：
   全局模式：在算法开始时，对每个维度分桶一次，后续的分裂都依赖于该分桶并不再更新。
   ①优点是：只需要计算一次，不需要重复计算。②缺点是：在经过多次分裂之后，叶结点的样本有可能在很多全局桶中是空的。
   局部模式：除了在算法开始时进行分桶，每次拆分之后再重新分桶。
   ①优点是：每次分桶都能保证各桶中的样本数量都是均匀的。②缺点是：计算量较大。
   全局模式会构造更多的候选拆分点。而局部模式会更适合构建更深的树。
5. 分桶时的桶区间间隔大小是个重要的参数。
   区间间隔越小，则桶越多，则划分的越精细，候选的拆分点就越多。

6.3.3 加权分桶

1. 假设候选样本的第$k$维特征，及候选样本的损失函数的二阶偏导数为： D k = { ( x 1 , k , h 1 ) , ( x 2 , k , h 2 ) , . . . , ( x N , k , h N ) } D_k = \{(x_{1,k},h_1),(x_{2,k},h_2),...,(x_{N,k},h_N)\} Dk​={(x1,k​,h1​),(x2,k​,h2​),...,(xN,k​,hN​)}
   定义排序函数：$$r_k(z)=\frac{{\sum }_{i|(x_{i,k},h_i)\in D_k,x_{i,k}<z}hi}{{\sum }_{i|(x_{i,k},h_i)\in D_k}hi}$$
   它刻画的是：第$k$维小于$z$的样本的$h$之和，占总的$h$之和的比例。
2. xgboost 的作者提出了一种带权重的桶划分算法。定义候选样本的下标集合为$Ⅱ$，拆分点 S k = { s k 1 , s k 2 , . . . , s k l } S_k =\{s_{k1},s_{k2},...,s_{kl}\} Sk​={sk1​,sk2​,...,skl​}定义为：$$s_{k,1}=\underset{i\in Ⅱ}{\min }{x}_{i,k},s_{k,l}=\underset{i\in Ⅱ}{\max }{x}_{i,k},|r_k(s_{k,j})-r_k(s_{k,j+1})|<ϵ$$
   其中$x_{i,k}$表示样本$x_i$的第$k$个特征。即：
   ①最小的拆分点是所有样本第$k$维的最小值。②最大的拆分点是所有样本第$k$维的最大值。③中间的拆分点：选取拆分点，使得相邻拆分点的排序函数值小于$ϵ$（分桶的桶宽），其意义为：第$k$维大于等于$s_{k,j}$，小于$s_{k,j+1}$的样本的$h$之和，占总的$h$之和的比例小于$ϵ$，这种拆分点使得每个桶内的以$h$为权重的样本数量比较均匀，而不是样本个数比较均匀。

6.3.4 缺失值

1. 真实场景中，有很多可能导致产生稀疏。如：数据缺失、某个特征上出现很多 0 项、人工进行 one-hot 编码导致的大量的 0。
   （1）理论上，数据缺失和数值0的含义是不同的，数值 0 是有效的。
   （2）实际上，数值0的处理方式类似缺失值的处理方式，都视为稀疏特征。
   在xgboost 中，数值0的处理方式和缺失值的处理方式是统一的。这只是一个计算上的优化，用于加速对稀疏特征的处理速度。
   （3）对于稀疏特征，只需要对有效值进行处理，无效值则采用默认的分裂方向。
   注意：每个结点的默认分裂方向可能不同。
2. 在xgboost 算法的实现中，允许对数值0进行不同的处理。可以将数值0视作缺失值，也可以将其视作有效值。
   如果数值0是有真实意义的，则建议将其视作有效值。
3. 缺失值处理算法：
   （1）输入：
   ①数据集 D = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } D = \{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} D={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}，样本$x_i=(x_{i,1},x_{i,2},...,x_{i,n}{)}^T$。
   ②属于当前叶结点的样本集的下标集合$Ⅱ$。
   ③属于当前叶结点，且第$k$维特征有效的样本的下标集合 Ⅱ k = { i ∈ Ⅱ ∣ x k , i ≠ m i s s i n g } Ⅱ_k=\{ i \in Ⅱ | x_{k,i} \neq missing\} Ⅱk​={i∈Ⅱ∣xk,i​​=missing}
   （2）输出：当前叶结点最佳分裂点。
   （3）算法：
   ①初始化：$score\leftarrow 0,G\leftarrow {\sum }_{i\in Ⅱ}{g}_i,H\leftarrow {\sum }_{i\in Ⅱ}{h}_i$。
   ②遍历各维度：$k=1,2,...,n$
   1)先从左边开始遍历：
   (a)初始化：$G_L\leftarrow 0,H_L\leftarrow 0$。
   (b)遍历各拆分点：沿着第$k$维，将当前有效的叶结点的样本从小到大排序。
   这相当于所有无效特征值的样本放在最右侧，因此可以保证无效的特征值都在右子树。
   然后用$j$顺序遍历排序后的样本下标：
   $$G_L\leftarrow G_L+g_j,H_L\leftarrow H_L+h_j$$ $$G_R\leftarrow G-G_L,H_R\leftarrow H-H_L$$ $$score\leftarrow max(score,\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }-\frac{G^2}{H+\lambda })$$
   2)再从右边开始遍历：
   (a)初始化：$G_R\leftarrow 0,H_R\leftarrow 0$。
   (b)遍历各拆分点：沿着第$k$维，将当前叶结点的样本从大到小排序。
   这相当于所有无效特征值的样本放在最左侧，因此可以保证无效的特征值都在左子树。
   然后用$j$逆序遍历排序后的样本下标：
   $$G_R\leftarrow G_R+g_j,H_R\leftarrow H_R+h_j$$ $$G_L\leftarrow G-G_R,H_L\leftarrow H-H_R$$ $$score\leftarrow max(score,\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }-\frac{G^2}{H+\lambda })$$
   ③选取最大的$score$对应的维度和拆分点作为最优拆分点。
4. 缺失值处理算法中，通过两轮遍历可以确保稀疏值位于左子树和右子树的情形。

6.3.5 其他优化

6.3.5.1 正则化

1. xgboost 在学习过程中使用了如下的正则化策略来缓解过拟合：
   通过学习率$v$来更新模型：$f_m(x)=f_{m-1}(x)+v{h}_m(x;{\Theta }_m),0<v<1$
   类似于随机森林，采取随机属性选择。

6.3.5.2 计算速度提升

1. xgboost 在以下方面提出改进来提升计算速度：
   预排序pre-sorted ；cache-aware 预取；Out-of-Core 大数据集
   （1）预排序
   ①xgboost 提出column block 数据结构来降低排序时间。
   每一个block 代表一个属性，样本在该block 中按照它在该属性的值排好序。
   这些block 只需要在程序开始的时候计算一次，后续排序只需要线性扫描这些block 即可。
   由于属性之间是独立的，因此在每个维度寻找划分点可以并行计算。
   ②block 可以仅存放样本的索引，而不是样本本身，这样节省了大量的存储空间。
   如：block_1 代表所有样本在feature_1 上的从小到大排序：sample_no1,sample_no2,… 。
   其中样本编号出现的位置代表了该样本的排序。
   （2）预取
   ①由于在column block 中，样本的顺序会被打乱，这会使得从导数数组中获取$g_i$时的缓存命中率较低。因此xgboost 提出了cache-aware 预取算法，用于提升缓存命中率。
   ②xgboost 会以minibatch 的方式累加数据，然后在后台开启一个线程来加载需要用到的导数$g_i$。这里有个折中：minibatch 太大，则会引起cache miss ；太小，则并行程度较低。
   （3）Out-of-Core
   ①xgboost 利用硬盘来处理超过内存容量的大数据集。其中使用了下列技术：
   使用block 压缩技术来缓解内存和硬盘的数据交换IO ： 数据按列压缩，并且在硬盘到内存的传输过程中被自动解压缩。
   数据随机分片到多个硬盘，每个硬盘对应一个预取线程，从而加大"内存-硬盘"交换数据的吞吐量。

6.4 LightGBM

1. 提升树的缺点：在构建子决策树时为了获取分裂点，需要在所有特征上扫描所有的样本，从而获得最大的信息增益。
   当样本的数量很大，或者样本的特征很多时，效率非常低。同时提升树也无法使用类似mini batch 方式进行训练。
2. xgboost 缺点：
   （1）每轮迭代都需要遍历整个数据集多次。
   如果把整个训练集装载进内存，则限制了训练数据的大小。
   如果不把整个训练集装载进内存，则反复读写训练数据会消耗非常大的IO 时间。
   （2）空间消耗大。
   预排序（pre-sorted）需要保存数据的feature 值，还需要保存feature 排序的结果（如排序后的索引，为了后续的快速计算分割点）。因此需要消耗训练数据两倍的内存。
   （3）时间消耗大。
   为了获取分裂点，需要在所有特征上扫描所有的样本，从而获得最大的信息增益，时间消耗大
   （4）对cache 优化不友好，造成cache miss 。
   预排序后，feature 对于梯度的访问是一种随机访问，并且不同feature 访问的顺序不同，无法对cache 进行优化。
   在每一层的树生长时，需要随机访问一个行索引到叶子索引的数组，并且不同feature 访问的顺序也不同。
3. LightGBM 的优点：
   更快的训练效率：在达到同样的准确率的情况下，可以达到比提升树约20倍的训练速度。
   低内存使用。
   更高的准确率。
   支持并行化学习。
   可处理大规模数据。

6.4.1 原理

1. LightGBM 的思想：若减少训练样本的数量，或者减少样本的训练特征数量，则可以大幅度提高训练速度。
2. LightGBM 提出了两个策略：
   Gradient-based One-Side Sampling(GOSS)： 基于梯度的采样。该方法用于减少训练样本的数量。
   Exclusive Feature Bundling(EFB)： 基于互斥特征的特征捆绑。该方法用于减少样本的特征。

参考

1. 李航《统计学习方法》
2. http://www.huaxiaozhuan.com/%E7%BB%9F%E8%AE%A1%E5%AD%A6%E4%B9%A0/chapters/7_GBT.html