2021-04-20

Bagging思想的实质是：通过Bootstrap 的方式对全样本数据集进行抽样得到抽样子集，对不同的子集使用同一种基本模型进行拟合，然后投票得出最终的预测。

Boosting是与Bagging截然不同的思想，Boosting方法是使用同一组数据集进行反复学习，得到一系列简单模型，然后组合这些模型构成一个预测性能十分强大的机器学习模型。显然，Boosting思想提高最终的预测效果是通过不断减少偏差的形式，与Bagging有着本质的不同。

弱学习：识别错误率小于1/2（即准确率仅比随机猜测略高的学习算法）
强学习：识别准确率很高并能在多项式时间内完成的学习算法

Adaboost的基本原理

对于Adaboost来说，解决上述的两个问题的方式是：1. 提高那些被前一轮分类器错误分类的样本的权重，而降低那些被正确分类的样本的权重。这样一来，那些在上一轮分类器中没有得到正确分类的样本，由于其权重的增大而在后一轮的训练中“备受关注”。2. 各个弱分类器的组合是通过采取加权多数表决的方式，具体来说，加大分类错误率低的弱分类器的权重，因为这些分类器能更好地完成分类任务，而减小分类错误率较大的弱分类器的权重，使其在表决中起较小的作用。
现在，我们来具体介绍Adaboost算法：(参考李航老师的《统计学习方法》)
假设给定一个二分类的训练数据集： T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ⋯   , ( x N , y N ) } T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right\} T={(x1​,y1​),(x2​,y2​),⋯,(xN​,yN​)}，其中每个样本点由特征与类别组成。特征$x_i\in \mathcal{X}\subseteq {\mathbf{R}}^n$，类别 y i ∈ Y = { − 1 , + 1 } y_{i} \in \mathcal{Y}=\{-1,+1\} yi​∈Y={−1,+1}，$\mathcal{X}$是特征空间，$ \mathcal{Y}$是类别集合，输出最终分类器$G(x)$。Adaboost算法如下：(1)初始化训练数据的分布：$D_{1}=\left(w_{11}, \cdots, w_{1 i}, \cdots, w_{1 N}\right), \quad w_{1 i}=\frac{1}{N}, \quad i=1,2, \cdots, N$
(2) 对于m=1,2,…,M

使用具有权值分布$D_m$的训练数据集进行学习，得到基本分类器： G m ( x ) : X → { − 1 , + 1 } G_{m}(x): \mathcal{X} \rightarrow\{-1,+1\} Gm​(x):X→{−1,+1}
计算$G_m(x)$在训练集上的分类误差率$e_m={\sum }_{i=1}^{N}P\left(G_m\left(x_i\right)\ne y_i\right)={\sum }_{i=1}^N{w}_{mi}I\left(G_m\left(x_i\right)\ne y_i\right)$
计算$G_m(x)$的系数${\alpha }_m=\frac{1}{2}\log \frac{1-e_m}{e_m}$，这里的log是自然对数ln
更新训练数据集的权重分布
undefined \begin{array}{c} D_{m+1}=\left(w_{m+1,1}, \cdots, w_{m+1, i}, \cdots, w_{m+1, N}\right) \ w_{m+1, i}=\frac{w_{m i}}{Z_{m}} \exp \left(-\alpha_{m} y_{i} G_{m}\left(x_{i}\right)\right), \quad i=1,2, \cdots, N \end{array} undefined
这里的$Z_m$是规范化因子，使得$D_{m+1}$称为概率分布，$Z_m={\sum }_{i=1}^N{w}_{mi}\exp \left(-{\alpha }_m{y}_i{G}_m\left(x_i\right)\right)$
(3) 构建基本分类器的线性组合$f(x)={\sum }_{m=1}^M{\alpha }_m{G}_m(x)$，得到最终的分类器

undefined \begin{aligned} G(x) &=\operatorname{sign}(f(x)) \ &=\operatorname{sign}\left(\sum_{m=1}^{M} \alpha_{m} G_{m}(x)\right) \end{aligned} undefined

