xgboost原生库接口(陈天奇) && xgboost的sklearn接口

0/参数网址

blog.csdn.net/momokofly/a… blog.csdn.net/Amanda_pyth…

1/xgboost原生库接口

陈天奇创造了XGBoost算法后，很快就和一群机器学习爱好者建立了专门的XGBoost库，名为xgboost
xgboost是一个独立的、开源的，并且专门提供梯度提升树以及XGBoost算法应用的算法库。
它和sklearn类似，有一个详细的官方网站可以提供学习资料，并且可以与C、Python、R、Julia等语言连用，但需要单独安装和下载。
安装或者更新xgboost原生库：
    pip install xgboost             # 安装xgboost库
    pip install --upgrade xgboost   # 更新xgboost库
使用xgboost原生库：
    import xgboost as xgb

建模流程：

从上图可以知道，xgboost原生库训练模型用的是train()函数，预测用的是predict()函数。
xgboost原生库必须先使用字典设置好参数，再用train()函数把参数集传入，然后再进行训练。
(sklearn是把所有的参数都写在类中)

xgboost原生库之所以要提前把参数写在一个字典中，是因为xgboost算法的参数实在是太多了，
如果全部写在xgb.train()函数中，不太美观，而且容易出错。


DMatrix()类：用于封装数据，它是XGBoost自定义的一个数据矩阵类，目的是这种定义方式可以优化存储和运算速度；

    import xgboost as xgb
    dtrain = xgb.DMatrix(X_train, label=y_train)
    dtest = xgb.DMatrix(X_test, label=y_test)
    
    # params:弱评估器(booster)有关的参数
    params = {
        'eta': 0.1, #学习率
        'max_depth':5 #树的最大深度
    }
    
    num_round = 20 # 迭代轮数

    bst = xgb.train(params=params,      #设置模型参数
                    dtrain=dtrain,      #dtrain：训练数据集
                    num_boost_round = num_round     #迭代轮数
                   ) 

    ypred = bst.predict(dtest)
    mean_squared_error(y_test, ypred)
    
    # 也可以一边训练，一边测试 
    bst = xgb.train(
        params=params, 
        dtrain=dtrain, 
        num_boost_round = num_round, 
        evals=[(dtrain, 'train'),(dtest, 'test')] #evals：验证数据集
    )  
    ```


    XGBoost必须先使用字典设定参数集，再使用train()将参数输入，进行训练；
    
    以下是xgboost.train()函数的使用方法：
    params {eta, 
            gamma, 
            max_depth, 
            min_child_weight, 
            max_delta_step, 
            subsample, 
            colsample_bytree, 
            colsample_bylevel,
            colsample_bynode, 
            lambda, 
            alpha, 
            tree_method_string, 
            sketch_eps, 
            scale_pos_weight, 
            updater, 
            refresh_leaf, 
            process_type, 
            grow_policy, 
            max_leaves, 
            max_bin, 
            predictor, 
            num_parallel_tree}
    
    xgboost.train(params, 
                  dtrain, 
                  num_boost_round = 10, 
                  evals = (), 
                  obj = None, 
                  feval = None, 
                  maximize = False, 
                  early_stopping_rounds = None, 
                  evals_result = None, 
                  verbose_eval = True, 
                  xgb_model = None, 
                  callbacks = None, 
                  learning_rates = None)
     
    
    xgboost原生接口，数据需要经过:
          输入数据标准化(xgboost.DMatrix),
          label标准化(LabelEncoder().fit_transform),
          输出结果反标签标准化(LabelEncoder().inverse_transform).
    训练调用train()预测调用predict()


# 2/xgboost中的sklearn中的接口
    from xgboost.sklearn import XGBClassifier   # 分类
    from xgboost.sklearn import XGBRegressor    # 回归

    XGBRegressor(max_depth = 3, 
                 learning_rate = 0.1, 
                 n_estimators = 100, 
                 silent = True, 
                 objective = ‘reg:linear’, 
                 booster = ‘gbtree’, 
                 n_jobs = 1, 
                 nthread = None, 
                 gamma = 0, 
                 min_child_weight = 1, 
                 max_delta_step = 0, 
                 subsample = 1,
                 colsample_bytree = 1, 
                 colsample_bylevel = 1, 
                 reg_alpha = 0, 
                 reg_lambda = 1, 
                 scale_pos_weight = 1, 
                 base_score = 0.5, 
                 random_state = 0, 
                 seed = None, 
                 missing = None, 
                 importance_type = ‘gain’, ∗ ∗ ** ∗∗kwargs)
      
    xgboost原生库和sklearn中的接口，输入的参数有点不同，但是看起来很接近。
    比如xgboost原生库中的字典params中的eta参数，其实就是XGBRegressor中的learning_rate，步长。
    他们虽然名字不同，但是功能是一样的。只是sklearn的开发团队很友好的把参数名称调整成了和sklearn中其它算法类似的样子。

```python
from xgboost.sklearn import XGBRegressor    # 回归
from sklearn.datasets import load_boston 
from sklearn.metrics import r2_score,mean_squared_error,mean_absolute_error,
                  accuracy_score,precision_score, recall_score 
