常用集成学习算法

1. 概念

集成算法是对几种机器学习的学习器进行组合，形成一个方差更小、偏差更小、或预测效果更好的模型。主要有bagging、boosting、stacking三种方法。

2. Bagging

图源：机器学习算法之Boosting

【步骤】

1. Bootstrap: 从原始样本集中采用有放回抽样的方式抽取n个训练样本，共进行n轮抽取，得到k个相互独立的训练集
2. 对每个训练集进行训练，得到k个模型，可以是相同也可以是不相同的训练方法
3. 对分类问题：预测结果为k个分类器投票方式得到的分类结果；
   对回归问题，将分类器的均值作为预测结果

【应用】随机森林

【说明】

1. 对于有m个样本的训练集，在Bagging中任何一个样本每次被选中的概率为1/m， 不被抽到的概率为$1-\frac{1}{m}$，如果m次都没有被抽到的概率为$（1-\frac{1}{m}{)}^m$ ，当$m\to \infty$时， 该式极限为$\frac{1}{e}$ ≈ 36.8%。也就是说，每轮采样大约有36.8%的数据没有被采样采中,实际上是一种欠采样的抽样方式。
2. 需要放回抽样的原因：有放回抽样才能保证不破坏数据的分布

3. Boosting

图源：机器学习算法之Boosting

Boosting的主要思想是将弱分类器经过对迭代，按照不同的权重组合成为一个强分类器，这些基本分类器之间有依赖关系。主要有包括Adaboost算法、提升树、GBDT算法。

3.1 AdaBoost(Adaptive Boosting 算法)

AdaBoost 算法在训练初始对所有样本赋予相同权重，训练时，会对上一轮分类器的样本进行权值调整，对于预测正确的样本权值降低，而对于预测错误的样本进行权值增加。

【AdaBoost 实例】通俗易懂理解——Adaboost算法原理

3.1.1算法流程

图源：AdaBoost基本原理与算法描述

用于解决回归问题的流程参考： 梯度提升树(GBDT)原理小结

3.1.2 AdaBoost 误差分析

1. AdaBoost 的训练误差界：
   $$\frac{1}{N}\sum _{i=1}^{N}I(G(x_i)\ne y_i)\le \frac{1}{N}\sum _{i}exp(-y_{i}f(x_i))=\prod Z_m$$

证明：
（1）第一步：证明第一个不等式

当 $G(x_i)=y_i$时, $y_{i}f(x_i)>0$,
$左边I(G(x_i)\ne y_i)=0$，右边$exp(-y_{i}f(x_i))>0$

当 $G(x_i)\ne y_i$ 时,$y_{i}f(x_i)<0$,
$左边I(G(x_i)\ne y_i)=1$，右边$exp(-y_{i}f(x_i))\ge 1$

第一个不等式成立。

（2）第二步：证明第二个等式
首先，回忆对于$w_{m+1,i}=\frac{w_{mi}}{Z_m}exp(-{\alpha }_m{y}_i{G}_m(x_i))$，
$Z_m={\sum }_{i=1}^N{w}_{mi}exp(-{\alpha }_m{y}_i{G}_m(x_i))$

对第一个式子变形得到：
$w_{m+1,i}{Z}_m=w_{mi}exp(-{\alpha }_m{y}_i{G}_m(x_i))$

现推导如下：

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

2. 二分类问题AadaBoost的训练误差界
   $$\prod _{m=1}^M{Z}_m=\prod _{m=1}^M\sqrt{1-4{\gamma }_m^2}\le exp(-2\sum _{m=1}^M{\gamma }_m^2)$$
   其中，${\gamma }_m=\frac{1}{2}-e_m$

证明：
这里需要利用${\alpha }_m=\frac{1}{2}ln\frac{1-e_m}{e_m}$

$$\begin{gathered} Z_m=\sum _{i=1}^N{w}_{mi}exp(-{\alpha }_m{y}_i{G}_m(x_i)) \\ =\sum _{True}{w}_{mi}{e}^{-{\alpha }_m}+\sum _{False}{w}_{mi}{e}^{{\alpha }_m} \\ =(1-e_m)e^{-{\alpha }_m}+e_m{e}^{{\alpha }_m} \\ =\sqrt{e_m(1-e_m)}=\sqrt{1-4{\gamma }_m^2} \end{gathered}$$

