机器学习算法[9]--集成方法之XGBoost原理详解及XGBoost库实现

1. XGBoost

1.1 原理

XGBoost(Extreme Gradient Boosting)通过串行的方式迭代训练多个相互依赖的决策树回归模型，最后综合多个简单模型共同作用产生输出，在GBDT作出全面优化改进，其中主要改进思想：

（1）GBDT中将简单模型限定为只能使用决策树回归模型；而XGBoost支持使用其他的简单模型(一般多采用决策树回归模型)，如线性回归

（2）GBDT未考虑正则项，在算法优化方面使用负梯度(一阶泰勒)拟合残差；而XGBoost为实现精确度与复杂度之间的平衡在损失函数部分加入正则项，在算法优化方面使用二阶负梯度(二阶泰勒)拟合带正则项损失函数的残差，因此XGBoost可使用任意二阶可导的损失函数

（3）GBDT通过决策树回归模型拟合残差得出叶子节点后求解最佳拟合值；而XGBoost合并决策树模型叶子节点和最佳拟合值的求解，并且考虑结构复杂度引入了全新的决策分支准则：结构分数增益

（4）使用估计贪婪算法，平行学习等方法引入并行处理优化模型运行效率，使用感知缓存访问技术与核外计算技术等提升硬件上的运算性能，引入Droupout技术，为模型建立过程增加更多的随机性，增加对缺失特征值样本的自动学习

1.1.1 算法解析

假设给定一个大小为$n$的数据集：
D = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . . . , ( x n , y n ) } \boldsymbol{D} = \{ (\pmb{x_1},y_1), (\pmb{x_2}, y_2),.....,(\pmb{x_n}, y_n) \} D={ (x1​​x1​​​x1​,y1​),(x2​​x2​​​x2​,y2​),.....,(xn​​xn​​​xn​,yn​)}

XGBoost的思想与GBDT类似，通过拟合残差得到第t次模型$h_t(x\text{x}x)$使得第t次XGBoost模型损失函数$L(y,f_{t-1}(x\text{x}x)+h_t(x\text{x}x))$最小，再此基础上加入正则项如下：
$$\sum _{i=1}^{n}L(y_i,f_{t-1}({x\text{x}x}_i)+h_t({x\text{x}x}_i))+\gamma J+\frac{\lambda }{2}\sum _{j=1}^J{w}_{tj}^2+\alpha \sum _{j=1}^J|w_{tj}|\text{\hspace{1em}(1)}$$

其中$L$代表任意二阶可导的损失函数，$J$为第t次模型叶子节点的个数，$w_{tj}$和GBDT中$c_t^{(j)}$意义相同代表叶子节点的回归值，$\gamma ,\lambda ,\alpha$代表正则化惩罚系数

对式(1)进行二阶泰勒展开(为方便计算，假设$\alpha$取0)：
$$\begin{array}{rl}& \sum _{i=1}^{n}L(y_i,f_{t-1}({x\text{x}x}_i)+h_t({x\text{x}x}_i))+\gamma J+\frac{\lambda }{2}\sum _{j=1}^J{w}_{tj}^2\\ & =\sum _{i=1}^n(L(y_i,f_{t-1}({x\text{x}x}_i))+\frac{\partial L(y_i,f_{t-1}({x\text{x}x}_i))}{\partial f_{t-1}({x\text{x}x}_i)}{h}_t({x\text{x}x}_i)+\frac{1}{2}\frac{{\partial }^{2}L(y_i,f_{t-1}({x\text{x}x}_i))}{{\partial }^2{f}_{t-1}({x\text{x}x}_i)}{h}_t^2({x\text{x}x}_i))+\gamma J+\frac{\lambda }{2}\sum _{j=1}^J{w}_{tj}^2\end{array}\text{\hspace{1em}(2)}$$
令：
$$g_{ti}=\frac{\partial L(y_i,f_{t-1}({x\text{x}x}_i))}{\partial f_{t-1}({x\text{x}x}_i)},h_{ti}=\frac{{\partial }^{2}L(y_i,f_{t-1}({x\text{x}x}_i))}{{\partial }^2{f}_{t-1}({x\text{x}x}_i)}$$

式(2)为：
$$\sum _{i=1}^n(L(y_i,f_{t-1}({x\text{x}x}_i))+g_{ti}{h}_t({x\text{x}x}_i)+\frac{1}{2}{h}_{ti}{h}_t^2({x\text{x}x}_i))+\gamma J+\frac{\lambda }{2}\sum _{j=1}^J{w}_{tj}^2\text{\hspace{1em}(3)}$$

