xgboost_xgboosting - CSDN
xgboost 订阅
XGBoost是一个优化的分布式梯度增强库,旨在实现高效,灵活和便携。它在 Gradient Boosting 框架下实现机器学习算法。XGBoost提供并行树提升(也称为GBDT,GBM),可以快速准确地解决许多数据科学问题。相同的代码在主要的分布式环境(Hadoop,SGE,MPI)上运行,并且可以解决数十亿个示例之外的问题。 [1] 展开全文
XGBoost是一个优化的分布式梯度增强库,旨在实现高效,灵活和便携。它在 Gradient Boosting 框架下实现机器学习算法。XGBoost提供并行树提升(也称为GBDT,GBM),可以快速准确地解决许多数据科学问题。相同的代码在主要的分布式环境(Hadoop,SGE,MPI)上运行,并且可以解决数十亿个示例之外的问题。 [1]
信息
外文名
XGBoost
易语言简介
XGBoost [2]  是对梯度提升算法的改进,求解损失函数极值时使用了牛顿法,将损失函数泰勒展开到二阶,另外损失函数中加入了正则化项。训练时的目标函数由两部分构成,第一部分为梯度提升算法损失,第二部分为正则化项。损失函数定义为 [2]  其中n为训练函数样本数,l是对单个样本的损失,假设它为凸函数, 为模型对训练样本的预测值, 为训练样本的真实标签值。正则化项定义了模型的复杂程度: 其中, 和 为人工设置的参数,w为决策树所有叶子节点值形成的向量,T为叶子节点数。正则化项
收起全文
精华内容
参与话题
  • xgboost入门与实战(原理篇)

    万次阅读 多人点赞 2018-01-03 17:24:08
    xgboost入门与实战(原理篇)前言: xgboost是大规模并行boosted tree的工具,它是目前最快最好的开源boosted tree工具包,比常见的工具包快10倍以上。在数据科学方面,有大量kaggle选手选用它进行数据挖掘比赛,...

    xgboost入门与实战(原理篇)

    前言:

    xgboost是大规模并行boosted tree的工具,它是目前最快最好的开源boosted tree工具包,比常见的工具包快10倍以上。在数据科学方面,有大量kaggle选手选用它进行数据挖掘比赛,其中包括两个以上kaggle比赛的夺冠方案。在工业界规模方面,xgboost的分布式版本有广泛的可移植性,支持在YARN, MPI, Sungrid Engine等各个平台上面运行,并且保留了单机并行版本的各种优化,使得它可以很好地解决于工业界规模的问题。

    花了几天时间粗略地看完了xgboost原论文和作者的slide讲解,仅仅是入门入门入门笔记。给我的感觉就是xgboost算法比较复杂,针对传统GBDT算法做了很多细节改进,包括损失函数、正则化、切分点查找算法优化、稀疏感知算法、并行化算法设计等等。本文主要介绍xgboost基本原理以及与传统gbdt算法对比总结,后续会基于python版本做了一些实战调参试验。想详细学习xgboost算法原理建议通读作者原始论文与slide讲解。

    相关文献资料:
    Xgboost Slides
    XGBoost中文版原理介绍
    原始论文XGBoost: A Scalable Tree Boosting System
    XGBoost Parameters (official guide)

    精彩博文:
    XGBoost浅入浅出——wepon
    xgboost: 速度快效果好的boosting模型
    Complete Guide to Parameter Tuning in XGBoost (with codes in Python)

    XGBoost Plotting API以及GBDT组合特征实践

    补充!LightGBM!:

    微软出了个LightGBM,号称性能更强劲,速度更快。简单实践了一波,发现收敛速度要快一些,不过调参还不6 ,没有权威。看了GitHub上的介绍以及知乎上的一些回答,大致理解了性能提升的原因。
    主要是两个:①histogram算法替换了传统的Pre-Sorted,某种意义上是牺牲了精度(但是作者声明实验发现精度影响不大)换取速度,直方图作差构建叶子直方图挺有创造力的。(xgboost的分布式实现也是基于直方图的,利于并行)②带有深度限制的按叶子生长 (leaf-wise) 算法代替了传统的(level-wise) 决策树生长策略,提升精度,同时避免过拟合危险。

    细节大家直接看作者的解释以及GitHub上的介绍吧,还是挺好理解的~
    链接:
    https://www.zhihu.com/question/51644470/answer/130946285
    https://github.com/Microsoft/LightGBM/wiki/Features

    一、xgboost基本原理介绍


    1.提升方法是一种非常有效的机器学习方法,在前几篇笔记中介绍了提升树与GBDT基本原理,xgboost(eXtreme Gradient Boosting)可以说是提升方法的完全加强版本。xgboost算法在各大比赛中展现了强大的威力。

    2.Regression Tree and Ensemble (What are we Learning,得到学习目标)
    (1).Regression Tree (CART)回归树

    (2).Regression Tree Ensemble 回归树集成

    在上面的例子中,我们用两棵树来进行预测。我们对于每个样本的预测结果就是每棵树预测分数的和。

    (3).Objective for Tree Ensemble 得到学习目标函数

    这里是构造一个目标函数,然后我们要做的就是去尝试优化这个目标函数。读到这里,感觉与gbdt好像没有什么区别,确实如此,不过在后面就能看到他们的不同了(构造(学习)模型参数)。

    3.Gradient Boosting (How do we Learn,如何学习)
    (1).So How do we Learn?
    目标函数:

    We can not use methods such as SGD, to find f (since they are
    trees, instead of just numerical vectors)
    Solution: Additive Training (Boosting)
    Start from constant prediction, add a new function each time

    这里理解很关键,这里目标函数优化的是整体的模型,yi’是整个累加模型的输出,正则化项是所有树的复杂度之和,这个复杂度组成后面(6)会讲。这种包含树的模型不适合直接用SGD等优化算法直接对整体模型进行优化,因而采用加法学习方法,boosting的学习策略是每次学习当前的树,找到当前最佳的树模型加入到整体模型中,因此关键在于学习第t棵树。
    (2).Additive Training :定义目标函数,优化,寻找最佳的ft。

    • How do we decide which f to add?
     Optimize the objective!! 目标优化

    如图所示,第t轮的模型预测等于前t-1轮的模型预测y(t-1)加上ft,因此误差函数项记为l(yi,y(t-1)+ft),后面一项为正则化项。
    在当前步,yi以及y(t-1)都是已知值,模型学习的是ft。
    (3).Taylor Expansion Approximation of Loss 对误差函数进行二阶泰勒近似展开

    把平方损失函数的一二次项带入原目标函数,你会发现与之前那张ppt的损失函数是一致的 。
    至于为什么要这样展开呢,这里就是xgboost的特点了,通过这种近似,你可以自定义一些损失函数(只要保证二阶可导),树分裂的打分函数是基于gi,hi(Gj,Hj)计算的。

    (4).Our New Goal 得到了新的目标函数

    从这里就可以看出xgboost的不同了,目标函数保留了泰勒展开的二次项。

    这里写图片描述

    (5).Refine the definition of tree 重新定义每棵树

    • We define tree by a vector of scores in leafs, and a leaf index
    用叶子节点集合以及叶子节点得分表示
    mapping function that maps an instance to a leaf
    每个样本都落在一个叶子节点上
    q(x)表示样本x在某个叶子节点上,wq(x)是该节点的打分,即该样本的模型预测值。

    (6).Define the Complexity of Tree 树的复杂度项

    • Define complexity as (this is not the only possible definition)

    从图中可以看出,xgboost算法中对树的复杂度项包含了两个部分,一个是叶子节点总数,一个是叶子节点得分L2正则化项,针对每个叶结点的得分增加L2平滑,目的也是为了避免过拟合。

    (7).Revisit the Objectives 更新

    注意,这里优化目标的n->T,T是叶子数。???
    论文中定义了:Define I j = {i|q(x i ) = j} as the instance set of leaf j.这一步是由于xgb加了两个正则项,一个是叶子节点个数(T),一个是叶节点分数(w). 原文中的等式4,加了正则项的目标函数里就出现了两种累加,一种是i->n(样本数),一种是j->T(叶子节点数)。这步转换是为了统一目标函数中的累加项,Ij是每个叶节点j上的样本集合。

    (8).The Structure Score 这个score是用来评价树结构的。根据目标函数得到(见论文公式(4)、(5)、(6)),用于切分点查找算法。
    这里写图片描述

    这里写图片描述
    The Structure Score Calculation:

    (9)切分点查找算法


    如上图可见Gain还加了一个叶子节点复杂度项,有点类似CART的剪枝。

    这里写图片描述
    上图中G都是各自区域内的gi总和,根据Gain(max)选择最优分割点。此外,作者针对算法设计对特征进行了排序,分位点划分等,有兴趣的可以阅读原始论文,这里不做详解。

    算法步骤:
    这里写图片描述

    根据特征划分有无数可能的树结构,因此采用近似算法(特征分位点,候选分割点)
    这里写图片描述
    (10)小结一下: Boosted Tree Algorithm

    二、xgboost特点(与gbdt对比)


    说明一下:这部分内容参考了知乎上的一个问答—机器学习算法中GBDT和XGBOOST的区别有哪些?,答主是wepon大神,根据他的总结我自己做了一理解和补充。

    1.传统GBDT以CART作为基分类器,xgboost还支持线性分类器,这个时候xgboost相当于带L1和L2正则化项的逻辑斯蒂回归(分类问题)或者线性回归(回归问题)。 —可以通过booster [default=gbtree]设置参数:gbtree: tree-based models/gblinear: linear models

    2.传统GBDT在优化时只用到一阶导数信息,xgboost则对代价函数进行了二阶泰勒展开,同时用到了一阶和二阶导数。顺便提一下,xgboost工具支持自定义代价函数,只要函数可一阶和二阶求导。 —对损失函数做了改进(泰勒展开,一阶信息g和二阶信息h,上一章节有做介绍)

    3.xgboost在代价函数里加入了正则项,用于控制模型的复杂度。正则项里包含了树的叶子节点个数、每个叶子节点上输出的score的L2模的平方和。从Bias-variance tradeoff角度来讲,正则项降低了模型variance,使学习出来的模型更加简单,防止过拟合,这也是xgboost优于传统GBDT的一个特性
    —正则化包括了两个部分,都是为了防止过拟合,剪枝是都有的,叶子结点输出L2平滑是新增的。

    4.shrinkage and column subsampling —还是为了防止过拟合,论文2.3节有介绍,这里答主已概括的非常到位

    (1)shrinkage缩减类似于学习速率,在每一步tree boosting之后增加了一个参数n(权重),通过这种方式来减小每棵树的影响力,给后面的树提供空间去优化模型。

    (2)column subsampling列(特征)抽样,说是从随机森林那边学习来的,防止过拟合的效果比传统的行抽样还好(行抽样功能也有),并且有利于后面提到的并行化处理算法。

    5.split finding algorithms(划分点查找算法):—理解的还不够透彻,需要进一步学习
    (1)exact greedy algorithm—贪心算法获取最优切分点
    (2)approximate algorithm— 近似算法,提出了候选分割点概念,先通过直方图算法获得候选分割点的分布情况,然后根据候选分割点将连续的特征信息映射到不同的buckets中,并统计汇总信息。详细见论文3.3节
    (3)Weighted Quantile Sketch—分布式加权直方图算法,论文3.4节
    这里的算法(2)、(3)是为了解决数据无法一次载入内存或者在分布式情况下算法(1)效率低的问题,以下引用的还是wepon大神的总结:

    可并行的近似直方图算法。树节点在进行分裂时,我们需要计算每个特征的每个分割点对应的增益,即用贪心法枚举所有可能的分割点。当数据无法一次载入内存或者在分布式情况下,贪心算法效率就会变得很低,所以xgboost还提出了一种可并行的近似直方图算法,用于高效地生成候选的分割点。

    6.对缺失值的处理。对于特征的值有缺失的样本,xgboost可以自动学习出它的分裂方向。 —稀疏感知算法,论文3.4节,Algorithm 3: Sparsity-aware Split Finding

    7.Built-in Cross-Validation(内置交叉验证)

    XGBoost allows user to run a cross-validation at each iteration of the boosting process and thus it is easy to get the exact optimum number of boosting iterations in a single run.
    This is unlike GBM where we have to run a grid-search and only a limited values can be tested.

    8.continue on Existing Model(接着已有模型学习)

    User can start training an XGBoost model from its last iteration of previous run. This can be of significant advantage in certain specific applications.
    GBM implementation of sklearn also has this feature so they are even on this point.

    9.High Flexibility(高灵活性)

    **XGBoost allow users to define custom optimization objectives and evaluation criteria.
    This adds a whole new dimension to the model and there is no limit to what we can do.**

    10.并行化处理 —系统设计模块,块结构设计等

    xgboost工具支持并行。boosting不是一种串行的结构吗?怎么并行的?注意xgboost的并行不是tree粒度的并行,xgboost也是一次迭代完才能进行下一次迭代的(第t次迭代的代价函数里包含了前面t-1次迭代的预测值)。xgboost的并行是在特征粒度上的。我们知道,决策树的学习最耗时的一个步骤就是对特征的值进行排序(因为要确定最佳分割点),xgboost在训练之前,预先对数据进行了排序,然后保存为block结构,后面的迭代中重复地使用这个结构,大大减小计算量。这个block结构也使得并行成为了可能,在进行节点的分裂时,需要计算每个特征的增益,最终选增益最大的那个特征去做分裂,那么各个特征的增益计算就可以开多线程进行。

    此外xgboost还设计了高速缓存压缩感知算法,这是系统设计模块的效率提升。
    当梯度统计不适合于处理器高速缓存和高速缓存丢失时,会大大减慢切分点查找算法的速度。
    (1)针对 exact greedy algorithm采用缓存感知预取算法
    (2)针对 approximate algorithms选择合适的块大小

    我觉得关于xgboost并行化设计仅仅从论文PPT博客上学习是远远不够的,有时间还要从代码层面去学习分布式 xgboost的设计理念。

    三、xgboost参数详解


    官方参数介绍看这里:
    Parameters (official guide)

    General Parameters(常规参数)
    1.booster [default=gbtree]:选择基分类器,gbtree: tree-based models/gblinear: linear models
    2.silent [default=0]:设置成1则没有运行信息输出,最好是设置为0.
    3.nthread [default to maximum number of threads available if not set]:线程数

    Booster Parameters(模型参数)
    1.eta [default=0.3]:shrinkage参数,用于更新叶子节点权重时,乘以该系数,避免步长过大。参数值越大,越可能无法收敛。把学习率 eta 设置的小一些,小学习率可以使得后面的学习更加仔细。
    2.min_child_weight [default=1]:这个参数默认是 1,是每个叶子里面 h 的和至少是多少,对正负样本不均衡时的 0-1 分类而言,假设 h 在 0.01 附近,min_child_weight 为 1 意味着叶子节点中最少需要包含 100 个样本。这个参数非常影响结果,控制叶子节点中二阶导的和的最小值,该参数值越小,越容易 overfitting。
    3.max_depth [default=6]: 每颗树的最大深度,树高越深,越容易过拟合。
    4.max_leaf_nodes:最大叶结点数,与max_depth作用有点重合。
    5.gamma [default=0]:后剪枝时,用于控制是否后剪枝的参数。
    6.max_delta_step [default=0]:这个参数在更新步骤中起作用,如果取0表示没有约束,如果取正值则使得更新步骤更加保守。可以防止做太大的更新步子,使更新更加平缓。
    7.subsample [default=1]:样本随机采样,较低的值使得算法更加保守,防止过拟合,但是太小的值也会造成欠拟合。
    8.colsample_bytree [default=1]:列采样,对每棵树的生成用的特征进行列采样.一般设置为: 0.5-1
    9.lambda [default=1]:控制模型复杂度的权重值的L2正则化项参数,参数越大,模型越不容易过拟合。
    10.alpha [default=0]:控制模型复杂程度的权重值的 L1 正则项参数,参数值越大,模型越不容易过拟合。
    11.scale_pos_weight [default=1]:如果取值大于0的话,在类别样本不平衡的情况下有助于快速收敛。

    Learning Task Parameters(学习任务参数)
    1.objective [default=reg:linear]:定义最小化损失函数类型,常用参数:
    binary:logistic –logistic regression for binary classification, returns predicted probability (not class)
    multi:softmax –multiclass classification using the softmax objective, returns predicted class (not probabilities)
    you also need to set an additional num_class (number of classes) parameter defining the number of unique classes
    multi:softprob –same as softmax, but returns predicted probability of each data point belonging to each class.
    2.eval_metric [ default according to objective ]
    The metric to be used for validation data.
    The default values are rmse for regression and error for classification.
    Typical values are:
    rmse – root mean square error
    mae – mean absolute error
    logloss – negative log-likelihood
    error – Binary classification error rate (0.5 threshold)
    merror – Multiclass classification error rate
    mlogloss – Multiclass logloss
    auc: Area under the curve
    3.seed [default=0]
    The random number seed. 随机种子,用于产生可复现的结果
    Can be used for generating reproducible results and also for parameter tuning.

    注意: python sklearn style参数名会有所变化
    eta –> learning_rate
    lambda –> reg_lambda
    alpha –> reg_alpha

    四、实战


    官方样例:
    XGBoost Python API Reference (official guide)
    XGBoost Demo Codes (xgboost GitHub repository)

    xgboost参数设置代码示例:

    # 划分数据集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.01, random_state=1729)
    print(X_train.shape, X_test.shape)
    
    #模型参数设置
    xlf = xgb.XGBRegressor(max_depth=10, 
                            learning_rate=0.1, 
                            n_estimators=10, 
                            silent=True, 
                            objective='reg:linear', 
                            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=1440, 
                            missing=None)
    
    xlf.fit(X_train, y_train, eval_metric='rmse', verbose = True, eval_set = [(X_test, y_test)],early_stopping_rounds=100)
    
    # 计算 auc 分数、预测
    preds = xlf.predict(X_test)

    实战待续…

    展开全文
  • 本文通过XGBoost的算法思想到XGBoost的目标函数转换,通过泰勒公式和叶节点的角度对XGBoost目标函数进行转换,然后通过树结构的生成策略去生成每一颗模型树,最后讲解于GBDT的算法区别以及相关参数。 目录如下: ...
  • 二、XGBoost基本思想 三、MacOS安装XGBoost 四、用python实现XGBoost算法 在竞赛题中经常会用到XGBoost算法,用这个算法通常会使我们模型的准确率有一个较大的提升。既然它效果这么好,那么它从头到尾做了一件...

    目录

    一、集成算法思想

    二、XGBoost基本思想

    三、MacOS安装XGBoost

    四、用python实现XGBoost算法


    竞赛题中经常会用到XGBoost算法,用这个算法通常会使我们模型的准确率有一个较大的提升。既然它效果这么好,那么它从头到尾做了一件什么事呢?以及它是怎么样去做的呢?

    我们先来直观的理解一下什么是XGBoost。XGBoost算法是和决策树算法联系到一起的。决策树算法在我的另一篇博客中讲过了.

    一、集成算法思想

    在决策树中,我们知道一个样本往左边分或者往右边分,最终到达叶子结点,这样来进行一个分类任务。 其实也可以做回归任务。

    看上面一个图例左边:有5个样本,现在想看下这5个人愿不愿意去玩游戏,这5个人现在都分到了叶子结点里面,对不同的叶子结点分配不同的权重项,正数代表这个人愿意去玩游戏,负数代表这个人不愿意去玩游戏。所以我们可以通过叶子结点和权值的结合,来综合的评判当前这个人到底是愿意还是不愿意去玩游戏。上面「tree1」那个小男孩它所处的叶子结点的权值是+2(可以理解为得分)。

    用单个决策树好像效果一般来说不是太好,或者说可能会太绝对。通常我们会用一种集成的方法,就是一棵树效果可能不太好,用两棵树呢?

    看图例右边的「tree2」,它和左边的不同在于它使用了另外的指标,出了年龄和性别,还可以考虑使用电脑频率这个划分属性。通过这两棵树共同帮我们决策当前这个人愿不愿意玩游戏,小男孩在「tree1」的权值是+2,在「tree2」的权值是+0.9, 所以小男孩最终的权值是+2.9(可以理解为得分是+2.9)。老爷爷最终的权值也是通过一样的过程得到的。

    所以说,我们通常在做分类或者回归任务的时候,需要想一想一旦选择用一个分类器可能表达效果并不是很好,那么就要考虑用这样一个集成的思想。上面的图例只是举了两个分类器,其实还可以有更多更复杂的弱分类器,一起组合成一个强分类器

     

    二、XGBoost基本思想

    XGBoost的集成表示是什么?怎么预测?求最优解的目标是什么?看下图的说明你就能一目了然。

    600

    在XGBoost里,每棵树是一个一个往里面加的,每加一个都是希望效果能够提升,下图就是XGBoost这个集成的表示(核心)。

    一开始树是0,然后往里面加树,相当于多了一个函数,再加第二棵树,相当于又多了一个函数...等等,这里需要保证加入新的函数能够提升整体对表达效果。提升表达效果的意思就是说加上新的树之后,目标函数(就是损失)的值会下降。

    如果叶子结点的个数太多,那么过拟合的风险会越大,所以这里要限制叶子结点的个数,所以在原来目标函数里要加上一个惩罚项「omega(ft)」。

     

    这里举个简单的例子看看惩罚项「omega(ft)」是如何计算的:

    一共3个叶子结点,权重分别是2,0.1,-1,带入「omega(ft)」中就得到上面图例的式子,惩罚力度和「lambda」的值人为给定。

    XGBoost算法完整的目标函数见下面这个公式,它由自身的损失函数正则化惩罚项「omega(ft)」相加而成。

    关于目标函数的推导本文章不作详细介绍。过程就是:给目标函数对权重求偏导,得到一个能够使目标函数最小的权重,把这个权重代回到目标函数中,这个回代结果就是求解后的最小目标函数值,如下:

    其中第三个式子中的一阶导二阶导的梯度数据都是可以算出来的,只要指定了主函数中的两个参数,这就是一个确定的值。下面给出一个直观的例子来看下这个过程。

    (这里多说一句:Obj代表了当我们指定一个树的结构的时候,在目标上最多会减少多少,我们可以把它叫做结构分数,这个分数越小越好)

    对于每次扩展,我们依旧要枚举所有可能的方案。对于某个特定的分割,我们要计算出这个分割的左子树的导数和和右子数导数和之和(就是下图中的第一个红色方框),然后和划分前的进行比较(基于损失,看分割后的损失和分割前的损失有没有发生变化,变化了多少)。遍历所有分割,选择变化最大的作为最合适的分割。

     

    三、MacOS安装XGBoost

    用pip安装XGBoost

    第一步, 安装HomeBrew.

    /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

    HomeBrew是Mac的一个包管理软件, 类似于Linux里面的apt-get

    第二步, 安装llvm

    brew install llvm

    第三步,安装clang-omp

    brew install clang-omp

    有人提到clang-omp已经从HomeBrew移除了, 如果找不到clang-omp可以尝试

    brew install --with-clang llvm 

    第四步,安装XGBoost

    pip install xgboost

    测试一下,大功告成!

     

    四、用python实现XGBoost算法

    pima-indians-diabetes.csv文件中包括了8列数值型自变量,和第9列0-1的二分类因变量,导入到python中用XGBoost算法做探索性尝试,得到预测数据的准确率为77.95%。

    import xgboost
    from numpy import loadtxt
    from xgboost import XGBClassifier
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    
    # 载入数据集
    dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
    # split data into X and y
    X = dataset[:,0:8]
    Y = dataset[:,8]
    
    # 把数据集拆分成训练集和测试集
    seed = 7
    test_size = 0.33
    X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)
    
    # 拟合XGBoost模型
    model = XGBClassifier()
    model.fit(X_train, y_train)
    
    # 对测试集做预测
    y_pred = model.predict(X_test)
    predictions = [round(value) for value in y_pred]
    
    # 评估预测结果
    accuracy = accuracy_score(y_test, predictions)
    print("Accuracy: %.2f%%" % (accuracy * 100.0))

    结果输出:

    Accuracy: 77.95%

    在python的XGBoost包中最重要的函数是XGBClassifier(),函数中涉及到多种参数,此外还可以关注plot_importance(),更多的说明我将在以后进行更新。

     

     

    展开全文
  • XGBoost的基本原理

    万次阅读 2018-08-20 13:04:53
    XGBoost原理与实践

    说明:本文是阅读XGBoost有关的论文和一些博客后的入门笔记。有什么不足之处还望大家多多赐教,欢迎交流,转载。

    一. 前言

  • XGBoost是提升方法中的一个可扩展的机器学习系统。XGBoost在许多机器学习和数据挖掘问题中产生了广泛的影响。2015年发表在Kaggle竞赛的博客的29个冠军解决方案中,有17个是使用XGBoost解决的,其中有8个是仅使用了XGBoost方法去训练模型,剩余的是用XGBoost和其他模型相结合使用的。相比较而言,第二个受欢迎的方法是深度神经网络,有11个是使用该方法的。
  • XGBoost成功的最重要因素就是它在任何场景下的可扩展性。XGBoost系统在单台机器上的运行速度比现有流行的解决方案快10倍以上,并可在分布式或内存限制设置中扩展到数十亿个示例。XGBoost的可扩展性是由于在它的系统实现中的一些创新,包括:
    1. 为处理稀疏数据使用了一个新颖的树学习算法;
    2. 理论上合理的加权分位数草图过程,使得能够在近似树学习中处理实例权重;
    3. 平行和分布式计算使得学习更快,从而能够更快的进行模型探索;
    4. 最重要的是XGBoost使用核外计算并且能够让数据科学家在台式机上处理数以亿计的示例;
    5. 更令人兴奋的是结合这些技术使端到端系统以最少的集群资源扩展到更大的数据。
    下面开始介绍XGBoost的模型训练原理
  • 二. XGBoost原理

    1. 学习目标

    在讨论学习目标之前,先说一说XGBoost是如何预测输出值的。XGBoost是一个树集成模型,它使用的是K(树的总数为K)个树的每棵树对样本的预测值的和作为该样本在XGBoost系统中的预测,定义函数如下:
    这里写图片描述
    对于所给的数据集有n个样本,m个特征,定义为:
    这里写图片描述
    其中Xi表示第i个样本,yi表示第i个样本的类别标签。CART树的空间为F,如下:
    这里写图片描述
    其中q表示每棵树的结构映射每个样本到相应的叶节点的分数,即q表示树的模型,输入一个样本,根据模型将样本映射到叶节点输出预测的分数;Wq(x)表示树q的所有叶节点的分数组成集合;T是树q的叶节点数量。
    所以,由(1)式可以看出,XGBoost的预测值为每棵树的预测值之和,即每棵树相应的叶节点的得分之和(Wi的和,Wi表示第i个叶节点的得分)。
    我们的目标就是学习这样的K个树模型f(x).。为了学习模型f(x),我们定义下面的目标函数:
    这里写图片描述
    这里写图片描述
    其中,(2)式右边第一项为损失函数项,即训练误差,是一个可微的凸函数(比如用于回归的均方误差和用于分类的Logistic误差函数等),第二项为正则化项,即每棵树的复杂度之和,目的是控制模型的复杂度,防止过拟合。我们的目标是在L(φ)取得最小化时得出对应的模型f(x)。
    由于XGBoost模型中的优化参数是模型f(x),不是一个具体的值,所以不能用传统的优化方法在欧式空间中进行优化,而是采用additive training的方式去学习模型。每一次保留原来的模型不变,加入一个新的函数f到模型中,如下:
    这里写图片描述
    预测值在每一次迭代中加入一个新的函数f目的是使目标函数尽量最大地降低。
    因为我们的目标是最小化L(φ)时得到模型f(x),但是L(φ)中并没有参数f(x),所以,我们将上图中的最后一式代入L(φ)中可得到如下式子:
    这里写图片描述
    对于平方误差(用于回归)来说(3)式转换成如下形式:
    这里写图片描述
    对于不是平方误差的情况下,一般会采用泰勒展开式来定义一个近似的目标函数,以方便我们的进一步计算。
    根据如下的泰勒展开式,移除高阶无穷小项,得:
    这里写图片描述
    这里写图片描述
    (3)式等价于下面的式子:
    这里写图片描述
    由于我们的目标是求L(φ)最小化时的模型f(x)(也是变量),当移除常数项时模型的最小值变化,但是取最小值的变量不变(比如:y=x^2+C,无论C去何值,x都在0处取最小值)。所以,为了简化计算,我们移除常数项,得到如下的目标函数:
    这里写图片描述
    定义 这里写图片描述 为叶节点j的实例,重写(4)式,将关于树模型的迭代转换为关于树的叶子节点的迭代,得到如下过程:
    这里写图片描述
    此时我们的目标是求每棵树的叶节点j的分数Wj,求出Wj后,将每棵树的Wj相加,即可得到最终的预测的分数。而要想得到最优的Wj的值,即最小化我们的目标函数,所以上式对Wj求偏导,并令偏导数为0,算出此时的W*j为:
    这里写图片描述
    这里写图片描述
    将W*j代入原式得:
    这里写图片描述
    方程(5)可以用作得分(score)函数来测量树结构q的质量。该得分类似于评估决策树的不纯度得分,除了它是针对更广泛的目标函数得出的。下图表示得分(score)是如何被计算的:
    这里写图片描述
    由上图可以看出,当我们指定一颗树的结构的时候,每棵树的得分(score)只与损失函数的一阶导数和二阶倒数相关(γ和λ是在实际应用中需要自己调参的),而该得分表示我们在目标上面最多减少多少。我们可以把它叫做结构分数(structure score)。你可以认为这个就是类似吉尼系数一样更加一般的对于树结构进行打分的函数。
    到这里,我们的XGBoost学习目标的原理已经介绍完毕,接下来就是如何进行节点的切分了。

    2. 节点的划分

    树学习的其中之一的重要问题就是找到最好的节点划分,而节点划分的目的是寻找一个最优结构的树。假设IL和IR是一个节点切分后的左右节点,I等于IL和IR的并集。然后切分后的损失函数定义如下:
    这里写图片描述
    上面的式子通常在实践中被使用来评估切分的候选节点。我们的目标是希望找到一个特征及其对应的大小,使得上式取得最大值。
    节点划分有两种方式,一是基本精确的贪心算法(Basic Exact Greedy Algorithm),二是近似算法(Approximate Algorithm)。下面我们来分别介绍这两种方式。

    2.1 基本精确的贪心算法(Basic Exact Greedy Algorithm)

    为了找到节点最好的划分,该算法的原理是在所有特征上枚举所有的可能的划分,我们称这个算法为Basic Exact Greedy Algorithm。大多数已存在的单台机器上的树提升算法库都是用这种方法实现的,例如scikit-learn,R’s gbm 以及 XGBoost的单机版本都支持这种算法。该算法要求为连续特征枚举所有可能的切分,这对计算机的要求很高,所以该算法为了有效的做到这一点,首先根据特征值排序数据并且按照顺序访问数据,以累积方程(6)中结构分数的梯度统计量。该算法如下:
    这里写图片描述

    2.2 近似算法

    Basic Exact Greedy Algorithm是一个非常精确的算法,因为它枚举的所有可能的切分点。但是,当数据不能完全的加载到内存时,它可能不是特别有效地。同样的问题也出现在分布式的设置中。为了有效的支持在这两种设置中的有效的梯度提升,一个近似算法需要被使用。该算法首先根据特征分布的百分位数提出n个候选切分节点,然后,算法将位于相邻分位点之间的样本分在一个桶中,在遍历该特征的时候,只需要遍历各个分位点,从而计算最优划分。注意到上面算法流程中表明有全局的近似(global)和局部(local)的近似,所谓全局就是在新生成一棵树之前就对各个特征计算分位点并划分样本,之后在每次分裂过程中都采用近似划分,而局部就是在具体的某一次分裂节点的过程中采用近似算法。该算法如下所示:
    这里写图片描述
    以上两个算法都应用在了XGBoost中。
    接下来,最后一个问题就是近似算法中的如何根据分位数来提出候选切分点。

    2.3 带权重的分位数草图(Weighted Quantile Sketch)

    Weighted Quantile Sketch是近似算法中的一个重要步骤,主要用于解决近似算法中如何选取候选切分点的问题。通常,特征的百分位数用于使候选节点均匀地分布在数据上。也就是在特征集上选取一个百分数,然后根据这个百分数来依次的选取候选节点。比如某个特征的样本点是1~100,特征的百分位数设为2%,则候选节点的选择就是100*0.02*1=2,4,…,100。用数学公式表示,定义一个rank function,如下:
    这里写图片描述
    上式表示特征值k小于z的实例的比例。其中:
    这里写图片描述
    表示每个训练样本的第k个特征值和二阶梯度值。
    这里写图片描述
    其中ε是近似因子,也就是切分百分数。这意味着大概有1/ε个候选切分点。
    到这里,XGBoost的理论部分已经介绍完毕。有不足之处希望指出,一起学习。接下来就是介绍XGBoost的一些优缺点。

    三. XGBoost的优缺点:

    3.1 与GBDT相比:

    1)GBDT以传统CART作为基分类器,而XGBoost支持线性分类器,相当于引入L1和L2正则化项的逻辑回归(分类问题)和线性回归(回归问题);

    2)GBDT在优化时只用到一阶导数,XGBoost对代价函数做了二阶Talor展开,引入了一阶导数和二阶导数。XGBoost支持自定义的损失函数,只要是能满足二阶连续可导的函数均可以作为损失函数;

    3)XGBoost在损失函数中引入正则化项,用于控制模型的复杂度。正则化项包含全部叶子节点的个数,每个叶子节点输出的score的L2模的平方和。从Bias-variance tradeoff角度考虑,正则项降低了模型的方差,防止模型过拟合,这也是xgboost优于传统GBDT的一个特性。

    4)当样本存在缺失值是,xgBoosting能自动学习分裂方向,即XGBoost对样本缺失值不敏感;

    5)XGBoost借鉴RF的做法,支持列抽样,这样不仅能防止过拟合,还能降低计算,这也是xgboost异于传统gbdt的一个特性。

    6)XGBoost在每次迭代之后,会将叶子节点的权重乘上一个学习率(相当于XGBoost中的eta,论文中的Shrinkage),主要是为了削弱每棵树的影响,让后面有更大的学习空间。实际应用中,一般把eta设置得小一点,然后迭代次数设置得大一点;

    7)XGBoost工具支持并行,但并行不是tree粒度的并行,XGBoost也是一次迭代完才能进行下一次迭代的(第t次迭代的代价函数里包含了前面t-1次迭代的预测值),XGBoost的并行是在特征粒度上的。XGBoost在训练之前,预先对数据进行了排序,然后保存为(block)结构,后面的迭代中重复地使用这个结构,大大减小计算量。这个块结构也使得并行成为了可能,在进行节点的分裂时,需要计算每个特征的增益,最终选增益最大的那个特征去做分裂,那么各个特征的增益计算就可以开多线程进行;

    8)可并行的近似直方图算法,树结点在进行分裂时,需要计算每个节点的增益,若数据量较大,对所有节点的特征进行排序,遍历的得到最优分割点,这种贪心法异常耗时,这时引进近似直方图算法,用于生成高效的分割点,即用分裂后的某种值减去分裂前的某种值,获得增益,为了限制树的增长,引入阈值,当增益大于阈值时,进行分裂;

    9) XGBoost的原生语言为C/C++,这是也是它训练速度快的一个原因。

    3.2 与LightGBM相比:

    1)XGBoost采用预排序,在迭代之前,对结点的特征做预排序,遍历选择最优分割点,数据量大时,贪心法耗时,LightGBM方法采用histogram算法,占用的内存低,数据分割的复杂度更低,但是不能找到最精确的数据分割点;

    2)XGBoost采用level-wise生成决策树策略,同时分裂同一层的叶子,从而进行多线程优化,不容易过拟合,但很多叶子节点的分裂增益较低,没必要进行更进一步的分裂,这就带来了不必要的开销;LightGBM采用leaf-wise生长策略,每次从当前叶子中选择增益最大的叶子进行分裂,如此循环,但会生长出更深的决策树,产生过拟合,因此 LightGBM 在leaf-wise之上增加了一个最大深度的限制,在保证高效率的同时防止过拟合)。另一个比较巧妙的优化是 histogram 做差加速。一个容易观察到的现象:一个叶子的直方图可以由它的父亲节点的直方图与它兄弟的直方图做差得到。

    四. 参考文献/博文

    1. XGBoost: A Scalable Tree Boosting System(XGBoost原论文)
    2. 陈天奇的XGBoost ppt
    3. https://blog.csdn.net/xwd18280820053/article/details/68927422
    4. http://www.52cs.org/?p=429
    展开全文
  • python机器学习库xgboost——xgboost算法

    万次阅读 多人点赞 2020-03-30 22:23:44
    xgboost目前还不能pip在线安装,所以先在网址https://www.lfd.uci.edu/~gohlke/pythonlibs/#xgboost 中下载whl文件,然后参考https://blog.csdn.net/luanpeng825485697/article/details/7781...

    分享一个朋友的人工智能教程。零基础!通俗易懂!风趣幽默!还带黄段子!大家可以看看是否对自己有帮助:点击打开

    docker/kubernetes入门视频教程


    全栈工程师开发手册 (作者:栾鹏)
    python数据挖掘系列教程

    安装

    xgboost目前还不能pip在线安装,所以先在网址https://www.lfd.uci.edu/~gohlke/pythonlibs/#xgboost 中下载whl文件,然后参考https://blog.csdn.net/luanpeng825485697/article/details/77816740 进行离线安装,就可以正常导入xgboost库了。

    更新:现在已经可以通过pip install xgboost在线安装库了。

    xgboost简介

    xgboost一般和sklearn一起使用,但是由于sklearn中没有集成xgboost,所以才需要单独下载安装。

    xgboost是在GBDT的基础上进行改进,使之更强大,适用于更大范围。

    1. XGBoost的优点

    2.1 正则化

    XGBoost在代价函数里加入了正则项,用于控制模型的复杂度。正则项里包含了树的叶子节点个数、每个叶子节点上输出的score的L2模的平方和。从Bias-variance tradeoff角度来讲,正则项降低了模型的variance,使学习出来的模型更加简单,防止过拟合,这也是xgboost优于传统GBDT的一个特性。

    2.2 并行处理

    XGBoost工具支持并行。Boosting不是一种串行的结构吗?怎么并行的?注意XGBoost的并行不是tree粒度的并行,XGBoost也是一次迭代完才能进行下一次迭代的(第t次迭代的代价函数里包含了前面t-1次迭代的预测值)。XGBoost的并行是在特征粒度上的。

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

    2.3 灵活性

    XGBoost支持用户自定义目标函数和评估函数,只要目标函数二阶可导就行。

    2.4 缺失值处理

    对于特征的值有缺失的样本,xgboost可以自动学习出它的分裂方向

    2.5 剪枝

    XGBoost 先从顶到底建立所有可以建立的子树,再从底到顶反向进行剪枝。比起GBM,这样不容易陷入局部最优解。

    2.6 内置交叉验证

    XGBoost允许在每一轮boosting迭代中使用交叉验证。因此,可以方便地获得最优boosting迭代次数。而GBM使用网格搜索,只能检测有限个值。

    1. XGBoost详解

    3.1 数据格式

    XGBoost可以加载多种数据格式的训练数据:

    libsvm 格式的文本数据;

    Numpy 的二维数组;

    XGBoost 的二进制的缓存文件。加载的数据存储在对象 DMatrix 中。

    下面一一列举:

    加载libsvm格式的数据

     dtrain1 = xgb.DMatrix('train.svm.txt')
    

    加载二进制的缓存文件

    dtrain2 = xgb.DMatrix('train.svm.buffer')
    

    加载numpy的数组

    data = np.random.rand(5,10) # 5行10列数据集
    label = np.random.randint(2, size=5) # 2分类目标值
    dtrain = xgb.DMatrix( data, label=label) # 组成训练集
    

    将scipy.sparse格式的数据转化为 DMatrix 格式

    csr = scipy.sparse.csr_matrix( (dat, (row,col)) )
    dtrain = xgb.DMatrix( csr )
    

    将 DMatrix 格式的数据保存成XGBoost的二进制格式,在下次加载时可以提高加载速度,使用方式如下

     dtrain = xgb.DMatrix('train.svm.txt')
    dtrain.save_binary("train.buffer")
    

    可以用如下方式处理 DMatrix中的缺失值:

    dtrain = xgb.DMatrix( data, label=label, missing = -999.0)
    

    当需要给样本设置权重时,可以用如下方式

    w = np.random.rand(5,1)
    dtrain = xgb.DMatrix( data, label=label, missing = -999.0, weight=w)
    

    3.2 参数设置

    XGBoost使用key-value字典的方式存储参数:

    params = {
        'booster': 'gbtree',
        'objective': 'multi:softmax',  # 多分类的问题
        'num_class': 10,               # 类别数,与 multisoftmax 并用
        'gamma': 0.1,                  # 用于控制是否后剪枝的参数,越大越保守,一般0.1、0.2这样子。
        'max_depth': 12,               # 构建树的深度,越大越容易过拟合
        'lambda': 2,                   # 控制模型复杂度的权重值的L2正则化项参数,参数越大,模型越不容易过拟合。
        'subsample': 0.7,              # 随机采样训练样本
        'colsample_bytree': 0.7,       # 生成树时进行的列采样
        'min_child_weight': 3,
        'silent': 1,                   # 设置成1则没有运行信息输出,最好是设置为0.
        'eta': 0.007,                  # 如同学习率
        'seed': 1000,
        'nthread': 4,                  # cpu 线程数
    }
    

    3.3 训练模型

    有了参数列表和数据就可以训练模型了

    num_round = 10
    bst = xgb.train( plst, dtrain, num_round, evallist )
    

    3.4 模型预测

    # X_test类型可以是二维List,也可以是numpy的数组
    dtest = DMatrix(X_test)
    ans = model.predict(dtest)
    

    3.5 保存模型

    在训练完成之后可以将模型保存下来,也可以查看模型内部的结构

     bst.save_model('test.model')
    

    导出模型和特征映射(Map)

    你可以导出模型到txt文件并浏览模型的含义:

    # 导出模型到文件
    bst.dump_model('dump.raw.txt')
    # 导出模型和特征映射
    bst.dump_model('dump.raw.txt','featmap.txt')
    

    3.6 加载模型

    通过如下方式可以加载模型:

    bst = xgb.Booster({'nthread':4}) # init model
    bst.load_model("model.bin")      # load data
    

    XGBoost参数详解

    在运行XGboost之前,必须设置三种类型成熟:general parameters,booster parameters和task parameters:

    通用参数 :该参数参数控制在提升(boosting)过程中使用哪种booster,常用的booster有树模型(tree)和线性模型(linear model)。

    Booster参数 :这取决于使用哪种booster。

    学习目标参数 :控制学习的场景,例如在回归问题中会使用不同的参数控制排序。

    4.1 通用参数

    booster [default=gbtree]:有两中模型可以选择gbtree和gblinear。gbtree使用基于树的模型进行提升计算,gblinear使用线性模型进行提升计算。缺省值为gbtree

    silent [default=0]:取0时表示打印出运行时信息,取1时表示以缄默方式运行,不打印运行时信息。缺省值为0

    nthread:XGBoost运行时的线程数。缺省值是当前系统可以获得的最大线程数

    num_pbuffer:预测缓冲区大小,通常设置为训练实例的数目。缓冲用于保存最后一步提升的预测结果,无需人为设置。

    num_feature:Boosting过程中用到的特征维数,设置为特征个数。XGBoost会自动设置,无需人为设置。

    4.2 tree booster参数

    eta [default=0.3] :为了防止过拟合,更新过程中用到的收缩步长。在每次提升计算之后,算法会直接获得新特征的权重。 eta通过缩减特征的权重使提升计算过程更加保守。缺省值为0.3
    取值范围为:[0,1]。典型值为0.01-0.2。

    gamma [default=0] :在节点分裂时,只有分裂后损失函数的值下降了,才会分裂这个节点。Gamma指定了节点分裂所需的最小损失函数下降值。
    这个参数的值越大,算法越保守。这个参数的值和损失函数息息相关,所以是需要调整的。
    取值范围为:[0,∞]

    max_depth [default=6] :数的最大深度。缺省值为6 。取值范围为:[1,∞]。需要使用CV函数来进行调优。典型值:3-10

    min_child_weight [default=1] :孩子节点中最小的样本权重和。如果一个叶子节点的样本权重和小于min_child_weight则拆分过程结束。在现行回归模型中,这个参数是指建立每个模型所需要的最小样本数。这个参数用于避免过拟合。当它的值较大时,可以避免模型学习到局部的特殊样本。
    但是如果这个值过高,会导致欠拟合。这个参数需要使用CV来调整。取值范围为:[0,∞]

    max_delta_step [default=0] :我们允许每个树的权重被估计的值。如果它的值被设置为0,意味着没有约束;如果它被设置为一个正值,它能够使得更新的步骤更加保守。通常这个参数是没有必要的,但是如果在逻辑回归中类极其不平衡这时候他有可能会起到帮助作用。把它范围设置为1-10之间也许能控制更新。 取值范围为:[0,∞]

    subsample [default=1] :用于训练模型的子样本占整个样本集合的比例。如果设置为0.5则意味着XGBoost将随机的从整个样本集合中随机的抽取出50%的子样本建立树模型,这能够防止过拟合。 取值范围为:(0,1]

    colsample_bytree [default=1] :在建立树时对特征采样的比例。缺省值为1 。取值范围为:(0,1]

    4.3 Linear Booster参数

    lambda [default=0] :L2 正则的惩罚系数

    alpha [default=0] :L1 正则的惩罚系数

    lambda_bias :在偏置上的L2正则。缺省值为0(在L1上没有偏置项的正则,因为L1时偏置不重要)

    4.4 学习目标参数

    objective [ default=reg:linear ] :定义学习任务及相应的学习目标,可选的目标函数如下:

    • “reg:linear” —— 线性回归。
    • “reg:logistic”—— 逻辑回归。
    • “binary:logistic”—— 二分类的逻辑回归问题,输出为概率。
    • “binary:logitraw”—— 二分类的逻辑回归问题,输出的结果为wTx。
    • “count:poisson”—— 计数问题的poisson回归,输出结果为poisson分布。在poisson回归中,max_delta_step的缺省值为0.7。(used to safeguard optimization)
    • “multi:softmax” –让XGBoost采用softmax目标函数处理多分类问题,同时需要设置参数num_class(类别个数)
    • “multi:softprob” –和softmax一样,但是输出的是ndata * nclass的向量,可以将该向量reshape成ndata行nclass列的矩阵。没行数据表示样本所属于每个类别的概率。
    • “rank:pairwise” –set XGBoost to do ranking task by minimizing the pairwise loss

    base_score [ default=0.5 ]

    所有实例的初始化预测分数,全局偏置;
    当有足够的迭代次数时,改变这个值将不会有太大的影响。

    eval_metric [ default according to objective ]

    校验数据所需要的评价指标,不同的目标函数将会有缺省的评价指标(rmse for regression, and error for classification, mean average precision for ranking)-

    用户可以添加多种评价指标,对于Python用户要以list传递参数对给程序,而不是map参数list参数不会覆盖’eval_metric’

    可供的选择如下:

    • rmse 均方根误差(∑i=1Nϵ2N\sqrt {\frac{\sum_{i=1}^Nϵ^2}{N}}Ni=1Nϵ2)
    • mae 平均绝对误差(∑i=1N∣ϵ∣N\frac{\sum_{i=1}^N|ϵ|}{N}Ni=1Nϵ)
    • logloss 负对数似然函数值
    • error 二分类错误率(阈值为0.5)
    • merror 多分类错误率
    • mlogloss 多分类logloss损失函数
    • auc 曲线下面积

    seed [ default=0 ]

    随机数的种子。缺省值为0

    xgboost 基本方法和默认参数

    函数原型:

    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,learning_rates=None,xgb_model=None)  
    

    params :这是一个字典,里面包含着训练中的参数关键字和对应的值,形式是params = {‘booster’:’gbtree’, ’eta’:0.1}
    dtrain :训练的数据
    num_boost_round :这是指提升迭代的个数
    evals :这是一个列表,用于对训练过程中进行评估列表中的元素。形式是evals = [(dtrain,’train’), (dval,’val’)]或者是evals = [ (dtrain,’train’)], 对于第一种情况,它使得我们可以在训练过程中观察验证集的效果。
    obj:自定义目的函数
    feval:自定义评估函数
    maximize: 是否对评估函数进行最大化
    early_stopping_rounds: 早期停止次数 ,假设为100,验证集的误差迭代到一定程度在100次内不能再继续降低,就停止迭代。这要求evals 里至少有一个元素,如果有多个,按最后一个去执行。返回的是最后的迭代次数(不是最好的)。如果early_stopping_rounds 存在,则模型会生成三个属性,bst.best_score, bst.best_iteration, 和bst.best_ntree_limit
    evals_result :字典,存储在watchlist 中的元素的评估结果。
    verbose_eval(可以输入布尔型或数值型):也要求evals 里至少有 一个元素。如果为True, 则对evals中元素的评估结果会输出在结果中;如果输入数字,假设为5,则每隔5个迭代输出一次。
    learning_rates :每一次提升的学习率的列表,
    xgb_model:在训练之前用于加载的xgb model。

    1. XGBoost实战

    XGBoost有两大类接口:XGBoost原生接口 和 scikit-learn接口 ,并且XGBoost能够实现 分类 和 回归 两种任务。因此,本章节分四个小块来介绍!

    5.1 基于XGBoost原生接口的分类

    # ================基于XGBoost原生接口的分类=============
    from sklearn.datasets import load_iris
    import xgboost as xgb
    from xgboost import plot_importance
    from matplotlib import pyplot as plt
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score   # 准确率
    # 加载样本数据集
    iris = load_iris()
    X,y = iris.data,iris.target
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234565) # 数据集分割
    
    # 算法参数
    params = {
        'booster': 'gbtree',
        'objective': 'multi:softmax',
        'num_class': 3,
        'gamma': 0.1,
        'max_depth': 6,
        'lambda': 2,
        'subsample': 0.7,
        'colsample_bytree': 0.7,
        'min_child_weight': 3,
        'silent': 1,
        'eta': 0.1,
        'seed': 1000,
        'nthread': 4,
    }
    
    plst = params.items()
    
    
    dtrain = xgb.DMatrix(X_train, y_train) # 生成数据集格式
    num_rounds = 500
    model = xgb.train(plst, dtrain, num_rounds) # xgboost模型训练
    
    # 对测试集进行预测
    dtest = xgb.DMatrix(X_test)
    y_pred = model.predict(dtest)
    
    # 计算准确率
    accuracy = accuracy_score(y_test,y_pred)
    print("accuarcy: %.2f%%" % (accuracy*100.0))
    
    # 显示重要特征
    plot_importance(model)
    plt.show()
    

    输出预测正确率以及特征重要性:

    Accuracy: 96.67 %

    这里写图片描述

    5.2 基于XGBoost原生接口的回归

    # ================基于XGBoost原生接口的回归=============
    
    import xgboost as xgb
    from xgboost import plot_importance
    from matplotlib import pyplot as plt
    from sklearn.model_selection import train_test_split
    from sklearn.datasets import load_boston
    from sklearn.metrics import mean_squared_error
    
    # 加载数据集
    boston = load_boston()
    X,y = boston.data,boston.target
    
    # XGBoost训练过程
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
    
    params = {
        'booster': 'gbtree',
        'objective': 'reg:gamma',
        'gamma': 0.1,
        'max_depth': 5,
        'lambda': 3,
        'subsample': 0.7,
        'colsample_bytree': 0.7,
        'min_child_weight': 3,
        'silent': 1,
        'eta': 0.1,
        'seed': 1000,
        'nthread': 4,
    }
    
    dtrain = xgb.DMatrix(X_train, y_train)
    num_rounds = 300
    plst = params.items()
    model = xgb.train(plst, dtrain, num_rounds)
    
    # 对测试集进行预测
    dtest = xgb.DMatrix(X_test)
    ans = model.predict(dtest)
    
    # 显示重要特征
    plot_importance(model)
    plt.show()
    
    

    重要特征(值越大,说明该特征越重要)显示结果:

    这里写图片描述

    xgb使用sklearn接口(推荐)

    XGBClassifier

    from xgboost.sklearn import XGBClassifier
    clf = XGBClassifier(
    silent=0 ,#设置成1则没有运行信息输出,最好是设置为0.是否在运行升级时打印消息。
    #nthread=4,# cpu 线程数 默认最大
    learning_rate= 0.3, # 如同学习率
    min_child_weight=1, 
    # 这个参数默认是 1,是每个叶子里面 h 的和至少是多少,对正负样本不均衡时的 0-1 分类而言
    #,假设 h 在 0.01 附近,min_child_weight 为 1 意味着叶子节点中最少需要包含 100 个样本。
    #这个参数非常影响结果,控制叶子节点中二阶导的和的最小值,该参数值越小,越容易 overfitting。
    max_depth=6, # 构建树的深度,越大越容易过拟合
    gamma=0,  # 树的叶子节点上作进一步分区所需的最小损失减少,越大越保守,一般0.1、0.2这样子。
    subsample=1, # 随机采样训练样本 训练实例的子采样比
    max_delta_step=0,#最大增量步长,我们允许每个树的权重估计。
    colsample_bytree=1, # 生成树时进行的列采样 
    reg_lambda=1,  # 控制模型复杂度的权重值的L2正则化项参数,参数越大,模型越不容易过拟合。
    #reg_alpha=0, # L1 正则项参数
    #scale_pos_weight=1, #如果取值大于0的话,在类别样本不平衡的情况下有助于快速收敛。平衡正负权重
    #objective= 'multi:softmax', #多分类的问题 指定学习任务和相应的学习目标
    #num_class=10, # 类别数,多分类与 multisoftmax 并用
    n_estimators=100, #树的个数
    seed=1000 #随机种子
    #eval_metric= 'auc'
    )
    clf.fit(X_train,y_train,eval_metric='auc')
    

    5.3 基于Scikit-learn接口的分类

    # ==============基于Scikit-learn接口的分类================
    from sklearn.datasets import load_iris
    import xgboost as xgb
    from xgboost import plot_importance
    from matplotlib import pyplot as plt
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    
    # 加载样本数据集
    iris = load_iris()
    X,y = iris.data,iris.target
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234565) # 数据集分割
    
    # 训练模型
    model = xgb.XGBClassifier(max_depth=5, learning_rate=0.1, n_estimators=160, silent=True, objective='multi:softmax')
    model.fit(X_train, y_train)
    
    # 对测试集进行预测
    y_pred = model.predict(X_test)
    
    # 计算准确率
    accuracy = accuracy_score(y_test,y_pred)
    print("accuarcy: %.2f%%" % (accuracy*100.0))
    
    # 显示重要特征
    plot_importance(model)
    plt.show()
    
    

    输出结果:Accuracy: 96.67 %

    这里写图片描述

    基于Scikit-learn接口的回归

    # ================基于Scikit-learn接口的回归================
    import xgboost as xgb
    from xgboost import plot_importance
    from matplotlib import pyplot as plt
    from sklearn.model_selection import train_test_split
    from sklearn.datasets import load_boston
    
    boston = load_boston()
    X,y = boston.data,boston.target
    
    # XGBoost训练过程
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
    
    model = xgb.XGBRegressor(max_depth=5, learning_rate=0.1, n_estimators=160, silent=True, objective='reg:gamma')
    model.fit(X_train, y_train)
    
    # 对测试集进行预测
    ans = model.predict(X_test)
    
    # 显示重要特征
    plot_importance(model)
    plt.show()
    
    

    这里写图片描述

    参数调优的一般方法

    我们会使用和GBM中相似的方法。需要进行如下步骤:

    1. 选择较高的学习速率(learning rate)。一般情况下,学习速率的值为0.1。但是,对于不同的问题,理想的学习速率有时候会在0.05到0.3之间波动。选择对应于此学习速率的理想决策树数量。XGBoost有一个很有用的函数“cv”,这个函数可以在每一次迭代中使用交叉验证,并返回理想的决策树数量。
    2. 对于给定的学习速率和决策树数量,进行决策树特定参数调优(max_depth, min_child_weight, gamma, subsample, colsample_bytree)。在确定一棵树的过程中,我们可以选择不同的参数,待会儿我会举例说明。
    3. xgboost的正则化参数的调优。(lambda, alpha)。这些参数可以降低模型的复杂度,从而提高模型的表现。
    4. 降低学习速率,确定理想参数。

    咱们一起详细地一步步进行这些操作。

    第一步:确定学习速率和tree_based 参数调优的估计器数目。

    为了确定boosting 参数,我们要先给其它参数一个初始值。咱们先按如下方法取值:
    1、max_depth = 5 :这个参数的取值最好在3-10之间。我选的起始值为5,但是你也可以选择其它的值。起始值在4-6之间都是不错的选择。
    2、min_child_weight = 1:在这里选了一个比较小的值,因为这是一个极不平衡的分类问题。因此,某些叶子节点下的值会比较小。
    3、gamma = 0: 起始值也可以选其它比较小的值,在0.1到0.2之间就可以。这个参数后继也是要调整的。
    4、subsample,colsample_bytree = 0.8: 这个是最常见的初始值了。典型值的范围在0.5-0.9之间。
    5、scale_pos_weight = 1: 这个值是因为类别十分不平衡。
    注意哦,上面这些参数的值只是一个初始的估计值,后继需要调优。这里把学习速率就设成默认的0.1。然后用xgboost中的cv函数来确定最佳的决策树数量。

    第二步: max_depth 和 min_weight 参数调优

    我们先对这两个参数调优,是因为它们对最终结果有很大的影响。首先,我们先大范围地粗调参数,然后再小范围地微调。
    注意:在这一节我会进行高负荷的栅格搜索(grid search),这个过程大约需要15-30分钟甚至更久,具体取决于你系统的性能。你也可以根据自己系统的性能选择不同的值。

    第三步:gamma参数调优

    第四步:调整subsample 和 colsample_bytree 参数

    第五步:正则化参数调优。

    第6步:降低学习速率
    最后,我们使用较低的学习速率,以及使用更多的决策树。我们可以用XGBoost中的CV函数来进行这一步工作。

    展开全文
  • xgboost

    万次阅读 多人点赞 2018-08-09 17:53:43
    Xgboost 概念内容介绍来自七月在线头条号: xgboost一直在竞赛江湖里被传为神器,比如时不时某个kaggle/天池比赛中,某人用xgboost于千军万马中斩获冠军。 RF和GBDT是工业界大爱的模型,Xgboost 是大杀器包裹,...
  • XGBoost:参数解释

    万次阅读 多人点赞 2015-07-01 17:45:46
    XGBoost参数在运行XGboost之前,必须设置三种类型成熟:general parameters,booster parameters和task parameters: General parameters:参数控制在提升(boosting)过程中使用哪种booster,常用的booster有树模型...
  • Xgboost的 优点

    千次阅读 2019-07-27 22:31:17
    目录 主要优点 具体原因: xgboost中的基学习器除了可以是CART(gbtree)也可以是线性... XGBoost的并行优化,XGBoost的并行是在特征粒度上的​​​​​​​ 考虑了训练数据为稀疏值的情况,可以为缺失值或者...
  • XGBoost原理介绍

    万次阅读 2018-07-25 23:10:00
    在这篇文章中,我将介绍XGBoost(eXtreme Gradient Boosting),一种tree boosting的可扩展机器学习系统。这个系统可以作为开源的软件包使用。该系统的影响已经在大量的机器学习和数据挖掘挑战中被广泛地认可。这些...
  • XGBoost

    千次阅读 2019-02-25 11:56:38
    什么是XGBoost? XGBoost(eXtreme Gradient Boosting)算法是Gradient Boosting算法的高效实现版本,因其在应用实践中表现出优良的效果和效率,因而被工业界广为推崇。   XGBoost类似于GBDT,是一个基于CART树的,...
  • linux 下安装xgboost

    万次阅读 2016-05-03 13:37:54
    第一步:安装anaconda安装xgboost 有一些依赖包,所以在安装xgboost之前需要安装这些依赖包。为了方便安装,这里推荐直接安装anaconda,这里集成了绝大多数第三方库,安装步骤很方便,这里是具体方法第二步:下载...
  • xgboost怎么将数据集分批训练,得到跟整个数据集一起放进去训练一样的模型
  • anaconda安装xgboost

    千次阅读 2019-08-31 21:30:15
    打开 Anaconda prompt 输入: conda install -c anaconda py-xgboost 即可
  • Anaconda:包安装以XGBoost为例

    万次阅读 2020-06-13 19:04:53
    目录: ...Anaconda是个非常方便同时功能强大的python环境管理工具,本篇blog主讲如何利用anaconda安装一些pip安装麻烦的包,比如XGBoost。 正文 标准语法: conda install pack_...
  • sklearn接口的xgboost 分类器: xgboost.XGBClaaifier() xgboost.fit(x,y) 1. xgboost.predict(test_x)  2. xgboost.predict_proba(test_x) 3. xgboost.score(test_x,y) 讨论: 结果1“可能”不准,因为...
  • Xgboost如何处理缺失值

    万次阅读 2018-05-09 21:43:43
    XgboostXgboost简介Xgboost[1]是由陈天奇提出的一种集成学习方法,要想了解Xgboost,这里建议先了解决策树,再了解GBDT(Gradient boosting descent tree)即梯度提升树,再学习理解Xgboost。推荐学习方式,阅读[1]...
  • xgboost配置GPU加速(快速安装版)

    千次阅读 2018-01-23 21:45:25
    环境:anaconda(python3.6) + win10 第一步: 下载xgboost源码: https://github.com/dmlc/xgboost ...从http://ssl.picnet.com.au/xgboost/中下载支持GPU版已...将xgboost.dll复制到xgboost-master/python-packa
  • 简单到一步安装 xgboost (Windows环境)

    万次阅读 2018-03-08 21:37:53
    数据分析工具Xgboost神器,官网上有很详细的安装方法,但折腾了半天还是不能使用。 后来搜索到一个十分便捷的方式,只需要很简单的一步就可以搞定。特此分享。开始干活环境: Windows 32或64位都行,具体版本没有...
  • 网上查阅博客发现,ModuleNotFoundError: No module named 'xgboost',报错一般是python的xgboost没有装好, 但是在我的cmd中,是可以import xgboost的: 然而到了spyder中,就会报import错误 后来也是查阅博客...
  • 1.先检查一下自己的版本,如图python3.6,win64 我的之前环境是已经安装了anaconda. 2.去相关的网站下载 这里只有3.0版本的。 至于2.0版本的参看链接, 感觉复杂.。
1 2 3 4 5 ... 20
收藏数 17,544
精华内容 7,017
关键字:

xgboost