集成学习值Boosting（三）

1. XGBoost

​ XGBoost的全称是eXtreme Gradient Boosting，它是经过优化的分布式梯度提升库，旨在高效、灵活且可移植。XGBoost是大规模并行boosting tree的工具，它是目前最快最好的开源 boosting tree工具包，比常见的工具包快10倍以上。在数据科学方面，有大量的Kaggle选手选用XGBoost进行数据挖掘比赛，是各大数据科学比赛的必杀武器；在工业界大规模数据方面，XGBoost的分布式版本有广泛的可移植性，支持在Kubernetes、Hadoop、SGE、MPI、 Dask等各个分布式环境上运行，使得它可以很好地解决工业界大规模数据的问题。

1.1 XGBoost原理推导

我们的数据为： D = { ( x i , y i ) } ( ∣ D ∣ = n , x i ∈ R m , y i ∈ R ) \mathcal{D}=\left\{\left(\mathbf{x}_{i}, y_{i}\right)\right\}\left(|\mathcal{D}|=n, \mathbf{x}_{i} \in \mathbb{R}^{m}, y_{i} \in \mathbb{R}\right) D={(xi​,yi​)}(∣D∣=n,xi​∈Rm,yi​∈R)

1.1.1 构造目标函数

XGBoost是由$k$基模型组成的一个加法模型，假设我们第$t$次迭代要训练的树模型是 $f_t(x)$，则有：

损失函数可由预测值 ${\hat{y}}_i$ 与真实值 $y_i$ 进行表示:
$$\mathcal{L}=\sum _{i=1}^{n}l\left(y_i,{\hat{y}}_i\right)$$
其中, $n$ 为样本的数量
我们知道模型的预测精度由模型的偏差和方差共同决定, 损失函数代表了模型的偏差, 想要方差小则需要在目标函数中添加正则项, 用于防止过拟合。所以目标函数由模型的损失函数 $L$ 与抑制模型复杂度的正则项 $\Omega$ 組成, 目标函数的定义如下:
$$\mathcal{L}=\sum _{i=1}^{n}l\left(y_i,{\hat{y}}_i\right)+\sum _{i=1}^t\Omega \left(f_i\right)$$
其中, ${\sum }_{i=1}^t\Omega \left(f_i\right)$ 是将全部 $t$ 棵树的复杂度进行求和, 添加到目标函数中作为正则化项, 用于 防止模型过度拟合。

1.1.2 叠加式的训练(Additive Training)：

给定样本$x_i$，${\hat{y}}_i^{(0)}=0$(初始预测)，${\hat{y}}_i^{(1)}={\hat{y}}_i^{(0)}+f_1(x_i)$，${\hat{y}}_i^{(2)}={\hat{y}}_i^{(0)}+f_1(x_i)+f_2(x_i)={\hat{y}}_i^{(1)}+f_2(x_i)$…以此类推，可以得到：$ \hat{y}_i^{(K)} = \hat{y}_i^{(K-1)} + f_K(x_i)$ ，其中，$ \hat{y}_i^{(K-1)} $ 为前K-1棵树的预测结果，$ f_K(x_i)$ 为第K棵树的预测结果。 因此，目标函数可以分解为：
$${\mathcal{L}}^{(K)}=\sum _{i=1}^{n}l\left(y_i,{\hat{y}}_i^{(K-1)}+f_K\left({\mathrm{x}}_i\right)\right)+\sum _k\Omega \left(f_k\right)$$
由于正则化项也可以分解为前K-1棵树的复杂度加第K棵树的复杂度，因此：
$${\mathcal{L}}^{(K)}=\sum _{i=1}^{n}l\left(y_i,{\hat{y}}_i^{(K-1)}+f_K\left({\mathrm{x}}_i\right)\right)+\sum _{k=1}^{K-1}\Omega \left(f_k\right)+\Omega \left(f_K\right)，$$

由于${\sum }_{k=1}^{K-1}\Omega \left(f_k\right)$在模型构建到第K棵树的时候已经固定，无法改变，因此是一个已知的常数，可以在最优化的时候省去，故：
$${\mathcal{L}}^{(K)}=\sum _{i=1}^{n}l\left(y_i,{\hat{y}}_i^{(K-1)}+f_K\left({\mathrm{x}}_i\right)\right)+\Omega \left(f_K\right)$$

1.1.3 使用泰勒级数近似目标函数