再利用$e^x$和$\sqrt{1-x}$在x = 0处泰勒展开可以得到：
${\prod }_{m=1}^M\sqrt{1-4{\gamma }_m^2}\le exp(-2{\sum }_{m=1}^M{\gamma }_m^2)$

3. 推论：如果存在$\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)$$
这表明，在此条件下，AdaBoost的训练误差是以指数下降的

3.1.3 AdaBoost 总结

【优点】：

• 很好的利用了弱分类器进行级联。
• 可以将不同的分类算法作为弱分类器。
• AdaBoost具有很高的精度。
• 相对于bagging算法和Random Forest算法，AdaBoost充分考虑的每个分类器的权重。

缺点：

• AdaBoost迭代次数也就是弱分类器数目不太好设定，可以使用交叉验证来进行确定。
• 数据不平衡导致分类精度下降。
• 训练比较耗时，每次重新选择当前分类器最好切分点。

3.2 GBDT(Gradient Boost Decision Tree)

GBDT称为梯度提升决策树，主要思想为通过每轮产生一颗CART树，对上一轮的CART树的残差进行学习，最终通过对弱分类器进行加权求和,得到最终的分类器。
【例子】一个简单易懂的例子
采用传统的决策树

GBDT

最终的预测值为各个子树预测结果的和。

图源：GBDT（MART） 迭代决策树入门教程 | 简介

3.2.1 提升树算法

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 对每一个样本$(x_i,r_{mi})$拟合一棵cart回归树,得到$T(x;\Theta )$
   2.3 对叶子区域更计算最佳拟合值
   2.4 更新$f_m(x)=f_{m-1}(x)+T(x;\Theta )$
3. 得到回归问题提升树：
   $f_M(x)={\sum }_{m=1}^{M}T(x;{\Theta }_m)$

3.2.2 梯度提升决策树算法

学习残差回归树时，当损失函数是平方损失和指数损失时，每一步优化较为简单；但当对一般损失函数而言（见下表），往往每步优化都并不那么容易，因此出现了梯度提升算法，利用损失函数的负梯度在当前模型的值作为回归问题提升树算法中残差的近似值(残差是负梯度的特殊情况)。

损失函数列表

【算法流程】



对于处理分类问题和正则化可以参考：梯度提升树(GBDT)原理小结

【GBDT和AdaBoost区别】

• GBDT弱分类器为回归树
• GBDT不涉及样本权重的更新
• Loss一般采用均方差或自定义损失函数

3.3 XGBoost (Extreme Gradient Boosting)

Xgboost是GBDT的一种，是一种Boosting算法。GBDT和XGBoost最大的差异是目标函数的定义。XGBoost的目标函数增加了正则化项，并采用二阶泰勒展开，使用牛顿法求解等。

【例子】

【模型形式】
对于一个给定的有n个样本和m个特征的数据集$D=(x)(|D|=n,x_i\in R^m,y_i\in R)$
$$\hat{y}=\sum _{k=1}^K{f}_k（x_i）,f_k\in \mathcal{F}$$
$f_k$是每一轮训练的回归树，实质上，预测值是将该样本每一轮训练的预测结果相加得到

【目标函数】
$$Obj(\Theta )=\sum _{i=1}^{N}L(y_i,\widehat{y_i})+\sum _{j=1}^t\Omega (f_j),f_k\in \mathcal{F}$$

目标函数由两部分构成，第一部分用来衡量预测分数和真实分数的差距，另一部分则是正则化项。