考虑到$L(y_i,f_{t-1}({x\text{x}x}_i))$为常数，对最小化损失函数无影响，同时对于决策树回归模型$h_t({x\text{x}x}_i)$取决于最终叶子节点的回归值$w_{tj}$，则式(3)可简化为：
$$\sum _{j=1}^J(\sum _{x_i\in R_{tj}}{g}_{ti}{w}_{tj}+\sum _{x_i\in R_{tj}}\frac{1}{2}{h}_{ti}{w}_{tj}^2)+\gamma J+\frac{\lambda }{2}\sum _{j=1}^J{w}_{tj}^2$$

令：
$$G_{tj}=\sum _{x\in R_{tj}}{g}_{ti},H_{tj}=\sum _{x\in R_{tj}}{h}_{ti}$$

则最终的损失函数表达式为：
$$\sum _{j=1}^J(G_{tj}{w}_{tj}+\frac{1}{2}(H_{tj}+\lambda )w_{tj}^2)+\gamma J\text{\hspace{1em}(4)}$$

为求解$w_{tj}$对最终损失函数(4)关于$w_{tj}$求导令其为0，得：
$$w_{tj}=-\frac{G_{tj}}{H_{tj}+\lambda }$$
将其带入损失函数，则原损失函数表达式变为：
$$\sum _{j=1}^J-\frac{1}{2}\frac{G_{tj}^2}{H_{tj}+\lambda }+\gamma J$$
假设决策树为二叉树模型，为了在决策树回归模型生成过程中最大程度的减小损失函数，$G_L,H_L,G_R,H_R$为左右子树的一阶及二阶导数和，则期望最大化分裂左右子树前后的损失函数差：
$$\begin{array}{rl}& \max (-\frac{1}{2}\frac{(G_L+G_R{)}^2}{H_L+H_R+\lambda }+\gamma J-(-\frac{1}{2}\frac{G_L^2}{H_L+\lambda }-\frac{1}{2}\frac{G_R^2}{H_R+\lambda }+\gamma (J+1)))\\ & =\max (\frac{1}{2}\frac{G_L^2}{H_L+\lambda }+\frac{1}{2}\frac{G_R^2}{H_R+\lambda }-\frac{1}{2}\frac{(G_L+G_R{)}^2}{H_L+H_R+\lambda }-\gamma )\end{array}$$

因此引入全新的决策分支准则，最大化结构分数增益：
$$Gian=左节点结构分数+右节点结构分数-父节点结构分数$$
其中结构分数定义为:
$$\frac{G_{tj}^2}{H_{tj}+\lambda }$$

1.1.2 算法流程

（1）计算输入数据基于$f_{t-1}({x\text{x}x}_i)$的一阶导数之和$G_t$及二阶导数之和$H_t$
$$G_t=\sum _{i=1}^n{g}_{ti},H_t=\sum _{i=1}^n{h}_{ti}$$

（2）计算各特征结构分数，将所有的样本都放在右子树，然后从小到大迭代依次放入左子树，根据最大化结构分数增益划分特征和特征值
$$Gain=\frac{G_L^2}{H_L+\lambda }+\frac{G_R^2}{H_R+\lambda }-\frac{(G_L+G_R{)}^2}{H_L+H_R+\lambda }$$

（3）当结构分数增益为0时，当前t轮决策树模型建立完成，计算所有叶子区域$w_{tj}$
$$w_{tj}=-\frac{G_{tj}}{H_{tj}+\lambda }$$

（4）根据$w_{tj}$，更新第t次决策树回归模型：
$$f_t(x\text{x}x)=f_{t-1}(x\text{x}x)+h_t(x\text{x}x)$$

（5）当达到模型训练的最大迭代次数，则组合得到最终的XGBoost模型：
$$f(x\text{x}x)=\sum _{t=1}^m{f}_t(x\text{x}x)$$
其中$m$为模型训练迭代次数

1.2 XGBoost库实现

sklearn库没有封装XGBoost类，使用XGBoost需要手动安装，可使用pip install xgboost直接安装

XGboost库包含了多种接口，这里仅介绍有关sklearn接口，即Scikit-Learn API
参考官方文档：点击查看

XGBoost回归可通过xgboost库中的XGBRegressor类实现

有关参数：