泰勒公式是将一个在 $x=x_0$ 处具有 $n$ 阶导数的函数 $f(x)$ 利用关于 $\left(x-x_0\right)$ 的 $n$ 次多项式来 逼近函数的方法。若函数 $f(x)$ 在包含 $x_0$ 的某个闭区间 $[a,b]$ 上具有 $n$ 阶导数，且在开区间 $(a,b)$ 上具有 $n+1$ 阶导数, 则对闭区间 $[a,b]$ 上任意一点 $x$ 有:
$$\begin{array}{rl}f(x)& =\sum _{i=0}^n\frac{f^{(i)}\left(x_0\right)}{i!}{\left(x-x_0\right)}^i+R_n(x)\\ & =\frac{f\left(x_0\right)}{0!}+\frac{f^{\prime }\left(x_0\right)}{1!}\left(x-x_0\right)+\frac{f^{\prime \prime }\left(x_0\right)}{2!}{\left(x-x_0\right)}^2+\dots +\frac{f^{(n)}\left(x_0\right)}{n!}{\left(x-x_0\right)}^n+R_n(x)\end{array}$$
其中的多项式称为函数在 $x_0$ 处的泰勒展开式, $R_n(x)$ 是泰勒公式的余项且是 ${\left(x-x_0\right)}^n$ 的高 阶无穷小。
根据泰勒公式, 把函数 $f(x+\Delta x)$ 在点 $x$ 处进行泰勒的二阶展开，可得如下等式:
$$f(x+\Delta x)\approx f(x)+f^{\prime }(x)\Delta x+\frac{1}{2}{f}^{\prime \prime }(x)\Delta x^2$$
回到XGBoost的目标函数上来, $f(x)$ 对应损失函数 $l\left(y_i,{\hat{y}}_i^{(t-1)}+f_t\left(x_i\right)\right),x$ 对应前 $t-1$ 棵树的预测值 ${\hat{y}}_i^{(t-1)},\Delta x$ 对应于我们正在训练的第 $t$ 棵树 $f_t\left(x_i\right)$, 则可以将损失函数写为:
$$\mathcal{L}\left(y_i,{\hat{y}}_i^{(t-1)}+f_t\left(x_i\right)\right)=l\left(y_i,{\hat{y}}_i^{(t-1)}\right)+g_i{f}_t\left(x_i\right)+\frac{1}{2}{h}_i{f}_t^2\left(x_i\right)$$
其中, $g_i$ 为损失函数的一阶导, $h_i$ 为损失函数的二阶导，注意这里的求导是对 ${\hat{y}}_i^{(t-1)}$ 求导
我们以平方损失函数为例:
$$\mathcal{L}\left(y_i,{\hat{y}}_i^{(t-1)}\right)={\left(y_i-{\hat{y}}_i^{(t-1)}\right)}^2$$
则:
$$\begin{array}{l}{g}_i=\frac{\partial l\left(y_i,{\hat{y}}_i^{(t-1)}\right)}{\partial {\hat{y}}_i^{(t-1)}}=-2\left(y_i-{\hat{y}}_i^{(t-1)}\right)\\ h_i=\frac{{\partial }^{2}l\left(y_i,{\hat{y}}_i^{(t-1)}\right)}{\partial {\left({\hat{y}}_i^{(t-1)}\right)}^2}=2\end{array}$$
将上述的二阶展开式, 带入到XGBoost的目标函数中，可以得到目标函数的近似值:
$${\mathcal{L}}^{(t)}\simeq \sum _{i=1}^n\left[l\left(y_i,{\hat{y}}_i^{t-1}\right)+g_i{f}_t\left(x_i\right)+\frac{1}{2}{h}_i{f}_t^2\left(x_i\right)\right]+\Omega \left(f_t\right)$$
由于在第 $t$ 步时 ${\hat{y}}_i^{(t-1)}$ 其实是一个已知的值, 所以 $l\left(y_i,{\hat{y}}_i^{(t-1)}\right)$ 是一个常数, 其对函数的优化 不会产生影响。因此，去掉全部的常数项, 得到目标函数为:
$${\tilde{\mathcal{L}}}^{(t)}=\sum _{i=1}^n\left[g_i{f}_{\hat{t}}\left(x_i\right)+\frac{1}{2}{h}_i{f}_t^2\left(x_i\right)\right]+\Omega \left(f_t\right)$$
所以我们只需要求出每一步损失函数的一阶导和二阶导的值 (由于前一步的 ${\hat{y}}^{(t-1)}$ 是已知的, 所 以这两个值就是常数 ) , 然后最优化目标函数，就可以得到每一步的 $f(x)$, 最后根据加法模型得到一个整体模型。

1.1.4 如何定义一个树

​ 为了说明如何定义一棵树的问题，我们需要定义几个概念：第一个概念是样本所在的节点位置$q(x)$，第二个概念是有哪些样本落在节点j上 I j = { i ∣ q ( x i ) = j } I_{j}=\left\{i \mid q\left(\mathbf{x}_{i}\right)=j\right\} Ij​={i∣q(xi​)=j}，第三个概念是每个结点的预测值$w_{q(x)}$，第四个概念是模型复杂度$\Omega \left(f_K\right)$，决策树的复杂度可由叶子数$T$组成，叶子节点越少模型越简单，此外叶子节点也不应该含有过高的权重 $w$（类比 LR 的每个变量的权重）则：$\Omega \left(f_K\right)=\gamma T+\frac{1}{2}\lambda {\sum }_{j=1}^T{w}_j^2$。即决策树模型的复杂度由生成的所有决策树的叶子节点数量，和所有节点权重所组成的向量的 $L_2$ 范式共同决定。

