十大机器学习算法-XGBoost

简介

XGBoost是陈天奇等人开发的一个开源机器学习项目，高效地实现了GBDT算法并进行了算法和工程上的许多改进，被广泛应用在许多机器学习竞赛中取得不错的成绩。

基本思想

XGboost模型的损失函数包含两部分，模型的经验损失以及正则化项：
$$\begin{array}{l}\mathcal{L}(\varphi )={\sum }_{i}l\left({\hat{y}}_i,y_i\right)+{\sum }_k\Omega \left(f_k\right)\\ \text{ where }\Omega (f)=\gamma T+\frac{1}{2}\lambda \Vert w{\Vert }^2\end{array}$$
其中 $T$ 为基模型CART树的叶子数。如何优化上面的目标函数？我们不能用诸如梯度下降的方法，因为$f$是树，而非数值型的向量。我们采用前向分步算法，即贪心法找局部最优解模型，每一步找一个使得我们的损失函数降低最大的f（贪心法体现在这）
$${\hat{y}}_i^{(t)}=\sum _{j=1}^t{f}_j\left(x_i\right)={\hat{y}}_i^{(t-1)}+f_t\left(x_i\right)$$
对目标函数进行改写，得到第t次迭代的损失函数：
$${\mathcal{L}}^{(t)}=\sum _{i=1}^{n}l\left(y_i,{\hat{y}}_i^{(t-1)}+f_t\left({\mathbf{x}}_i\right)\right)+\Omega \left(f_t\right)$$

二阶泰勒展开

假设损失函数使用的是平方损失，则上式写为：
$$\begin{array}{rl}{\mathcal{L}}^{(t)}& =\sum _{i=1}^N{\left(y_i–\left({\hat{y}}_i^{(t-1)}+f_t({\mathbf{x}}_{\mathbf{i}})\right)\right)}^2+\Omega (f_t)\\ & =\sum _{i=1}^N(\underset{残差}{y_i–{\hat{y}}_i^{(t-1)}}–f_t({\mathbf{x}}_{\mathbf{i}}){)}^2+\Omega (f_t)\end{array}$$
这就是之前我们GBDT中使用平方损失，然后每一轮拟合的残差。

更一般的，我们之前使用“负梯度”。这里利用二阶泰勒展开：
$$f(x+\Delta x)\simeq f(x)+f^{\prime }(x)\Delta x+\frac{1}{2}{f}^{\prime \prime }(x)\Delta x^2$$
我们得到近似的目标函数：
$${\mathcal{L}}^{(t)}\simeq \sum _{i=1}^n\left[l\left(y_i,{\hat{y}}^{(t-1)}\right)+g_i{f}_t\left({\mathbf{x}}_i\right)+\frac{1}{2}{h}_i{f}_t^2\left({\mathbf{x}}_i\right)\right]+\Omega \left(f_t\right)$$
其中如果我们定义损失函数为平方损失，$g_i$和 $h_i$分别为每个数据点在损失函数上的一阶导数和二阶导数，则有：
$$g_i={\partial }_{{\hat{y}}^{(t-1)}}{\left({\hat{y}}^{(t-1)}-y_i\right)}^2=2\left({\hat{y}}^{(t-1)}-y_i\right)h_i={\partial }_{{\hat{y}}^{(t-1)}}^2{\left(y_i-{\hat{y}}^{(t-1)}\right)}^2=2$$
为什么只用到二阶泰勒展开呢？因为在平方损失时，三阶展开已经为0。

此时移除对当前t轮来说是常数项的 $l\left(y_i,{\hat{y}}_i^{(t-1)}\right)$得到：
$${\mathcal{L}}^{(t)}=\sum _{i=1}^N\left(g_i{f}_t\left({\mathbf{x}}_{\mathbf{i}}\right)+\frac{1}{2}{h}_i{f}_t^2\left({\mathbf{x}}_i\right)\right)+\Omega \left(f_t\right)$$
目标函数只依赖每个数据点在误差函数上的一阶导数和二阶导数。

正则项

XGBoost采用衡量树复杂度的方式为:一棵树里面叶子节点的个数T，以及每棵树叶子节点上面输出分数w的平方和(相当于L2正则)：
$$\Omega (f_t)=\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2$$
举例如下：