1. 损失函数
   Xgboost其实是通过贪心算法寻找局部最优解，当生成t棵树后，预测分数可以写成：
   $$\widehat{y_i}=\sum _{j=1}^t{f}_j(x_i)={\widehat{y_i}}^{(t-1)}+f_t(x_i)$$
   每一次迭代寻找使损失函数降低最大的CART树$f_t$，因此目标函数可以改写为：
   $$\begin{array}{rl}Obj(\Theta {)}^{(t)}& =\sum _{i=1}^{N}L(y_i,{\widehat{y_i}}^{(t)})+\sum _{j=1}^t\Omega (f_j)\\ & =\sum _{i=1}^{N}L(y_i,{\widehat{y_i}}^{(t-1)}+f_t(x_i))+\Omega (f_t)+constant\end{array}$$
   在t轮时，前t-1次迭代正则项看作常数。
   接下来采用泰勒展开对目标函数进行近似：
   $$\begin{array}{rl}Ob{j}^{(t)}& =\sum _{i=1}^{N}L(y_i,{\widehat{y_i}}^{(t-1)}+f_t(x_i))+\Omega (f_t)+constant\\ & =\sum _{i=1}^N(L(y_i,{\widehat{y_i}}^{(t-1)})+g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i))+\Omega (f_t)+constant\\ 其中,& g_i=\frac{\partial L(y_i,{\widehat{y_i}}^{(t-1)})}{\partial {\widehat{y_i}}^{(t-1)}},h_i=\frac{{\partial }^{2}L(y_i,{\widehat{y_i}}^{(t-1)})}{{\partial }^2{\widehat{y_i}}^{(t-1)}}\end{array}$$
   由于前t-1棵树的预测分数与y的残差对目标函数优化不影响，可以直接去掉。简化目标函数为：：
   $$Ob{j}^{(t)}=\sum _{i=1}^N(g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i))+\Omega (f_t)$$

一元泰勒展开
对于一般的函数，泰勒公式的系数依赖于函数在一点的各阶导数值，函数f(x)在$x_0$处的泰勒展开基本形式如下：
$$\begin{array}{rl}f(x)& =\sum _{n=0}^{\infty }\frac{f^n(x_0)}{n!}(x-x_0{)}^n\\ & =f(x_0)+f^1(x_0)(x-x_0)+\frac{f^2(x_0)}{2}(x-x_0{)}^2+...+\frac{f^n(x_0)}{n!}(x-x_0{)}^n\end{array}$$
或
$$f(x+\Delta x)=f(x)+f^1(x)\Delta x+\frac{f^2(x_0)}{2}\Delta x^2+...$$
二元泰勒展开

二元证明参考：二元函数的泰勒公式

2. 正则项
   树的复杂度可以用树的深度、节点个数等来衡量，XGBoost中的正则项定义为：树的叶子结点个数T和每棵树叶子节点输出分数w的平方和。

从直观上看，正则项要求叶子节点尽可能少，而输出分数尽可能不极端。

3. 最终目标函数
   由损失函数和正则项，可以到到目标函数为：

$$Ob{j}^{(t)}=\sum _{i=1}^N(g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i))+\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2$$
第一部分是样本的累计，第二部分则是对叶节点的累加。

定义q函数，将输入x映射到某个叶子节点上，用叶子节点集合以及叶子节点得分表示原输入，则有：
$$f_t(x)=w_{q(x)},w\in R^T,q:R^d$$
每个样本都落在一个叶子节点上 ，q(x)表示样本x在某个叶子节点上,$w_{q(x)}$是该节点的打分，即该样本的模型预测值

定义每个叶子节点j上的样本集合为$I_j=i|q(x_i)=j$，可以将前面的目标函数做变形：
$$\begin{array}{rl}Ob{j}^{(t)}& =\sum _{i=1}^N(g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i))+\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2\\ & =\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\\ & =\sum _{j=1}^T(\sum _{i\in I_j}{g}_i{w}_j+\frac{1}{2}{h}_i{w}_j^2)+\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2\\ & =\sum _{j=1}^T(G_j{w}_j+\frac{1}{2}(H_j+\lambda )w_j^2)+\gamma T\\ 其中，& G_j=\sum _{i\in I_j}{g}_i,H_j=\sum _{i\in I_j}{h}_i\end{array}$$