• n_estimators：迭代更新次数，即回归模型数量
• max_depth：决策树的最大深度
• max_leaves：最大的叶子节点数量
• max_bin：基于直方图算法中的每个特征最大容器数量
• grow_policy：决策树建立的准则，0-按距离最近的节点进行拆分，即按深度方向增长；1-按损失变化最大的节点进行拆分
• learning_rate：每次迭代过程中更新模型的附加权重(正则化方法)
• verbosity：控制输出的详细程度
• objective：指定相关损失函数的定义
• booster：选择迭代过程中的模型，gbtree-决策树模型(CART)，gblinear-线性模型，dart-带droupout的决策树模型
• tree_method：建立树模型时使用的算法
• n_jobs：计算过程当中的并行数量
• gamma：正则化惩罚系数，γ
• min_child_weight：叶子节点的权重总和中需要的最小加权分数
• max_delta_step：叶子节点的最大权重
• subsample：针对样本的下采样比例
• sample_method：选择采样方法
• colsample_bytree：每个树模型所用特征的下采样比例
• colsample_bylevel：树模型每层所用特征的下采样比例
• colsample_bynode：树模型分裂时所用特征的下采样比例
• reg_alpha：L1正则化系数
• reg_lambda：L2正则化系数
• scale_pose_weight：平衡样本权重
• base_score：每个样本的初始预测分数(全局偏差)
• random_state：控制迭代更新过程中的随机性
• missing：当数据缺失时填补的缺失值
• num_parallel_tree：用于随机森林的Boosting操作
• monotone_constraints：变量单调性约束
• interaction_constraints：变量允许交互约束
• importance_type：选择计算特征重要程度的类型
• gpu_id：设备号
• validate_parameters：是否对未知参数发出警告
• predictor：选择预测器类型(gpu，cpu)
• enable_categorical：对分类数据类型的支持
• max_cat_to_onehot：对分割分类数据类型是否使用onehot编码的阈值
• eval_metric：评价模型最终结果的准则
• early_stopping_rounds：控制提前停止迭代更新
• callbacks：每次迭代结束时调用的函数包
• kwargs：XGboost对象的keyword参数字典

有关属性：

• best_iteration：迭代过程中最好模型的迭代次数
• best_score：迭代过程中最好模型的得分
• coef_：回归系数，仅使用线性模型
• intercept_：常数项，仅使用线性模型
• feature_importances_：基于特征计算类型的各特征重要程度
• n_features_in_：特征的个数
• feature_names_in_：特征的名称，仅当输入特征有(字符)名称时可用

有关方法：

• apply：获取XGboost中各决策树模型上每个叶子节点对应输入数据的索引
• evals_result：返回模型评估结果
• fit：生成XGBoost模型
• get_booster：获取迭代过程中的模型
• get_num_boosting_rounds：获取迭代更新次数
• get_params：获取模型参数
• get_xgb_params：获取XGBoost模型特定参数
• load_model：加载模型
• predict：预测回归值
• save_model：保存模型
• score：获取模型预测的确定系数
• set_params：设置对应模型参数

使用案例

>>> import numpy as np
>>> from xgboost import XGBRegressor

>>> reg = XGBRegressor() #实例化XGBoost回归模型对象
>>> X = np.array([[1, 1], [3, 2], [4, 7], [2, 5]]) #数据
>>> y = np.array([3, 6, 11, 8]) #类别
>>> reg.fit(X, y) #拟合求解
>>> reg.n_features_in_
2
>>> reg.feature_importances_
[0.69..., 0.308...]
>>> reg.get_params()
{
    
    'objective': 'reg:squarederror', 'base_score': 0.5, 'booster': 'gbtree', 'callbacks': None, 
'colsample_bylevel': 1, 'colsample_bynode': 1, 'colsample_bytree': 1, 'early_stopping_rounds': None, 
'enable_categorical': False, 'eval_metric': None, 'gamma': 0, 'gpu_id': -1, 'grow_policy': 'depthwise', 
'importance_type': None, 'interaction_constraints': '', 'learning_rate': 0.300000012, 'max_bin': 256, 
'max_cat_to_onehot': 4, 'max_delta_step': 0, 'max_depth': 6, 'max_leaves': 0, 'min_child_weight': 1, 
'missing': nan, 'monotone_constraints': '()', 'n_estimators': 100, 'n_jobs': 0, 'num_parallel_tree': 1, 
'predictor': 'auto', 'random_state': 0, 'reg_alpha': 0, 'reg_lambda': 1, 'sampling_method': 'uniform', 
'scale_pos_weight': 1, 'subsample': 1, 'tree_method': 'exact', 'validate_parameters': 1, 'verbosity': None}
>>> reg.predict([[1, 0]])
[3.00...]
>>> reg.score(X, y)
0.99...