完整目标函数

进一步，对XGBoost来说，每一个数据点 $x_i$ 最终都会落到一个叶子结点上。对于落在同一个叶子节点上的数据点来说，其输出都是一样的。假设我们共有 $J$ 个叶子结点，每个叶子结点对应的输出为 $w_j$ （$w_j$ 也是我们要求解的最优权重）， $I_j=\{i|q(x_i)=j\}$ 为落在叶子结点 $j$ 的实例集合。则目标函数可以进一步改写（已知 $y_i$和${\hat{y}}_i$ 所以第一项为常数项可忽略）：
$$\begin{array}{rl}{\tilde{\mathcal{L}}}^{(t)}& =\sum _{i=1}^n\left[g_i{f}_t\left({\mathbf{x}}_i\right)+\frac{1}{2}{h}_i{f}_t^2\left({\mathbf{x}}_i\right)\right]+\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2\\ & =\sum _{j=1}^T\left[\left(\sum _{i\in I_j}{g}_i\right)w_j+\frac{1}{2}\left(\sum _{i\in I_j}{h}_i+\lambda \right)w_j^2\right]+\gamma T\\ & =\sum _{j=1}^T\left[G_j{w}_j+\frac{1}{2}\left(H_j+\lambda \right)w_j^2\right]+\gamma T\end{array}$$
其中 $G_j={\sum }_{i\in I_j}{g}_i{H}_j={\sum }_{i\in I_j}{h}_i$

因此，现在要做的是两件事：