from sklearn.model_selection import train_test_split 
import math 


# 数据准备
boston_data = load_boston() 
X = boston_data.data 
y = boston_data.target 

# 划分训练集，测试集合
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=420)


xgb_reg = XGBRegressor( n_estimators = 20, #迭代次数 l
                   earning_rate = 0.1, #学习率 
                   max_depth=5 )
                   
xgb_reg.fit(X_train, y_train) 
ypred = xgb_reg.predict(X_test) 
mean_squared_error(y_test, ypred)
math.sqrt(mean_squared_error(y_test, ypred))


# 设置eval_set参数，可以一边训练，一边测试 
reg.fit(X_train, y_train, eval_set = [(X_train, y_train), (X_test, y_test)])

3/xgboost的3大核心

集成算法本身
弱学习期
计算速度(开启的线程数)

4/弱学习器的数量的作用，产生的影响论：

首先，XGB中的树的数量决定了模型的学习能力，树的数量越多，模型的学习能力越强。
只要XGB中树的数量足够了，即便只有很少的数据，模型也能够学到训练数据100%的信息，所以XGB也是天生过拟合的模型。但在这种情况下，模型会变得非常不稳定。

第二，XGB中树的数量很少的时候，对模型的影响较大，当树的数量已经很多的时候，对模型的影响比较小，只能有微弱的变化。当数据本身就处于过拟合的时候，再使用过多的树能达到的效果甚微，反而浪费计算资源。当唯一指标 R 2 R^2 R2或者准确率给出的n_estimators看起来不太可靠的时候，可以改造学习曲线来帮助选择参数。

第三，树的数量提升对模型的影响有极限，最开始，模型的表现会随着XGB的树的数量一起提升，但到达某个点之后，树的数量越多，模型的效果会逐步下降，这也说明了暴力增加n_estimators不一定有效果。

这些都和随机森林中的参数n_estimators表现出一致的状态。
在随机森林中总是先调整n_estimators，当n_estimators的极限已达到，才考虑其他参数，
但XGB中的状况明显更加复杂，当数据集不太寻常的时候会更加复杂，这是要给出的第一个超参数，因此还是建议优先调整n_estimators，一般都不会建议一个太大的数目，300以下为佳。

5/subsample参数的作用

6/总结

xgboost原生库的运算速度和参数设定，都要比sklearn简单。
所有，总的来说，还是建议大家用xgboost原生库，import xgboost as xgb
训练使用train()，预测使用predict()

训练集上的表现展示了模型的学习能力，测试集上的表现展示了模型的泛化能力，通常模型在测试集上的表现不太可能超过训练集，因此希望测试集的学习曲线能够努力逼近训练集的学习曲线。

7/区别

两种使用方式的区别：
建模流程略有不同：原生库的数据必须封装在DMatrix()中，再进行训练；sklearnAPI没有数据封装的过程；
原生XGBoost库的大部分参数通过params传递；sklearnAPI没有params这个参数，所有参数都是直接在类里 面赋值；
原生XGBoost库的train()函数即可用来处理分类问题，也可用来处理回归问题；sklearnAPI分别封装了分类函数与回归函数；