我们将属于第 $j$ 个叶子结点的所有样本 $x_i$ 划入到一个叶子结点的样本集合中，数学表示为 :
I j = { i ∣ q ( x i ) = j } I_{j}=\left\{i \mid q\left(x_{i}\right)=j\right\} Ij​={i∣q(xi​)=j}, 那么XGBoost的目标函数可以写成:
$$\begin{array}{rl}{\tilde{\mathcal{L}}}^{(t)}& =\sum _{i=1}^n\left[g_i{f}_t\left(x_i\right)+\frac{1}{2}{h}_i{f}_t^2\left(x_i\right)\right]+\Omega \left(f_t\right)\\ & =\sum _{i=1}^n\left[g_i{w}_{q\left(x_i\right)}+\frac{1}{2}{h}_i{w}_{q\left(x_i\right)}^2\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\end{array}$$
解释：第二行是遍历所有的样本后求每个样本的损失函数，但样本最终会落在叶子节点上，所以我们也可以遍历叶子节点, 然后获取叶子节点上的样本集合，最后再求损失函数。即我们之前是单个样本，现在都改写成叶子结点的集合, 由于一个叶子结点有多个样本存在, 因此才有了 ${\sum }_{i\in I_j}{g}_i$ 和 ${\sum }_{i\in I_j}{h}_i$ 这两项, $w_j$ 为第 $j$ 个叶 子节点取值。

由于我们的目标就是最小化目标函数，现在的目标函数化简为一个关于w的二次函数：
$${\tilde{\mathcal{L}}}^{(K)}=\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$$
根据二次函数求极值的公式：$y=a{x}^2+bx+c$求极值，对称轴在$x=-\frac{b}{2a}$，极值为$y=\frac{4ac-b^2}{4a}$，因此：
$$w_j^{\ast }=-\frac{{\sum }_{i\in I_j}{g}_i}{{\sum }_{i\in I_j}{h}_i+\lambda }$$
以及
$${\tilde{\mathcal{L}}}^{(K)}(q)=-\frac{1}{2}\sum _{j=1}^T\frac{{\left({\sum }_{i\in I_j}{g}_i\right)}^2}{{\sum }_{i\in I_j}{h}_i+\lambda }+\gamma T$$

1.1.5 最优切分点划分算法

（1）精确贪心分裂算法：

​ XGBoost在生成新树的过程中，最基本的操作是节点分裂。节点分裂中最重 要的环节是找到最优特征及最优切分点, 然后将叶子节点按照最优特征和最优切 分点进行分裂。选取最优特征和最优切分点的一种思路如下：首先找到所有的候 选特征及所有的候选切分点, 一一求得其 split Lsplit , 然后选择splitLsplit 最大的特征及 对应切分点作为最优特征和最优切分点。我们称此种方法为精确贪心算法。该算法是一种启发式算法, 因为在节点分裂时只选择当前最优的分裂策略, 而非全局最优的分裂策略。精确贪心算法的计算过程如下所示：

（2）基于直方图的近似算法：
​ 精确贪心算法在选择最优特征和最优切分点时是一种十分有效的方法。它计算了所有特征、所有切分点的收益, 并从中选择了最优的, 从而保证模型能比较好地拟合了训练数据。但是当数据不能完全加载到内存时，精确贪心算法会变得 非常低效，算法在计算过程中需要不断在内存与磁盘之间进行数据交换，这是个非常耗时的过程, 并且在分布式环境中面临同样的问题。为了能够更高效地选 择最优特征及切分点, XGBoost提出一种近似算法来解决该问题。 基于直方图的近似算法的主要思想是：对某一特征寻找最优切分点时，首先对该特征的所有切分点按分位数 (如百分位) 分桶, 得到一个候选切分点集。特征的每一个切分点都可以分到对应的分桶; 然后，对每个桶计算特征统计G和H得到直方图, G为该桶内所有样本一阶特征统计g之和, H为该桶内所有样本二阶特征统计h之和; 最后，选择所有候选特征及候选切分点中对应桶的特征统计收益最大的作为最优特征及最优切分点。基于直方图的近似算法的计算过程如下所示：

1. 对于每个特征 $k=1,2,\cdots ,m,$ 按分位数对特征 $k$ 分桶 $\Theta ,$ 可得候选切分点, S k = { S k 1 , S k 2 , ⋯   , S k l } 1 S_{k}=\left\{S_{k 1}, S_{k 2}, \cdots, S_{k l}\right\}^{1} Sk​={Sk1​,Sk2​,⋯,Skl​}1
2. 对于每个特征 $k=1,2,\cdots ,m,$ 有：
   G k v ← = ∑ j ∈ { j ∣ s k , v ≥ x j k > s k , v − 1    } g j H k v ← = ∑ j ∈ { j ∣ s k , v ≥ x j k > s k , v − 1    } h j \begin{array}{l} \large G_{k v} \leftarrow=\sum_{j \in\left\{j \mid s_{k, v} \geq \mathbf{x}_{j k}>s_{k, v-1\;}\right\}} g_{j} \\ \large H_{k v} \leftarrow=\sum_{j \in\left\{j \mid s_{k, v} \geq \mathbf{x}_{j k}>s_{k, v-1\;}\right\}} h_{j} \end{array} Gkv​←=∑j∈{j∣sk,v​≥xjk​>sk,v−1​}​gj​Hkv​←=∑j∈{j∣sk,v​≥xjk​>sk,v−1​}​hj​​
3. 类似精确贪心算法，依据梯度统计找到最大增益的候选切分点。
   下面用一个例子说明基于直方图的近似算法：
   假设有一个年龄特征，其特征的取值为18、19、21、31、36、37、55、57，我们需要使用近似算法找到年龄这个特征的最佳分裂点：

近似算法实现了两种候选切分点的构建策略：全局策略和本地策略。全局策略是在树构建的初始阶段对每一个特征确定一个候选切分点的集合, 并在该树每一层的节点分裂中均采用此集合计算收益, 整个过程候选切分点集合不改变。本地策略则是在每一次节点分裂时均重新确定候选切分点。全局策略需要更细的分桶才能达到本地策略的精确度, 但全局策略在选取候选切分点集合时比本地策略更简单。在XGBoost系统中, 用户可以根据需求自由选择使用精确贪心算法、近似算法全局策略、近似算法本地策略, 算法均可通过参数进行配置。

1.2 优缺点

1.2.1 优点

• 精度更高： GBDT 只用到一阶泰勒展开，而 XGBoost 对损失函数进行了二阶泰勒展开。XGBoost 引入二阶导一方面是为了增加精度，另一方面也是为了能够自定义损失函数，二阶泰勒展开可以近似大量损失函数；
• 灵活性更强： GBDT 以 CART 作为基分类器，XGBoost 不仅支持 CART 还支持线性分类器，使用线性分类器的 XGBoost 相当于带$L1$ 和$L2$正则化项的逻辑斯蒂回归（分类问题）或者线性回归（回归问题）。此外，XGBoost 工具支持自定义损失函数，只需函数支持一阶和二阶求导；
• 正则化： XGBoost 在目标函数中加入了正则项，用于控制模型的复杂度。正则项里包含了树的叶子节点个数、叶子节点权重的$L2$范式。正则项降低了模型的方差，使学习出来的模型更加简单，有助于防止过拟合，这也是XGBoost优于传统GBDT的一个特性。
• Shrinkage（缩减）： 相当于学习速率。XGBoost 在进行完一次迭代后，会将叶子节点的权重乘上该系数，主要是为了削弱每棵树的影响，让后面有更大的学习空间。传统GBDT的实现也有学习速率；
• 列抽样： XGBoost 借鉴了随机森林的做法，支持列抽样，不仅能降低过拟合，还能减少计算。这也是XGBoost异于传统GBDT的一个特性；
• 缺失值处理： 对于特征的值有缺失的样本，XGBoost 采用的稀疏感知算法可以自动学习出它的分裂方向；
• XGBoost工具支持并行： boosting不是一种串行的结构吗?怎么并行的？注意XGBoost的并行不是tree粒度的并行，XGBoost也是一次迭代完才能进行下一次迭代的$t$（第次迭代的代价函数里包含了前面$t-1$次迭代的预测值）。XGBoost的并行是在特征粒度上的。我们知道，决策树的学习最耗时的一个步骤就是对特征的值进行排序（因为要确定最佳分割点），XGBoost在训练之前，预先对数据进行了排序，然后保存为block结构，后面的迭代中重复地使用这个结构，大大减小计算量。这个block结构也使得并行成为了可能，在进行节点的分裂时，需要计算每个特征的增益，最终选增益最大的那个特征去做分裂，那么各个特征的增益计算就可以开多线程进行。
• 可并行的近似算法： 树节点在进行分裂时，我们需要计算每个特征的每个分割点对应的增益，即用贪心法枚举所有可能的分割点。当数据无法一次载入内存或者在分布式情况下，贪心算法效率就会变得很低，所以XGBoost还提出了一种可并行的近似算法，用于高效地生成候选的分割点。

1.2.2 缺点

• 虽然利用预排序和近似算法可以降低寻找最佳分裂点的计算量，但在节点分裂过程中仍需要遍历数据集；
• 预排序过程的空间复杂度过高，不仅需要存储特征值，还需要存储特征对应样本的梯度统计值的索引，相当于消耗了两倍的内存。

1.3 参数设置

XGBoost的参数分为三种：

1.3.1通用参数

• booster:使用哪个弱学习器训练，默认gbtree，可选gbtree，gblinear 或dart，两种类型的booster，因为tree的性能比线性回归好得多，因此我们很少用线性回归。

• nthread：用于运行XGBoost的并行线程数，默认为最大可用线程数

• verbosity：打印消息的详细程度。有效值为0（静默），1（警告），2（信息），3（调试）。

• Tree Booster的参数：

• eta（learning_rate）：learning_rate，在更新中使用步长收缩以防止过度拟合，默认= 0.3，范围：[0,1]；典型值一般设置为：0.01-0.2

• gamma（min_split_loss）：默认= 0，分裂节点时，损失函数减小值只有大于等于gamma节点才分裂，gamma值越大，算法越保守，越不容易过拟合，但性能就不一定能保证，需要平衡。范围：[0，∞]

• max_depth：默认= 6，一棵树的最大深度。增加此值将使模型更复杂，并且更可能过度拟合。范围：[0，∞]

• min_child_weight：默认值= 1，如果新分裂的节点的样本权重和小于min_child_weight则停止分裂 。这个可以用来减少过拟合，但是也不能太高，会导致欠拟合。范围：[0，∞]

• max_delta_step：默认= 0，允许每个叶子输出的最大增量步长。如果将该值设置为0，则表示没有约束。如果将其设置为正值，则可以帮助使更新步骤更加保守。通常不需要此参数，但是当类极度不平衡时，它可能有助于逻辑回归。将其设置为1-10的值可能有助于控制更新。范围：[0，∞]

• subsample：默认值= 1，构建每棵树对样本的采样率，如果设置成0.5，XGBoost会随机选择一半的样本作为训练集。范围：（0,1]