为了对目标函数进行优化，计算第t轮使目标函数函数最小的叶节点输出，即目标函数对w求导，并令其为0，得到：
$$w_j=-\frac{G_j}{H_j+\lambda }$$
带入损失函数后，得到：
$$\begin{array}{rl}Ob{j}^{(t)}& =\sum _{j=1}^T(G_j{w}_j+\frac{1}{2}(H_j+\lambda )w_j^2)+\gamma T\\ & =\sum _{j=1}^T(-\frac{G_j^2}{H_j+\lambda }+\frac{1}{2}\frac{G_j^2}{H_j+\lambda })+\gamma T\\ & =-\frac{1}{2}\sum _{j=1}^T\frac{G_j^2}{H_j+\lambda }+\gamma T\end{array}$$

【学习策略】 分裂结点算法

通过上面对目标函数的分析，我们知道如果需要目标函数越小越好，需要$\frac{G_j^2}{H_j+\lambda }$这部分越大越好，在XGBoost中增益定义为左子树、右子树的分数减去不分裂时的分数，再对叶节点的复杂度进行乘法，关系如下：

1. 精确贪心算法
   根据每个特征值对所有数据进行排序,并按排序顺序访问，计算相应的一阶导和二阶导，遍历每个特征值后选择增益最大的特征值进行分裂，该方法对计算量要求非常高。
   
   精确贪心算法是需要枚举所有的分割条件后，计算阈值左右两边的导数和，但节点划分不一定会带来目标函数的下降，一旦进行分裂，会增大决策树复杂度带来的
   

2. 近似算法
   贪婪算法可以的到最优解，但当数据量太大时对算力要求较高，因此出现了近似算法。该算法根据特征的分位数提出候选切分点，将连续性特征划分到对应的桶中，然后聚合统计信息找到区间的最佳分割点。

   在提出候选切分点时有两种策略：
   a. Global： 学习每棵树前就提出候选切分点，并在每次分裂时都采用这种分裂方式，当切分点足够多时，和精确贪心算法性能相当
   b. Local: 每次分裂前重新候选切分点，切分点数量可以不用太多，性能与精确贪心算法性能相当

   下图给出不同种分裂策略的 AUC 变换曲线，横坐标为迭代次数，纵坐标为测试集 AUC，eps 为近似算法的精度，其倒数为桶的数量，衡量了切分的细致程度。
   
   算法的流程如下，
   

3. 分位数缩略图 (Weighted Quantile Sketch)
   加权分位数算法的思想是按比例选择对样本进行抽取，根据每个样本的对loss的贡献，选取k个样本中最优值。

   直观上理解：
   

   对前面的目标函数函数进行整理，
   
   由于$\frac{1}{2}\frac{g_i^2}{h_i^2}$为常数，与常数项C合并，从上面的推导可以看出，$h_i$就是损失函数中样本的权重。

   接下来构造一个排序函数，计算第k个特征值小于z的样本比例。将样本对应的二阶导h作为划分依据，使得候选节点更容易选取到二阶导更大的地方。对于$D_k=(x_{1k},h_1),...(x_{nk},h_n)$有：
   $$r_k(z)=\frac{1}{{\sum }_{(x,k)\in D_k}h}\sum _{(x,k)\in D_k,x<z}h$$
   
   按照步幅$ϵ$挑选出取值候选点，组成候选点集

【缺失值处理】
处理方式：xgboost能对缺失值自动进行处理，主要思想是对于缺失值自动学习出其划分的方向，流程如下：
a. 将缺失值都放在右子树，枚举划分节点，计算最大增益
b. 将缺失值都放在左子树，枚举划分节点，计算最大增益
c. 最后求出最大增益，确定缺失值的划分

【防止过拟合】

1. 收缩率
2. 列采样

• 按层随机：对同一层内每个节点分裂之前，随机选一部分特征，这时每次分裂时只需要遍历这一部分特征来确定分割点
• 按树随机：在建树结构之前就随机选择特征，之后所有叶子节点都只使用这些特征

手算xgboost:xgboost原理分析以及实践

3.4 LightGBM

和xgbosst一样，Lightgbm也是对gbdt的高效实现，原理上LightGBM和XGBoost类似，都是通过对采用损失函数的负梯度作为残差预测值进行新一轮的拟合，但相比与XGBoost，LightBGM的性能更佳。