1. 确定树的结构, 这样，这一轮的目标函数就确定了下来
2. 求使得当前这一轮(第t轮)的目标函数最小的叶结点分数w。(Obj代表了当我们指定一个树的结构的时候，我们在目标上面最多减少多少，也称为结构分数，structure score）

对于给定的树结构 $q(\mathbf{x})$ 可以计算得到 $w_j$的最优权重为：
$$w_j^{\ast }=–\frac{G_j}{H_j+\lambda }$$
将最优权重带回目标函数，目标函数变为：

$$\begin{array}{rl}{\tilde{\mathcal{L}}}^{(t)}(q)& =\sum _{j=1}^T\left(G_j{w}_j+\frac{1}{2}(H_j+\lambda )w_j^2\right)+\gamma T\\ & =\sum _{j=1}^T\left(-\frac{G_j^2}{H_j+\lambda }+\frac{1}{2}\frac{G_j^2}{H_j+\lambda }\right)+\gamma T\\ & =-\frac{1}{2}\sum _{j=1}^T\left(\frac{G_j^2}{H_j+\lambda }\right)+\gamma T\end{array}\text{\hspace{1em}(2-8)}$$
所表示的目标函数越小越好。

树的结构确定

接下来要解决的就是上面提到的问题，即如何确定树的结构。

暴力枚举所有的树结构，然后选择结构分数最小的。 树的结构太多了，这样枚举一般不可行。

通常采用贪心法，每次尝试分裂一个叶节点，计算分裂后的增益，选增益最大的。这个方法在之前的决策树算法中大量被使用。而增益的计算方式比如ID3的信息增益，C4.5的信息增益率，CART的Gini系数等。那XGBoost呢？

回想式子2-8标红色的部分，衡量了每个叶子节点对总体损失的贡献，我们希望目标函数越小越好，因此红色的部分越大越好。

XGBoost使用下面的公式计算增益：
$$Gain=\frac{1}{2}[\underset{左子树分数}{\frac{G_L^2}{H_L+\lambda }}+\underset{右子树分数}{\frac{G_R^2}{H_R+\lambda }}–\underset{分裂前分数}{\frac{(G_L+G_R{)}^2}{H_L+H_R+\lambda }}]–\underset{新叶节点复杂度}{\gamma }\text{\hspace{1em}(2-9)}$$
式2-9即2-8红色部分的分裂后 – 分裂前的分数。Gain值越大，说明分裂后能使目标函数减少越多，就越好。

该式子可以作为一个打分函数衡量树结构 $q$的质量，也就是说可以作为是否可以进行分裂的判断标准，即分裂之后两边的目标函数之和是否能够小于不分裂的目标函数值：
$${\mathcal{L}}_{split}=\frac{1}{2}\left[\frac{{\left({\sum }_{i\in I_L}{g}_i\right)}^2}{{\sum }_{i\in I_L}{h}_i+\lambda }+\frac{{\left({\sum }_{i\in I_R}{g}_i\right)}^2}{{\sum }_{i\in I_R}{h}_i+\lambda }-\frac{{\left({\sum }_{i\in I}{g}_i\right)}^2}{{\sum }_{i\in I}{h}_i+\lambda }\right]-\gamma$$
其中 $I_L$和$I_R$ 是分裂后属于左右节点的实例集合，$I=I_L\cup I_R$；上式大于0选择分裂。注意分裂不一定会使情况变好，因为有一个引入新叶子的惩罚项 $\gamma$，优化这个目标相当于进行树的剪枝。当引入的分裂带来的增益小于一个阀值的时候，不进行分裂操作。

一个树结构分数计算例子如下图：

分裂算法

Basic Exact Greedy Algorithm

因此，每次分裂，枚举所有可能的分裂方案，就和CART中回归树进行划分一样，要枚举所有特征和特征的取值。该算法称为Exact Greedy Algorithm，如下图所示：遍历所有特征及分割点，选择增益最多的特征和分割点的组合

假设现在枚举的是年龄特征$x_j$。现在要考虑划分点a，因此要计算枚举$x_j<a$ 和 $a\le x_j$的导数和：

可以看出，对于一个特征，对特征取值排完序后，枚举所有的分裂点a，只要从左到右扫描一遍就可以枚举出所有分割的梯度$G_L$和$G_R$，然后用式2-9计算即可。这样假设树的高度为$H$，特征数$d$，则复杂度为 $O(Hdnlogn)$。 其中，排序为$O(nlogn)$，每个特征都要排序所以乘以$d$，每一层都要这样一遍，所以乘以高度H。这个仍可以继续优化（之后再讲）。

树节点划分算法-Approximate Algorithm

精确地枚举所有可能的划分，十分耗时；当数据量大的时候，几乎不可能将数据全部加载进内存；精确划分在分布式中也会有问题。因此文章提出了近似的策略。

简单的说，就是根据特征$k$的分布来确定$l$个候选切分点$S_k=\left\{s_{k1},s_{k2},\cdots s_{kl}\right\}$，然后根据这些候选切分点把相应的样本放入对应的桶中，对每个桶的$G,H$进行累加，最后通过遍历所有的候选分裂点来找到最佳分裂点。方法过程如下图：

给定了候选切分点后，一个例子为：

那么，现在有两个问题：

1. 如何选取候选切分点 $S_k=\{s_{k1},s_{k2},\cdots s_{kl}\}$ 呢？
2. 什么时候进行候选切分点的选取？

分界点选择时机

近似方法分为全局和局部两种。**全局策略(Global)**是在建立第 $k$ 棵树时（初始化阶段）利用样本的梯度对样本进行离散化，每一维的特征都建立buckets。在建树过程中，重复利用这些buckets进行分裂判断。**局部策略(Local)**是在每次进行分裂时，都重新计算每个样本的梯度并重新构建buckets，再进行分裂判断。局部选择的复杂度更高，实验中效果更好。

桶的个数等于 1 / eps， 可以看出:

• 全局切分点的个数够多的时候，和Exact greedy算法性能相当。
• 局部切分点个数不需要那么多，因为每一次分裂都重新进行了选择。

切分点的选取-Weighted Quantile Sketch

quantile是分位数，先回答一下什么是分位数，WIKI百科上是这么说的

quantiles are cut points dividing the range of a probability distribution into contiguous intervals with equal probabilities, or dividing the observations in a sample in the same way.

即把概率分布划分为连续的区间，每个区间的概率相同。

以统计学常见的四分位数为例，就是：

四分位数（Quartile）把所有数值由小到大排列并分成四等份，处于三个分割点位置的数值就是四分位数。

1）第一四分位数(Q1)，又称“较小四分位数”，等于该样本中所有数值由小到大排列后第25%的数字；

2）第二四分位数(Q2)，又称“中位数”，等于该样本中所有数值由小到大排列后第50%的数字；

3）第三四分位数(Q3)，又称“较大四分位数”，等于该样本中所有数值由小到大排列后第75%的数字。

可以看出，简单的分位数就是先把数值进行排序，然后根据你采用的几分位数把数据分为几份即可。

上文近似算法的关键在于怎么选择 $S_k=\left\{s_{k1},s_{k2}\dots s_{kl}\right\}$，即怎么限定近似算法buckets的边界。Quantile Sketch的思想是用k分位点来选取。但是实际中，我们要均分的是loss，而不是样本的数量，而每个样本对loss的贡献可能是不一样的，按样本均分会导致loss分布不均匀，取到的分位点会有偏差。怎么衡量每个样本都loss的贡献呢？

我们定义集合 ${\mathcal{D}}_k=\{\left(x_{1k},h_1\right),\left(x_{2k},h_2\right)\cdots \left(x_{nk},h_n\right)$ 代表每个训练实例的k-th特征值以及二阶梯度。定义rank函数 $r_k:\mathbb{R}\to [0,+\infty )$ 如下：
$$r_k(z)=\frac{1}{{\sum }_{(x,h)\in {\mathcal{D}}_k}h}\sum _{(x,h)\in {\mathcal{D}}_{k,},x<z}h$$
rank函数计算的是对某一个特征上，样本特征值小于 $z$ 的二阶梯度除以所有二阶梯度的总和。式3-2表达了第k个特征小于z的样本比例，和之前的分位数挺相似。

而候选切分点 $S_k=\left\{s_{k1},s_{k2}\dots s_{kl}\right\}$ 要求：
$$\left|r_k\left(s_{k,j}\right)-r_k\left(s_{k,j+1}\right)\right|<ϵ,s_{k1}=\underset{i}{\min }{\mathbf{x}}_{ik},s_{kl}=\underset{i}{\max }{\mathbf{x}}_{ik}$$
直观来看就是让相邻两个候选分裂点相差不超过某个值 $ϵ$ 。因此总共会得到 1$/ϵ$ 个切分点（桶）。我们对这么多个桶进行分支判断，显然比起对n个样本找分裂节点更快捷。$ϵ$ 越大桶数量越少，粒度越粗。

一个例子如下：

要切分为3个，总和为1.8，因此第1个在0.6处，第2个在1.2处。

那么，为什么要用二阶梯度加权？将前面我们泰勒二阶展开后的目标函数2-4进行配方：
$$\begin{array}{rl}& \sum _{i=1}^N\left(g_i{f}_t({\mathbf{x}}_{\mathbf{i}})+\frac{1}{2}{h}_i{f}_t^2({\mathbf{x}}_{\mathbf{i}})\right)+\Omega (f_t)\\ =& \sum _{i=1}^N\frac{1}{2}{h}_i\left(2\frac{g_i}{h_i}{f}_t({\mathbf{x}}_{\mathbf{i}})+f_t^2({\mathbf{x}}_{\mathbf{i}})\right)+\Omega (f_t)\\ =& \sum _{i=1}^N\frac{1}{2}{h}_i\left(\frac{g_i^2}{h_i^2}+2\frac{g_i}{h_i}{f}_t({\mathbf{x}}_{\mathbf{i}})+f_t^2({\mathbf{x}}_{\mathbf{i}})\right)+\Omega (f_t)\\ =& \sum _{i=1}^N\frac{1}{2}{h}_i{\left(f_t({\mathbf{x}}_{\mathbf{i}})–(-\frac{g_i}{h_i})\right)}^2+\Omega (f_t)\end{array}\text{\hspace{1em}(3-3)}$$
推导第三行可以加入$\frac{g_i^2}{h_i^2}$是因为 $g_i$ 和 $h_i$ 是上一轮的损失函数求导，是常量。

从式3-3可以看出，目标函数就像是标签为$-g_i/h_i$，权重为$h_i$的平方损失，因此用$h_i$加权。

一些Trick

Shrinkage和采样

除了正则项以外，还有shrinkage与采样技术来避免过拟合。

Shrinkage

shrinkage（收缩率）就是在每步迭代添加树的过程中，对叶子节点乘以一个缩减权重 $\eta$ ，类似于随机梯度下降中的学习率。该操作的作用是减少每棵树的影响力，留更多的空间给后来的树提升。
$${\hat{y}}_i^t={\hat{y}}_i^{(t-1)}+\eta f_t(x_i)\text{\hspace{1em}(3-1)}$$
通常步长 $\eta$ 取值为0.1。

采样

采样的技术有两种，一种是行采样（样本采样），是bagging的思想，每次只抽取部分样本进行训练，不使用全部样本。行采样增加了不同样本集合的差异性，从而不同基学习器之间的差异性也增大，避免过拟合。另一种是列采样（特征采样），相当于做随机特征筛选，进入模型的特征个数越少(即模型变量越少)，模型越简单，根据机器学习理论（方差偏差理论），模型越简单，模型泛化性越好。

列采样的实现方式有两种，一种是按层随机（一般效果好一点），另一种是建树前就随机选择特征。按层随机：上文提到每次分裂一个节点时，我们都要遍历所有的特征和分割点，从而确定最优分割点。如果加入列采样，在对同一层的每个节点分裂之前，先随机选择一部分特征，于是只需要遍历这部分特征，来确定最优的分割点。建树前随机选择特征：在建树前就随机选择一部分特征，之后所有叶子结点的分裂都使用这部分特征。

稀疏值处理 – Sparsity-aware Split Finding

在真实世界中，我们的特征往往是稀疏的，可能的原因有：

1. 数据缺失值
2. 大量的0值（比如统计出现的）
3. 进行了One-hot 编码

XGBoost能对缺失值自动进行处理，其思想是对于缺失值自动学习出它该被划分的方向（左子树or右子树）:

注意，上述的算法只遍历非缺失值。划分的方向怎么学呢？很naive但是很有效的方法：

1. 让特征k的所有缺失值的都到右子树，然后和之前的一样，枚举划分点，计算最大的gain
2. 让特征k的所有缺失值的都到左子树，然后和之前的一样，枚举划分点，计算最大的gain

这样最后求出最大增益的同时，也知道了缺失值的样本应该往左边还是往右边。使用了该方法，相当于比传统方法多遍历了一次，但是它只在非缺失值的样本上进行迭代，因此其复杂度与非缺失值的样本成线性关系。在Allstate-10k数据集上，比传统方法快了50倍:

分块并行 – Column Block for Parallel Learning

在建树的过程中，最耗时是找最优的切分点，而这个过程中，最耗时的部分是将数据排序。为了减少排序的时间，提出Block结构存储数据。

• Block中的数据以稀疏格式CSC进行存储

• Block中的特征进行排序（不对缺失值排序）

• Block 中特征还需存储指向样本的索引，这样才能根据特征的值来取梯度。

• 一个Block中存储一个或多个特征的值

可以看出，只需在建树前排序一次，后面节点分裂时可以直接根据索引得到梯度信息。

• 在Exact greedy算法中，将整个数据集存放在一个Block中。这样，复杂度从原来的$O(Hd||x|{|}_{0}logn)$降为$O(Hd||x|{|}_0+||x|{|}_{0}logn)$，其中$||x|{|}_0$为训练集中非缺失值的个数。这样，Exact greedy算法就省去了每一步中的排序开销。
• 在近似算法中，使用多个Block，每个Block对应原来数据的子集。不同的Block可以在不同的机器上计算。该方法对Local策略尤其有效，因为Local策略每次分支都重新生成候选切分点。

Block结构还有其它好处，数据按列存储，可以同时访问所有的列，很容易实现并行的寻找分裂点算法。此外也可以方便实现之后要讲的out-of score计算。

缺点是空间消耗大了一倍。

总结

XGBoost为什么快

1. 当数据集大的时候使用近似算法

   在特征分裂时，根据特征k的分布确定$l$个候选切分点。根据这些切分点把相应的样本放入对应的桶中，对每个桶的$G,H$进行累加，最后通过遍历所有的候选分裂点来找到最佳分裂点。我们对这么多个桶进行分支判断，显然比起对n个样本找分裂节点更快捷。

2. Block与并行

   1. XGBoost工具支持并行

      当然这个并行是在特征的粒度上，而非tree粒度，因为本质还是boosting算法。我们知道，决策树的学习最耗时的一个步骤是对特征的值进行排序（因为要确定最佳分割点）。xgboost在训练之前，预先对数据进行了排序，然后保存为block结构，后面的迭代中重复地使用这个结构，大大减小计算量。这个block结构也使得并行成为可能。在进行节点分裂时，需要计算每个特征的增益，最终选增益最大的那个特征去做分裂，那么各个特征的增益计算就可以开多线程进行。

3. CPU cache 命中优化

4. Block预取、Block压缩、Block Sharding等

XGBoost与GBDT的异同

1. GBDT是机器学习算法，XGBoost是该算法的工程实现
2. 传统GBDT以CART作为基分类器，XGBoost还支持线性分类器，这个时候XGBoost相当于带L1和L2正则化项的Logistic回归（分类问题）或者线性回归（回归问题）。
3. 传统的GBDT只用了一阶导数信息（使用牛顿法的除外），而XGBoost对损失函数做了二阶泰勒展开。并且XGBoost支持自定义损失函数，只要损失函数一阶、二阶可导。
4. 在使用CART作为基分类器时，XGBoost的目标函数多了正则项控制模型复杂度， 相当于预剪枝，使得学习出来的模型更加不容易过拟合。
5. 传统的GBDT在每轮迭代时使用全部数据，XGBoost则采用了与随机森林相似的策略，支持对数据进行采样（行采样和列采样）。
6. 对缺失值的处理。传统的GBDT没有涉及对缺失值进行处理，XGBoost能够自动学习出缺失值的处理策略。
7. XGBoost工具支持并行。当然这个并行是在特征的粒度上，而非tree粒度，因为本质还是boosting算法。我们知道，决策树的学习最耗时的一个步骤是对特征的值进行排序（因为要确定最佳分割点）。xgboost在训练之前，预先对数据进行了排序，然后保存为block结构，后面的迭代中重复地使用这个结构，大大减小计算量。这个block结构也使得并行成为可能。在进行节点分裂时，需要计算每个特征的增益，最终选增益最大的那个特征去做分裂，那么各个特征的增益计算就可以开多线程进行。
8. 可并行的近似直方图计算。

XGBoost Scalable的体现

XGBoost的paper在KKD上发表，名为：《Xgboost: A scalable tree boosting system》，那么scalable体现在哪?

参考知乎上王浩的回答，修改如下：

• 模型的scalability：弱分类器可以支持cart也可以支持lr和linear， 但其实这是Boosting算法做的事情，XGBoost只是实现了而已。
• 目标函数的scalability： 支持不同的loss function, 支持自定义loss function，只要一、二阶可导。有这个特性是因为泰勒二阶展开，得到通用的目标函数形式。
• 学习方法的scalability：Block结构支持并行化，支持 Out-of-core计算（这点和王浩的看法不一样，他写的是优化的trick）

XGBoost 防止过拟合的方法

• 目标函数的正则项， 叶子节点数+叶子节点数输出分数的平方和。相当于预剪枝。
  $$\Omega (f_t)=\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2$$

• 行抽样和列抽样：训练的时候只用一部分样本和一部分特征

• 可以设置树的最大深度

• $\eta$: 可以叫学习率、步长或者shrinkage

• Early stopping：使用的模型不一定是最终的ensemble，可以根据测试集的测试情况，选择使用前若干棵树

XGBoost的缺点

1. 空间开销大。需要保存数据的特征值。XGBoost采用Block结构，存储指向样本的索引，需要消耗两倍的内存。
2. 时间开销大（相对于lightGBM而言）。在寻找最优切分点时，要对每个特征都进行排序，还要对每个特征的每个值都进行了遍历，并计算增益。
3. 对Cache不友好（相对于lightGBM而言）。使用Block块预排序后，特征对梯度的访问是按照索引来获取的，是一种随机访问，而不同特征访问顺序也不一样，容易照成命中率低的问题。同时，在每一层长树的时候，需要随机访问一个行索引到叶子索引的数组，并且不同特征访问的顺序也不一样，也会造成较大的Cachemiss。

参考资料

『我爱机器学习』集成学习（三）XGBoost