• sampling_method：默认= uniform，用于对训练实例进行采样的方法。

  • uniform：每个训练实例的选择概率均等。通常将subsample> = 0.5 设置 为良好的效果。
  • gradient_based：每个训练实例的选择概率与规则化的梯度绝对值成正比，具体来说就是𝑔2+𝜆ℎ2⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯√g2+λh2，subsample可以设置为低至0.1，而不会损失模型精度。

• colsample_bytree：默认= 1，列采样率，也就是特征采样率。范围为（0，1]

• lambda（reg_lambda）：默认=1，L2正则化权重项。增加此值将使模型更加保守。

• alpha（reg_alpha）：默认= 0，权重的L1正则化项。增加此值将使模型更加保守。

• tree_method：默认=auto，XGBoost中使用的树构建算法。

  • auto：使用启发式选择最快的方法。
    • 对于小型数据集，exact将使用精确贪婪（）。
    • 对于较大的数据集，approx将选择近似算法（）。它建议尝试hist，gpu_hist，用大量的数据可能更高的性能。（gpu_hist）支持。external memory外部存储器。
  • exact：精确的贪婪算法。枚举所有拆分的候选点。
  • approx：使用分位数和梯度直方图的近似贪婪算法。
  • hist：更快的直方图优化的近似贪婪算法。（LightGBM也是使用直方图算法）
  • gpu_hist：GPU hist算法的实现。