LightGBM可以概括为以下式子：
LightGBM = XGBoost + Histogram + GOSS + EFB

Histogram: 直方图算法
GOSS:基于梯度的单边采样算法
EFB：互斥特征捆绑算法

3.4.1 数学原理

【基于leaf - wise的决策树生长策略】
对于大部分决策树使用的是level - wise 生长策略，同一层的叶子节点都一起分裂，但实际上一些叶子节点的分裂增益较低，这种方法分裂会增加不小的开销

LightGBM使用基于leaf - wise的决策树生长策略：每次在当前叶子节点中，找出分裂增益最大的叶子节点进行分裂，而不是所有节点都进行分裂，从而提高精度

【直方图算法】

直方图算法是替代XGBoost预排序算法的，思路如下：

• 先把连续的浮点特征离散化成k个整数，对特征值进行分箱处理（bins）
• 根据bins对其进行梯度累加和个数统计
• 遍历所有bins, 以当前bin为分割点，累加其左边bins至当前bin的梯度和（SL）以及样本数量（nL）
• 父结点上的梯度总和和样本总量与上一步得到的梯度与样本量分别相减得到右边所有bins梯度和(SR)和样本量(nR) -> Histogram（直方图）做差加速
• 计算loss，计算遍历过程中的最大增益，并将此时的特征和特征值作为分裂的特征和分裂特征值

【GOSS(Gradient-based One-Side Sampling)】

GOSS的思路是在保留大梯度样本的同时，随机地保留一些小梯度样本，同时放大了小梯度样本带来的信息增益。

流程如下：

算法描述：

• 根据样本点的绝对梯度进行排序
• 对排序后的结果取前a*100%%的样本作为大梯度样本集合
• 对剩下的样本集合(1-a)100%的样本，随机选取 b (1 -a ) *100%样本点作为小梯度样本集合
• 将大梯度样本和小梯度样本合并，小样本的权重系数为$\frac{1-a}{b}$
• 使用上述样本，学习一个新的弱学习器
• 重复上述步骤直到规定的迭代

GOSS保留所有的梯度较大的实例，在梯度小的实例上使用随机采样。为了抵消对数据分布的影响，计算信息增益的时候，GOSS对小梯度的数据引入常量乘数。GOSS首先根据数据的梯度绝对值排序，选取top a个实例。然后在剩余的数据中随机采样b个实例。接着计算信息增益时为采样出的小梯度数据乘以(1-a)/b，这样算法就会更关注训练不足的实例，而不会过多改变原数据集的分布。

GOSS不会丢失许多训练精度，胜过随机采样,证明参考：机器学习算法之LightGBM(GOSS部分)

【EFB(Exclusive Feature Bundling)】
EFB称之为特征捆绑，利用互斥的特征（1个特征值为0，一个特征值不为0）进行捆绑，减少特征维度，实际上是一种降维技术。

如果两个特征不完全互斥，可以用冲突比率来衡量不互斥程度，通过选择冲突比率小的特征进行捆绑实现降维。

EBF步骤1：可绑定特征选择

• 首先构造一个加权无向图，顶点是特征，边是两个特征之间的互斥程度
• 对根据节点的度进行排序，
• 遍历每个特征，将它分配给现有特征包（或新建），使得总体冲突最小

EBF步骤2：绑定后特征值确定

合并应该也要使得原始特征能够分离出来，可以通过添加特征偏移量来实现，如bundle中有两个特征，原始特征A取值[0, 10]，B取值[0, 20]。我们添加偏移量10到B中，因此B取值[10, 30]。通过这种做法，就可以安全地将A、B特征合并，使用一个取值[0, 30]的特征取代AB。

3.4.2 工程实现

【特征并行】

传统的特征并行是对数据进行垂直划分，即在不同的机器上划分数据，再基于通信将结果告诉其他机器划分结果，然后在具有最佳节点的机器上分裂，再由这个节点再广播到其他节点该特征左右节点的索引，其他节点才能进行分裂；