下面对Adaboost算法做如下说明：
对于步骤(1)，假设训练数据的权值分布是均匀分布，是为了使得第一次没有先验信息的条件下每个样本在基本分类器的学习中作用一样。
对于步骤(2)，每一次迭代产生的基本分类器$G_m(x)$在加权训练数据集上的分类错误率$\begin{array}{rl}{e}_m& =\sum _{i=1}^{N}P\left(G_m\left(x_i\right)\ne y_i\right)=\sum _{G_m\left(x_i\right)\ne y_i}{w}_{mi}\end{array}$代表了在$G_m(x)$中分类错误的样本权重和，这点直接说明了权重分布$D_m$与$G_m(x)$的分类错误率$e_m$有直接关系。同时，在步骤(2)中，计算基本分类器$G_m(x)$的系数${\alpha }_m$，${\alpha }_m=\frac{1}{2}\log \frac{1-e_m}{e_m}$，它表示了$G_m(x)$在最终分类器的重要性程度，${\alpha }_m$的取值由基本分类器$G_m(x)$的分类错误率有直接关系，当$e_m⩽\frac{1}{2}$时，${\alpha }_m⩾0$，并且${\alpha }_m$随着$e_m$的减少而增大，因此分类错误率越小的基本分类器在最终分类器的作用越大！
*最重要的，对于步骤(2)中的样本权重的更新： *
undefined w_{m+1, i}=\left{\begin{array}{ll} \frac{w_{m i}}{Z_{m}} \mathrm{e}^{-\alpha_{m}}, & G_{m}\left(x_{i}\right)=y_{i} \ \frac{w_{m i}}{Z_{m}} \mathrm{e}^{\alpha_{m}}, & G_{m}\left(x_{i}\right) \neq y_{i} \end{array}\right. undefined
因此，从上式可以看到：被基本分类器$G_m(x)$错误分类的样本的权重扩大，被正确分类的样本权重减少，二者相比相差${\mathrm{e}}^{2{\alpha }_m}=\frac{1-e_m}{e_m}$倍。
对于步骤(3)，线性组合$f(x)$实现了将M个基本分类器的加权表决，系数${\alpha }_m$标志了基本分类器$G_m(x)$的重要性，值得注意的是：所有的${\alpha }_m$之和不为1。$f(x)$的符号决定了样本x属于哪一类。

下面，我们使用一组简单的数据来手动计算Adaboost算法的过程：(例子来源：http://www.csie.edu.tw)

训练数据如下表，假设基本分类器的形式是一个分割$x<v$或$x>v$表示，阈值v由该基本分类器在训练数据集上分类错误率$e_m$最低确定。
undefined \begin{array}{ccccccccccc} \hline \text { 序号 } & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 \ \hline x & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \ y & 1 & 1 & 1 & -1 & -1 & -1 & 1 & 1 & 1 & -1 \ \hline \end{array} undefined
解：
初始化样本权值分布 undefined \begin{aligned} D_{1} &=\left(w_{11}, w_{12}, \cdots, w_{110}\right) \ w_{1 i} &=0.1, \quad i=1,2, \cdots, 10 \end{aligned} undefined
对m=1:

在权值分布$D_1$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=2.5时分类误差率最低，那么基本分类器为： undefined G_{1}(x)=\left{\begin{array}{ll} 1, & x<2.5 \ -1, & x>2.5 \end{array}\right. undefined
$G_1(x)$在训练数据集上的误差率为$e_1=P\left(G_1\left(x_i\right)\ne y_i\right)=0.3$。
计算$G_1(x)$的系数：${\alpha }_1=\frac{1}{2}\log \frac{1-e_1}{e_1}=0.4236$
更新训练数据的权值分布：
undefined \begin{aligned} D_{2}=&\left(w_{21}, \cdots, w_{2 i}, \cdots, w_{210}\right) \ w_{2 i}=& \frac{w_{1 i}}{Z_{1}} \exp \left(-\alpha_{1} y_{i} G_{1}\left(x_{i}\right)\right), \quad i=1,2, \cdots, 10 \ D_{2}=&(0.07143,0.07143,0.07143,0.07143,0.07143,0.07143,\ &0.16667,0.16667,0.16667,0.07143) \ f_{1}(x) &=0.4236 G_{1}(x) \end{aligned} undefined
对于m=2：

在权值分布$D_2$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=8.5时分类误差率最低，那么基本分类器为：
undefined G_{2}(x)=\left{\begin{array}{ll} 1, & x<8.5 \ -1, & x>8.5 \end{array}\right. undefined
$G_2(x)$在训练数据集上的误差率为$e_2=0.2143$
计算$G_2(x)$的系数：${\alpha }_2=0.6496$
更新训练数据的权值分布：
undefined \begin{aligned} D_{3}=&(0.0455,0.0455,0.0455,0.1667,0.1667,0.1667\ &0.1060,0.1060,0.1060,0.0455) \ f_{2}(x) &=0.4236 G_{1}(x)+0.6496 G_{2}(x) \end{aligned} undefined
对m=3：

在权值分布$D_3$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=5.5时分类误差率最低，那么基本分类器为：
undefined G_{3}(x)=\left{\begin{array}{ll} 1, & x>5.5 \ -1, & x<5.5 \end{array}\right. undefined
$G_3(x)$在训练数据集上的误差率为$e_3=0.1820$
计算$G_3(x)$的系数：${\alpha }_3=0.7514$
更新训练数据的权值分布：
undefined D_{4}=(0.125,0.125,0.125,0.102,0.102,0.102,0.065,0.065,0.065,0.125) undefined
于是得到：$f_3(x)=0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x)$，分类器$\mathrm{sign}\left[f_3(x)\right]$在训练数据集上的误分类点的个数为0。
于是得到最终分类器为：$G(x)=\mathrm{sign}\left[f_3(x)\right]=\mathrm{sign}\left[0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x)\right]$

梯度提升决策树算法(GBDT)：
提升树利用加法模型和前向分步算法实现学习的过程，当损失函数为平方损失和指数损失时，每一步优化是相当简单的，也就是我们前面探讨的提升树算法和Adaboost算法。但是对于一般的损失函数而言，往往每一步的优化不是那么容易，针对这一问题，我们得分析问题的本质，也就是是什么导致了在一般损失函数条件下的学习困难。对比以下损失函数：
undefined \begin{array}{l|l|l} \hline \text { Setting } & \text { Loss Function } & -\partial L\left(y_{i}, f\left(x_{i}\right)\right) / \partial f\left(x_{i}\right) \ \hline \text { Regression } & \frac{1}{2}\left[y_{i}-f\left(x_{i}\right)\right]^{2} & y_{i}-f\left(x_{i}\right) \ \hline \text { Regression } & \left|y_{i}-f\left(x_{i}\right)\right| & \operatorname{sign}\left[y_{i}-f\left(x_{i}\right)\right] \ \hline \text { Regression } & \text { Huber } & y_{i}-f\left(x_{i}\right) \text { for }\left|y_{i}-f\left(x_{i}\right)\right| \leq \delta_{m} \ & & \delta_{m} \operatorname{sign}\left[y_{i}-f\left(x_{i}\right)\right] \text { for }\left|y_{i}-f\left(x_{i}\right)\right|>\delta_{m} \ & & \text { where } \delta_{m}=\alpha \text { th-quantile }\left{\left|y_{i}-f\left(x_{i}\right)\right|\right} \ \hline \text { Classification } & \text { Deviance } & k \text { th component: } I\left(y_{i}=\mathcal{G}{k}\right)-p{k}\left(x_{i}\right) \ \hline \end{array} undefined
观察Huber损失函数：
undefined L_{\delta}(y, f(x))=\left{\begin{array}{ll} \frac{1}{2}(y-f(x))^{2} & \text { for }|y-f(x)| \leq \delta \ \delta|y-f(x)|-\frac{1}{2} \delta^{2} & \text { otherwise } \end{array}\right. undefined
针对上面的问题，Freidman提出了梯度提升算法(gradient boosting)，这是利用最速下降法的近似方法，利用损失函数的负梯度在当前模型的值$-{\left[\frac{\partial L\left(y,f\left(x_i\right)\right)}{\partial f\left(x_i\right)}\right]}_{f(x)=f_{m-1}(x)}$作为回归问题提升树算法中的残差的近似值，拟合回归树。与其说负梯度作为残差的近似值，不如说残差是负梯度的一种特例。

XGBoost是陈天奇等人开发的一个开源机器学习项目，高效地实现了GBDT算法并进行了算法和工程上的许多改进，被广泛应用在Kaggle竞赛及其他许多机器学习竞赛中并取得了不错的成绩。XGBoost本质上还是一个GBDT，但是力争把速度和效率发挥到极致，所以叫X (Extreme) GBoosted，包括前面说过，两者都是boosting方法。XGBoost是一个优化的分布式梯度增强库，旨在实现高效，灵活和便携。 它在Gradient Boosting框架下实现机器学习算法。 XGBoost提供了并行树提升（也称为GBDT，GBM），可以快速准确地解决许多数据科学问题。 相同的代码在主要的分布式环境（Hadoop，SGE，MPI）上运行，并且可以解决超过数十亿个样例的问题。XGBoost利用了核外计算并且能够使数据科学家在一个主机上处理数亿的样本数据。最终，将这些技术进行结合来做一个端到端的系统以最少的集群系统来扩展到更大的数据集上。Xgboost以CART决策树为子模型，通过Gradient Tree Boosting实现多棵CART树的集成学习，得到最终模型。下面我们来看看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) 构造目标函数：
假设有K棵树，则第i个样本的输出为${\hat{y}}_i=\varphi \left({\mathrm{x}}_i\right)={\sum }_{k=1}^K{f}_k\left({\mathrm{x}}_i\right),f_k\in \mathcal{F}$，其中，$\mathcal{F}=\left\{f(\mathbf{x})=w_{q(\mathbf{x})}\right\}\left(q:{\mathbb{R}}^m\to T,w\in {\mathbb{R}}^T\right)$
因此，目标函数的构建为：
undefined \mathcal{L}(\phi)=\sum_{i} l\left(\hat{y}{i}, y{i}\right)+\sum_{k} \Omega\left(f_{k}\right) undefined
其中，${\sum }_{i}l\left({\hat{y}}_i,y_i\right)$为loss function，${\sum }_k\Omega \left(f_k\right)$为正则化项。
(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棵树的预测结果。
因此，目标函数可以分解为：
undefined \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) undefined 由于正则化项也可以分解为前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棵树的时候已经固定，无法改变，因此是一个已知的常数，可以在最优化的时候省去，故：
undefined \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) undefined
(3) 使用泰勒级数近似目标函数：
undefined \mathcal{L}^{(K)} \simeq \sum_{i=1}^{n}\left[l\left(y_{i}, \hat{y}^{(K-1)}\right)+g_{i} f_{K}\left(\mathrm{x}{i}\right)+\frac{1}{2} h{i} f_{K}^{2}\left(\mathrm{x}{i}\right)\right]+\Omega\left(f{K}\right) undefined
其中，$g_i={\partial }_{\hat{y}(t-1)}l\left(y_i,{\hat{y}}^{(t-1)}\right)$和$h_i={\partial }_{{\hat{y}}^{(t-1)}}^{2}l\left(y_i,{\hat{y}}^{(t-1)}\right)$
在这里，我们补充下泰勒级数的相关知识：
在数学中，泰勒级数（英语：Taylor series）用无限项连加式——级数来表示一个函数，这些相加的项由函数在某一点的导数求得。具体的形式如下：
undefined f(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}+\ldots+\frac{f}{(n)}\left(x_{0}\right)}{n !}\left(x-x_{0}\right)^{n}+… undefined
由于${\sum }_{i=1}^{n}l\left(y_i,{\hat{y}}^{(K-1)}\right)$在模型构建到第K棵树的时候已经固定，无法改变，因此是一个已知的常数，可以在最优化的时候省去，故：
undefined \tilde{\mathcal{L}}^{{(K)}=\sum_{i=1}}{n}\left[g_{i} f_{K}\left(\mathbf{x}{i}\right)+\frac{1}{2} h{i} f_{K}^{2}\left(\mathbf{x}{i}\right)\right]+\Omega\left(f{K}\right) undefined
(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)$，它可以由叶子节点的个数以及节点函数值来构建，则：$\Omega \left(f_K\right)=\gamma T+\frac{1}{2}\lambda {\sum }_{j=1}^T{w}_j^2$。如下图的例子：
jupyter
$q(x_1)=1,q(x_2)=3,q(x_3)=1,q(x_4)=2,q(x_5)=3$， I 1 = { 1 , 3 } , I 2 = { 4 } , I 3 = { 2 , 5 } I_1 = \{1,3\},I_2 = \{4\},I_3 = \{2,5\} I1​={1,3},I2​={4},I3​={2,5}，$w=(15,12,20)$
因此，目标函数用以上符号替代后：
undefined \begin{aligned} \tilde{\mathcal{L}}^{(K)} &=\sum_{i=1}^{n}\left[g_{i} f_{K}\left(\mathrm{x}{i}\right)+\frac{1}{2} h{i} f_{K}^{2}\left(\mathrm{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 \end{aligned} undefined
由于我们的目标就是最小化目标函数，现在的目标函数化简为一个关于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}bxc$求极值，对称轴在$x=-\frac{b}{2a}$，极值为$y=\frac{4ac-b^2}{4a}$，因此：
undefined w_{j}^{*}=-\frac{\sum_{i \in I_{j}} g_{i}}{\sum_{i \in I_{j}} h_{i}+\lambda} undefined
以及 undefined \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 undefined
(5) 如何寻找树的形状：
不难发现，刚刚的讨论都是基于树的形状已经确定了计算$w$和$L$，但是实际上我们需要像学习决策树一样找到树的形状。因此，我们借助决策树学习的方式，使用目标函数的变化来作为分裂节点的标准。我们使用一个例子来说明：
jupyter
例子中有8个样本，分裂方式如下，因此:
undefined \tilde{\mathcal{L}}^{(old)} = -\frac{1}{2}[\frac{(g_7 + g_8)^2}{H_7+H_8 + \lambda} + \frac{(g_1 +…+ g_6)^2}{H_1+…+H_6 + \lambda}] + 2\gamma \ \tilde{\mathcal{L}}^{(new)} = -\frac{1}{2}[\frac{(g_7 + g_8)^2}{H_7+H_8 + \lambda} + \frac{(g_1 +…+ g_3)^2}{H_1+…+H_3 + \lambda} + \frac{(g_4 +…+ g_6)^2}{H_4+…+H_6 + \lambda}] + 3\gamma\ \tilde{\mathcal{L}}^{(old)} - \tilde{\mathcal{L}}^{(new)} = \frac{1}{2}[ \frac{(g_1 +…+ g_3)^2}{H_1+…+H_3 + \lambda} + \frac{(g_4 +…+ g_6)^2}{H_4+…+H_6 + \lambda} - \frac{(g_1+…+g_6)^2}{h_1+…+h_6+\lambda}] - \gamma undefined
因此，从上面的例子看出：分割节点的标准为 m a x { L ~ ( o l d ) − L ~ ( n e w ) } max\{\tilde{\mathcal{L}}^{(old)} - \tilde{\mathcal{L}}^{(new)} \} max{L~(old)−L~(new)}，即：
undefined \mathcal{L}{\text {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 undefined
(6.1) 精确贪心分裂算法：
XGBoost在生成新树的过程中，最基本的操作是节点分裂。节点分裂中最重 要的环节是找到最优特征及最优切分点, 然后将叶子节点按照最优特征和最优切 分点进行分裂。选取最优特征和最优切分点的一种思路如下：首先找到所有的候 选特征及所有的候选切分点, 一一求得其 ${\mathcal{L}}_{\text{split }}$, 然后选择${\mathcal{L}}_{\mathrm{s}\mathrm{p}\mathrm{l}\mathrm{i}\mathrm{t}}$ 最大的特征及 对应切分点作为最优特征和最优切分点。我们称此种方法为精确贪心算法。该算法是一种启发式算法, 因为在节点分裂时只选择当前最优的分裂策略, 而非全局最优的分裂策略

XGBoost的参数分为三种：

通用参数：（两种类型的booster，因为tree的性能比线性回归好得多，因此我们很少用线性回归。）
booster:使用哪个弱学习器训练，默认gbtree，可选gbtree，gblinear 或dart
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：每个训练实例的选择概率与规则化的梯度绝对值成正比，具体来说就是$\sqrt{g^2+\lambda h^2}$，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对第一个预测变量施加增加的约束，对第二个预测变量施加减小的约束。）
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内）
任务参数（这个参数用来控制理想的优化目标和每一步结果的度量方法。）

objective：默认=reg:squarederror，表示最小平方误差。
reg:squarederror,最小平方误差。
reg:squaredlogerror,对数平方损失。$\frac{1}{2}[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]。