• scale_pos_weight:控制正负权重的平衡，这对于不平衡的类别很有用。Kaggle竞赛一般设置sum(negative instances) / sum(positive instances)，在类别高度不平衡的情况下，将参数设置大于0，可以加快收敛。

• num_parallel_tree：默认=1，每次迭代期间构造的并行树的数量。此选项用于支持增强型随机森林。

• monotone_constraints：可变单调性的约束，在某些情况下，如果有非常强烈的先验信念认为真实的关系具有一定的质量，则可以使用约束条件来提高模型的预测性能。（例如params_constrained[‘monotone_constraints’] = “(1,-1)”，(1,-1)我们告诉XGBoost对第一个预测变量施加增加的约束，对第二个预测变量施加减小的约束。）

1.3.2 Linear Booster的参数

• lambda（reg_lambda）：默认= 0，L2正则化权重项。增加此值将使模型更加保守。归一化为训练示例数。
• alpha（reg_alpha）：默认= 0，权重的L1正则化项。增加此值将使模型更加保守。归一化为训练示例数。
• updater：默认= shotgun。
• shotgun：基于shotgun算法的平行坐标下降算法。使用“ hogwild”并行性，因此每次运行都产生不确定的解决方案。
• coord_descent：普通坐标下降算法。同样是多线程的，但仍会产生确定性的解决方案。
• feature_selector：默认= cyclic。特征选择和排序方法
• cyclic：通过每次循环一个特征来实现的。
• shuffle：类似于cyclic，但是在每次更新之前都有随机的特征变换。
• random：一个随机(有放回)特征选择器。
• greedy：选择梯度最大的特征。（贪婪选择）
• thrifty：近似贪婪特征选择（近似于greedy）
• top_k：要选择的最重要特征数（在greedy和thrifty内）

1.3.3 任务参数

这个参数用来控制理想的优化目标和每一步结果的度量方法。