LGM的每个机器上都有全部数据，但是每个worker仅在特征子集上进行最佳切分点的寻找，然后将这个最佳切分点的位置进行全局广播，每个worker进行切分即可

很明显, LGB仅需要通信一个特征分裂点，不需要通信索引，但数据量大时仍然存在瓶颈，可以采用数据并行的方式。

【数据并行】

• 不同于传统的数据并行方式（水平划分数据后，构建本地直方图后，将所有本地直方图整合成全局直方图后再寻找最优划分），LGB采用Reduce Scatter分散规约的方式把直方图合并的任务分摊到不同的机器，然后从整合直方图中寻找最佳化分界点并同步至全局最优划分
• LightGBM 通过直方图做差法加速训练。 基于此，我们可以进行单叶子的直方图通讯，并且在相邻直方图上使用做差法

【投票并行】

针对数据量特别大特征也特别多的情况下，可以采用投票并行。

投票并行主要针对数据并行时数据合并的通信代价比较大的瓶颈进行优化，其通过投票的方式只合并部分特征的直方图从而达到降低通信量的目的。

主要思路是在每个worker中选出top k个分裂特征，然后将每个worker选出的k个特征进行汇总，并选出全局分裂特征，进行数据分裂

3.4.3 参数调节

调参参考：
Lightgbm基本原理介绍

3.4.4 优缺点分析

【优点】

1. 直方图算法使得计算过程中不需要存储排序结果，并且可以只存储离散化后的值，一般为整型，相比原来存储浮点类型的数值，内存开销大幅减少。
2. 直方图算法不需要对每个特征值进行分裂，并且可以采用直方图加速算法，使得计算代价大幅降低

【缺点】

1. 不能找到很精确的分割点
2. 可能会长出比较深的决策树，产生过拟合

参考：LightGBM 直方图优化算法

4. 总结

【GBDT和随机森林】
xgboost/gbdt 的树浅，而RandomForest树深的原因：

从偏差和方差的角度来说比较好理解。要想精度高，泛化误差必须低，就机器学习算法来说，其泛化误差可以分解为两部分，偏差（bias)和方差(variance)。偏差指的是算法的期望预测与真实预测之间的偏差程度，反应了模型本身的拟合能力；方差度量了同等大小的训练集的变动导致学习性能的变化，刻画了数据扰动所导致的影响。

我们尽可能地让方差和偏差小一点，想一下，决策树的深度就决定了模型的偏差（越深，偏差越小，但是太深，会导致过拟合，也就是方差会大），而随机森林中多棵树的组合就是为了降低方差。这就是为什么随机森林的树深度会很高的原因。而GBDT的每一棵树是拟合的上一棵树的偏差，本身就保证了偏差，所以问题就在于怎么选择使方差更小的分类器，故决策树的深度都很浅。

【XGBoost和LightGBM对比】

内存：

• XGboost使用预排序后需要记录特征值对应样本的统计值的索引，LightGBM 使用了直方图算法将特征值转变为 bin 值，且不需要记录特征到样本的索引,极大的减少了内存消耗
• LightGBM 在训练过程中采用互斥特征捆绑算法减少了特征数量，降低了内存消耗

计算速度：

• LightGBM不需要遍历所有特征节点，仅需遍历所有bins，极大降低了复杂度
• LightGBM在计算过程中采用单边梯度算法过滤掉梯度小的样本，减少了大量计算
• LightGBM采用了Leaf-wise算法，减少很多计算
• LightGBMca爱用特征并行、数据并行等，加速计算

还有很多细节有遗漏，想到再补充…

参考：

1. 李航：《统计学习方法》
2. 机器学习–集成学习（Ensemble Learning）
   有放回采样和无放回采样
3. boosting系列算法
4. GBDT（MART） 迭代决策树入门教程 | 简介
5. 决策树（下）——XGBoost、LightGBM（非常详细）
6. Newton Boosting Tree 算法原理：详解 XGBoost
7. xgb和lgb在特征、数据并行上存在什么差异？
8. Bagging 和 Boosting 算法异同
9. 为什么说bagging是减少variance，而boosting是减少bias
10. LightGBM原文链接