• objective：默认=reg:squarederror，表示最小平方误差。
• reg:squarederror,最小平方误差。
• reg:squaredlogerror,对数平方损失。12[𝑙𝑜𝑔(𝑝𝑟𝑒𝑑+1)−𝑙𝑜𝑔(𝑙𝑎𝑏𝑒𝑙+1)]212[log(pred+1)−log(label+1)]2
• reg:logistic,逻辑回归
• reg:pseudohubererror,使用伪Huber损失进行回归，这是绝对损失的两倍可微选择。
• binary:logistic,二元分类的逻辑回归，输出概率。
• binary:logitraw：用于二进制分类的逻辑回归，逻辑转换之前的输出得分。
• binary:hinge：二进制分类的铰链损失。这使预测为0或1，而不是产生概率。（SVM就是铰链损失函数）
• count:poisson –计数数据的泊松回归，泊松分布的输出平均值。
• survival:cox：针对正确的生存时间数据进行Cox回归（负值被视为正确的生存时间）。
• survival:aft：用于检查生存时间数据的加速故障时间模型。
• aft_loss_distribution：survival:aft和aft-nloglik度量标准使用的概率密度函数。
• multi:softmax：设置XGBoost以使用softmax目标进行多类分类，还需要设置num_class（类数）
• multi:softprob：与softmax相同，但输出向量，可以进一步重整为矩阵。结果包含属于每个类别的每个数据点的预测概率。
• rank:pairwise：使用LambdaMART进行成对排名，从而使成对损失最小化。
• rank:ndcg：使用LambdaMART进行列表式排名，使标准化折让累积收益（NDCG）最大化。
• rank:map：使用LambdaMART进行列表平均排名，使平均平均精度（MAP）最大化。
• reg:gamma：使用对数链接进行伽马回归。输出是伽马分布的平均值。
• reg:tweedie：使用对数链接进行Tweedie回归。
• 自定义损失函数和评价指标：https://xgboost.readthedocs.io/en/latest/tutorials/custom_metric_obj.html
• eval_metric：验证数据的评估指标，将根据目标分配默认指标（回归均方根，分类误差，排名的平均平均精度），用户可以添加多个评估指标
• rmse，均方根误差； rmsle：均方根对数误差； mae：平均绝对误差；mphe：平均伪Huber错误；logloss：负对数似然； error：二进制分类错误率；
• merror：多类分类错误率； mlogloss：多类logloss； auc：曲线下面积； aucpr：PR曲线下的面积；ndcg：归一化累计折扣；map：平均精度；
• seed ：随机数种子，[默认= 0]。

1.4 调参

XGBoost的调参说明：

参数调优的一般步骤

1. 确定学习速率和提升参数调优的初始值

2. max_depth 和 min_child_weight 参数调优

3. gamma参数调优

4. subsample 和 colsample_bytree 参数优

5. 正则化参数alpha调优

6. 降低学习速率和使用更多的决策树

用网格法进行调参：

import xgboost as xgb
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import roc_auc_score

iris = load_iris()
X,y = iris.data,iris.target
col = iris.target_names 
train_x, valid_x, train_y, valid_y = train_test_split(X, y, test_size=0.3, random_state=1)   # 分训练集和验证集
parameters = {
              'max_depth': [5, 10, 15, 20, 25],
              'learning_rate': [0.01, 0.02, 0.05, 0.1, 0.15],
              'n_estimators': [500, 1000, 2000, 3000, 5000],
              'min_child_weight': [0, 2, 5, 10, 20],
              'max_delta_step': [0, 0.2, 0.6, 1, 2],
              'subsample': [0.6, 0.7, 0.8, 0.85, 0.95],
              'colsample_bytree': [0.5, 0.6, 0.7, 0.8, 0.9],
              'reg_alpha': [0, 0.25, 0.5, 0.75, 1],
              'reg_lambda': [0.2, 0.4, 0.6, 0.8, 1],
              'scale_pos_weight': [0.2, 0.4, 0.6, 0.8, 1]

}
xlf = xgb.XGBClassifier(max_depth=10,
            learning_rate=0.01,
            n_estimators=2000,
            silent=True,
            objective='multi:softmax',
            num_class=3 ,          
            nthread=-1,
            gamma=0,
            min_child_weight=1,
            max_delta_step=0,
            subsample=0.85,
            colsample_bytree=0.7,
            colsample_bylevel=1,
            reg_alpha=0,
            reg_lambda=1,
            scale_pos_weight=1,
            seed=0,
            missing=None)

gs = GridSearchCV(xlf, param_grid=parameters, scoring='accuracy', cv=3)
gs.fit(train_x, train_y)

print("Best score: %0.3f" % gs.best_score_)
print("Best parameters set: %s" % gs.best_params_ )

1.5 XGBoost与GBDT的联系和区别有哪些？

（1）GBDT是机器学习算法，XGBoost是该算法的工程实现。
（2）正则项： 在使用CART作为基分类器时，XGBoost显式地加入了正则项来控制模型的复杂度，有利于防止过拟合，从而提高模型的泛化能力。
（3）导数信息： GBDT在模型训练时只使用了代价函数的一阶导数信息，XGBoost对代价函数进行二阶泰勒展开，可以同时使用一阶和二阶导数。
（4）基分类器： 传统的GBDT采用CART作为基分类器，XGBoost支持多种类型的基分类器，比如线性分类器。
（5）子采样： 传统的GBDT在每轮迭代时使用全部的数据，XGBoost则采用了与随机森林相似的策略，支持对数据进行采样。
（6）缺失值处理： 传统GBDT没有设计对缺失值进行处理，XGBoost能够自动学习出缺失值的处理策略。
（7）并行化： 传统GBDT没有进行并行化设计，注意不是tree维度的并行，而是特征维度的并行。XGBoost预先将每个特征按特征值排好序，存储为块结构，分裂结点时可以采用多线程并行查找每个特征的最佳分割点，极大提升训练速度。

1.6 XGBoost处理缺失值

​ 在普通的GBDT策略中，对于缺失值的方法是先手动对缺失值进行填充，然后当做有值的特征进行处理，但是这样人工填充不一定准确，而且没有什么理论依据。而XGBoost采取的策略是先不处理那些值缺失的样本，采用那些有值的样本搞出分裂点，在遍历每个有值特征的时候，尝试将缺失样本划入左子树和右子树，选择使损失最优的值作为分裂点。

2. LightGBM

​ 常用的机器学习算法，例如神经网络等算法，都可以以mini-batch的方式训练，训练数据的大小不会受到内存限制。而GBDT在每一次迭代的时候，都需要遍历整个训练数据多次。如果把整个训练数据装进内存则会限制训练数据的大小；如果不装进内存，反复地读写训练数据又会消耗非常大的时间。尤其面对工业级海量的数据，普通的GBDT算法是不能满足其需求的。LightGBM提出的主要原因就是为了解决GBDT在海量数据遇到的问题，让GBDT可以更好更快地用于工业实践。

2.1 优化方式

lightGBM在传统的GBDT算法上进行了如下优化：

• 基于Histogram的决策树算法。
• 单边梯度采样 Gradient-based One-Side Sampling(GOSS)：使用GOSS可以减少大量只具有小梯度的数据实例，这样在计算信息增益的时候只利用剩下的具有高梯度的数据就可以了，相比XGBoost遍历所有特征值节省了不少时间和空间上的开销。
• 互斥特征捆绑 Exclusive Feature Bundling(EFB)：使用EFB可以将许多互斥的特征绑定为一个特征，这样达到了降维的目的。
• 带深度限制的Leaf-wise的叶子生长策略：大多数GBDT工具使用低效的按层生长 (level-wise) 的决策树生长策略，因为它不加区分的对待同一层的叶子，带来了很多没必要的开销。实际上很多叶子的分裂增益较低，没必要进行搜索和分裂。LightGBM使用了带有深度限制的按叶子生长 (leaf-wise) 算法。
• 直接支持类别特征(Categorical Feature)，采用 many-vs-many 的切分方式将类别特征分为两个子集，实现类别特征的最优切分
• 支持高效并行：特征并行和数据并行
• Cache命中率优化

2.2 优缺点

2.2.1 优点

（1）速度更快

• LightGBM 采用了直方图算法将遍历样本转变为遍历直方图，极大的降低了时间复杂度；
• LightGBM 在训练过程中采用单边梯度算法过滤掉梯度小的样本，减少了大量的计算；
• LightGBM 采用了基于 Leaf-wise 算法的增长策略构建树，减少了很多不必要的计算量；
• LightGBM 采用优化后的特征并行、数据并行方法加速计算，当数据量非常大的时候还可以采用投票并行的策略；
• LightGBM 对缓存也进行了优化，增加了缓存命中率；
  （2）内存更小
• XGBoost使用预排序后需要记录特征值及其对应样本的统计值的索引，而 LightGBM 使用了直方图算法将特征值转变为 bin 值，且不需要记录特征到样本的索引，将空间复杂度从$O(2\ast data)$ 降低为 $O(bin)$，极大的减少了内存消耗；
• LightGBM 采用了直方图算法将存储特征值转变为存储 bin 值，降低了内存消耗；
• LightGBM 在训练过程中采用互斥特征捆绑算法减少了特征数量，降低了内存消耗。

2.2.2 缺点

• 可能会长出比较深的决策树，产生过拟合。因此LightGBM在Leaf-wise之上增加了一个最大深度限制，在保证高效率的同时防止过拟合；
• Boosting族是迭代算法，每一次迭代都根据上一次迭代的预测结果对样本进行权重调整，所以随着迭代不断进行，误差会越来越小，模型的偏差（bias）会不断降低。由于LightGBM是基于偏差的算法，所以会对噪点较为敏感；
• 在寻找最优解时，依据的是最优切分变量，没有将最优解是全部特征的综合这一理念考虑进去；

2.3 参数设置

1. 核心参数：（括号内名称是别名）

• objective（objective，app ，application）：默认regression，用于设置损失函数
• 回归问题：
  • L2损失：regression（regression_l2，l2，mean_squared_error，mse，l2_root，root_mean_squared_error，rmse）
  • L1损失：regression_l1（l1, mean_absolute_error, mae）
  • 其他损失：huber，fair，poisson，quantile，mape，gamma，tweedie
• 二分类问题：二进制对数损失分类（或逻辑回归）：binary
• 多类别分类：
  • softmax目标函数： multiclass（softmax）
  • One-vs-All 目标函数：multiclassova（multiclass_ova，ova，ovr）
• 交叉熵：
  • 用于交叉熵的目标函数（具有可选的线性权重）：cross_entropy（xentropy）
  • 交叉熵的替代参数化：cross_entropy_lambda（xentlambda）
• boosting ：默认gbdt，设置提升类型，选项有gbdt，rf，dart，goss，别名：boosting_type，boost
• gbdt（gbrt）:传统的梯度提升决策树
• rf（random_forest）：随机森林
• dart：多个加性回归树的DROPOUT方法 Dropouts meet Multiple Additive Regression Trees，参见：https://arxiv.org/abs/1505.01866
• goss：基于梯度的单边采样 Gradient-based One-Side Sampling
• data（train，train_data，train_data_file，data_filename）：用于训练的数据或数据file
• valid （test，valid_data，valid_data_file，test_data，test_data_file，valid_filenames）：验证/测试数据的路径，LightGBM将输出这些数据的指标
• num_iterations：默认=100，类型= INT
• n_estimators：提升迭代次数，LightGBM构造用于多类分类问题的树num_class * num_iterations
• learning_rate（shrinkage_rate，eta） ：收缩率，默认=0.1
• num_leaves（num_leaf，max_leaves，max_leaf） ：默认=31，一棵树上的最大叶子数
• tree_learner （tree，tree_type，tree_learner_type）：默认=serial，可选：serial，feature，data，voting
• serial：单台机器的 tree learner
• feature：特征并行的 tree learner
• data：数据并行的 tree learner
• voting：投票并行的 tree learner
• num_threads（num_thread, nthread）：LightGBM 的线程数，为了更快的速度, 将此设置为真正的 CPU 内核数, 而不是线程的数量 (大多数 CPU 使用超线程来使每个 CPU 内核生成 2 个线程)，当你的数据集小的时候不要将它设置的过大 (比如, 当数据集有 10,000 行时不要使用 64 线程)，对于并行学习, 不应该使用全部的 CPU 内核, 因为这会导致网络性能不佳。
• device（device_type）：默认cpu，为树学习选择设备, 你可以使用 GPU 来获得更快的学习速度，可选cpu, gpu。
• seed （random_seed，random_state）：与其他种子相比，该种子具有较低的优先级，这意味着如果您明确设置其他种子，它将被覆盖。

2. 用于控制模型学习过程的参数：

• max_depth：限制树模型的最大深度. 这可以在 #data 小的情况下防止过拟合. 树仍然可以通过 leaf-wise 生长。
• min_data_in_leaf： 默认=20，一个叶子上数据的最小数量. 可以用来处理过拟合。
• min_sum_hessian_in_leaf（min_sum_hessian_per_leaf, min_sum_hessian, min_hessian）：默认=1e-3，一个叶子上的最小 hessian 和. 类似于 min_data_in_leaf, 可以用来处理过拟合.
• feature_fraction：default=1.0，如果 feature_fraction 小于 1.0, LightGBM 将会在每次迭代中随机选择部分特征. 例如, 如果设置为 0.8, 将会在每棵树训练之前选择 80% 的特征，可以用来加速训练，可以用来处理过拟合。
• feature_fraction_seed：默认=2，feature_fraction 的随机数种子。
• bagging_fraction（sub_row, subsample）：默认=1，不进行重采样的情况下随机选择部分数据
• bagging_freq（subsample_freq）：bagging 的频率, 0 意味着禁用 bagging. k 意味着每 k 次迭代执行bagging
• bagging_seed（bagging_fraction_seed） ：默认=3，bagging 随机数种子。
• early_stopping_round（early_stopping_rounds, early_stopping）：默认=0，如果一个验证集的度量在 early_stopping_round 循环中没有提升, 将停止训练
• lambda_l1（reg_alpha）：L1正则化系数
• lambda_l2（reg_lambda）：L2正则化系数
• min_split_gain（min_gain_to_split）：执行切分的最小增益，默认=0.
• cat_smooth：默认=10，用于分类特征，可以降低噪声在分类特征中的影响, 尤其是对数据很少的类别

3.度量参数：

• metric：default={l2 for regression}, {binary_logloss for binary classification}, {ndcg for lambdarank}, type=multi-enum, options=l1, l2, ndcg, auc, binary_logloss, binary_error …
• l1, absolute loss, alias=mean_absolute_error, mae
• l2, square loss, alias=mean_squared_error, mse
• l2_root, root square loss, alias=root_mean_squared_error, rmse
• quantile, Quantile regression
• huber, Huber loss
• fair, Fair loss
• poisson, Poisson regression
• ndcg, NDCG
• map, MAP
• auc, AUC
• binary_logloss, log loss
• binary_error, 样本: 0 的正确分类, 1 错误分类
• multi_logloss, mulit-class 损失日志分类
• multi_error, error rate for mulit-class 出错率分类
• xentropy, cross-entropy (与可选的线性权重), alias=cross_entropy
• xentlambda, “intensity-weighted” 交叉熵, alias=cross_entropy_lambda
• kldiv, Kullback-Leibler divergence, alias=kullback_leibler
• 支持多指标, 使用 , 分隔
• train_metric（training_metric, is_training_metric）：默认=False，如果你需要输出训练的度量结果则设置 true

4.GPU 参数：

isson regression

• ndcg, NDCG
• map, MAP
• auc, AUC
• binary_logloss, log loss
• binary_error, 样本: 0 的正确分类, 1 错误分类
• multi_logloss, mulit-class 损失日志分类
• multi_error, error rate for mulit-class 出错率分类
• xentropy, cross-entropy (与可选的线性权重), alias=cross_entropy
• xentlambda, “intensity-weighted” 交叉熵, alias=cross_entropy_lambda
• kldiv, Kullback-Leibler divergence, alias=kullback_leibler
• 支持多指标, 使用 , 分隔
• train_metric（training_metric, is_training_metric）：默认=False，如果你需要输出训练的度量结果则设置 true

4.GPU 参数：

gpu_device_id：default为-1, 这个default意味着选定平台上的设备。

参考文档：https://zhuanlan.zhihu.com/p/87885678