精华内容
下载资源
问答
  • xgboost调参

    2018-11-19 09:58:07
    xgboost调参教程 ,适合机器学习 与风控评分卡调参相关学习。
  • xgboost调参指南

    2018-11-07 13:55:34
    xgboost调参过程,介绍xgboost调参的详细步骤,以及代码示例。
  • XGboost调参

    2017-11-24 00:34:42
    xgboost 使用与调参XGBoost的优势XGBoost算法可以给预测模型带来能力的提升。当我对它的表现有更多了解的时候,当我对它的高准确率背后的原理有更多了解的时候,我发现它具有很多优势:4.1 正则化 标准GBM的实现没有...

    xgboost 使用与调参

    XGBoost的优势

    XGBoost算法可以给预测模型带来能力的提升。当我对它的表现有更多了解的时候,当我对它的高准确率背后的原理有更多了解的时候,我发现它具有很多优势:

    4.1 正则化

    • 标准GBM的实现没有像XGBoost这样的正则化步骤。正则化对减少过拟合也是有帮助的。
    • 实际上,XGBoost以“正则化提升(regularized boosting)”技术而闻名。

    4.2 并行处理

    • XGBoost可以实现并行处理,相比GBM有了速度的飞跃。
    • 不过,众所周知,Boosting算法是顺序处理的,它怎么可能并行呢?每一课树的构造都依赖于前一棵树,那具体是什么让我们能用多核处理器去构造一个树呢?我希望你理解了这句话的意思。如果你希望了解更多,点击这个链接
    • XGBoost 也支持Hadoop实现。

    4.3 高度的灵活性

    • XGBoost 允许用户定义自定义优化目标和评价标准
    • 它对模型增加了一个全新的维度,所以我们的处理不会受到任何限制。

    4.4 缺失值处理

    • XGBoost内置处理缺失值的规则。
    • 用户需要提供一个和其它样本不同的值,然后把它作为一个参数传进去,以此来作为缺失值的取值。XGBoost在不同节点遇到缺失值时采用不同的处理方法,并且会学习未来遇到缺失值时的处理方法。

    4.5 剪枝

    • 当分裂时遇到一个负损失时,GBM会停止分裂。因此GBM实际上是一个贪心算法
    • XGBoost会一直分裂到指定的最大深度(max_depth),然后回过头来剪枝。如果某个节点之后不再有正值,它会去除这个分裂。
    • 这种做法的优点,当一个负损失(如-2)后面有个正损失(如+10)的时候,就显现出来了。GBM会在-2处停下来,因为它遇到了一个负值。但是XGBoost会继续分裂,然后发现这两个分裂综合起来会得到+8,因此会保留这两个分裂。

    4.6 内置交叉验证

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

    4.7、在已有的模型基础上继续

    • XGBoost可以在上一轮的结果上继续训练。这个特性在某些特定的应用上是一个巨大的优势。
    • sklearn中的GBM的实现也有这个功能,两种算法在这一点上是一致的。

    相信你已经对XGBoost强大的功能有了点概念。注意这是我自己总结出来的几点,你如果有更多的想法,尽管在下面评论指出,我会更新这个列表的!

    你的胃口被我吊起来了吗?棒棒哒!如果你想更深入了解相关信息,可以参考下面这些文章:
    XGBoost Guide - Introduce to Boosted Trees
    Words from the Auther of XGBoost [Viedo]

    5. XGBoost的参数

    XGBoost的作者把所有的参数分成了三类:

    1. 通用参数:宏观函数控制。
    2. Booster参数:控制每一步的booster(tree/regression)。
    3. 学习目标参数:控制训练目标的表现。

    在这里我会类比GBM来讲解,所以作为一种基础知识,强烈推荐先阅读这篇文章

    5.1 通用参数

    这些参数用来控制XGBoost的宏观功能。

    1、booster[默认gbtree]

    • 选择每次迭代的模型,有两种选择:
      gbtree:基于树的模型
      gbliner:线性模型

    2、silent[默认0]

    • 当这个参数值为1时,静默模式开启,不会输出任何信息。
    • 一般这个参数就保持默认的0,因为这样能帮我们更好地理解模型。

    3、nthread[默认值为最大可能的线程数]

    • 这个参数用来进行多线程控制,应当输入系统的核数。
    • 如果你希望使用CPU全部的核,那就不要输入这个参数,算法会自动检测它。

    还有两个参数,XGBoost会自动设置,目前你不用管它。接下来咱们一起看booster参数。

    5.2 booster参数

    尽管有两种booster可供选择,我这里只介绍tree booster,因为它的表现远远胜过linear booster,所以linear booster很少用到。

    1、eta[默认0.3]

    • 和GBM中的 learning rate 参数类似。
    • 通过减少每一步的权重,可以提高模型的鲁棒性。
    • 典型值为0.01-0.2。

    2、min_child_weight[默认1]

    • 决定最小叶子节点样本权重和。
    • 和GBM的 min_child_leaf 参数类似,但不完全一样。XGBoost的这个参数是最小样本权重的和,而GBM参数是最小样本总数
    • 这个参数用于避免过拟合。当它的值较大时,可以避免模型学习到局部的特殊样本。
    • 但是如果这个值过高,会导致欠拟合。这个参数需要使用CV来调整。

    3、max_depth[默认6]

    • 和GBM中的参数相同,这个值为树的最大深度。
    • 这个值也是用来避免过拟合的。max_depth越大,模型会学到更具体更局部的样本。
    • 需要使用CV函数来进行调优。
    • 典型值:3-10

    4、max_leaf_nodes

    • 树上最大的节点或叶子的数量。
    • 可以替代max_depth的作用。因为如果生成的是二叉树,一个深度为n的树最多生成n2个叶子。
    • 如果定义了这个参数,GBM会忽略max_depth参数。

    5、gamma[默认0]

    • 在节点分裂时,只有分裂后损失函数的值下降了,才会分裂这个节点。Gamma指定了节点分裂所需的最小损失函数下降值。
    • 这个参数的值越大,算法越保守。这个参数的值和损失函数息息相关,所以是需要调整的。

    6、max_delta_step[默认0]

    • 这参数限制每棵树权重改变的最大步长。如果这个参数的值为0,那就意味着没有约束。如果它被赋予了某个正值,那么它会让这个算法更加保守。
    • 通常,这个参数不需要设置。但是当各类别的样本十分不平衡时,它对逻辑回归是很有帮助的。
    • 这个参数一般用不到,但是你可以挖掘出来它更多的用处。

    7、subsample[默认1]

    • 和GBM中的subsample参数一模一样。这个参数控制对于每棵树,随机采样的比例。
    • 减小这个参数的值,算法会更加保守,避免过拟合。但是,如果这个值设置得过小,它可能会导致欠拟合。
    • 典型值:0.5-1

    8、colsample_bytree[默认1]

    • 和GBM里面的max_features参数类似。用来控制每棵随机采样的列数的占比(每一列是一个特征)。
    • 典型值:0.5-1

    9、colsample_bylevel[默认1]

    • 用来控制树的每一级的每一次分裂,对列数的采样的占比。
    • 我个人一般不太用这个参数,因为subsample参数和colsample_bytree参数可以起到相同的作用。但是如果感兴趣,可以挖掘这个参数更多的用处。

    10、lambda[默认1]

    • 权重的L2正则化项。(和Ridge regression类似)。
    • 这个参数是用来控制XGBoost的正则化部分的。虽然大部分数据科学家很少用到这个参数,但是这个参数在减少过拟合上还是可以挖掘出更多用处的。

    11、alpha[默认1]

    • 权重的L1正则化项。(和Lasso regression类似)。
    • 可以应用在很高维度的情况下,使得算法的速度更快。

    12、scale_pos_weight[默认1]

    • 在各类别样本十分不平衡时,把这个参数设定为一个正值,可以使算法更快收敛。

    5.3学习目标参数

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

    1、objective[默认reg:linear]

    • 这个参数定义需要被最小化的损失函数。最常用的值有:
      binary:logistic 二分类的逻辑回归,返回预测的概率(不是类别)。multi:softmax 使用softmax的多分类器,返回预测的类别(不是概率)。
      在这种情况下,你还需要多设一个参数:num_class(类别数目)。multi:softprob 和multi:softmax参数一样,但是返回的是每个数据属于各个类别的概率。

    2、eval_metric[默认值取决于objective参数的取值]

    • 对于有效数据的度量方法。
    • 对于回归问题,默认值是rmse,对于分类问题,默认值是error。
    • 典型值有:
      rmse 均方根误差(∑Ni=1ϵ2N‾‾‾‾‾‾‾√)mae 平均绝对误差(∑Ni=1|ϵ|N)logloss 负对数似然函数值error 二分类错误率(阈值为0.5)merror 多分类错误率mlogloss 多分类logloss损失函数auc 曲线下面积

    3、seed(默认0)

    • 随机数的种子
    • 设置它可以复现随机数据的结果,也可以用于调整参数

    如果你之前用的是Scikit-learn,你可能不太熟悉这些参数。但是有个好消息,python的XGBoost模块有一个sklearn包,XGBClassifier。这个包中的参数是按sklearn风格命名的。会改变的函数名是:

    1、eta -> learning_rate
    2、lambda -> reg_lambda
    3、alpha -> reg_alpha

    你肯定在疑惑为啥咱们没有介绍和GBM中的n_estimators类似的参数。XGBClassifier中确实有一个类似的参数,但是,是在标准XGBoost实现中调用拟合函数时,把它作为num_boosting_rounds参数传入。
    XGBoost Guide 的一些部分是我强烈推荐大家阅读的,通过它可以对代码和参数有一个更好的了解:

    XGBoost Parameters (official guide)
    XGBoost Demo Codes (xgboost GitHub repository)
    Python API Reference (official guide)

    展开全文
  • Xgboost调参

    2019-11-12 23:01:34
    xgboost XGBoost 参数 在运行XGBoost程序之前,必须设置三种类型的参数:通用类型参数(general parameters)、booster参数和学习任务参数(task parameters)。 一般类型参数general parameters –参数决定在提升的...

    xgboost

    XGBoost 参数

    在运行XGBoost程序之前,必须设置三种类型的参数:通用类型参数(general parameters)、booster参数和学习任务参数(task parameters)。
    一般类型参数general parameters –参数决定在提升的过程中用哪种booster,常见的booster有树模型和线性模型。
    Booster参数-该参数的设置依赖于我们选择哪一种booster模型。
    学习任务参数task parameters-参数的设置决定着哪一种学习场景,例如,回归任务会使用不同的参数来控制着排序任务。
    命令行参数-一般和xgboost的CL版本相关。

    接口形式

    def 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):
    
    - params 这是一个字典,里面包含着训练中的参数关键字和对应的值,形式是params {'booster':'gbtree','eta':0.1}
    - dtrain 训练的数据
    - obj 自定义目的函数
    - feval 自定义评估函数
    - 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
    
    ## 简单例子 ## 
    
    def ToWeight(y):
        w = np.zeros(y.shape, dtype=float)
        ind = y != 0
        w[ind] = 1./(y[ind]**2)
        return w
    
    def rmspe(yhat, y):
        w = ToWeight(y)
        rmspe = np.sqrt(np.mean(w*(y-yhat)**2))
        return rmspe
    
    # 放大的作用
    def rmspe_xg(yhat, y):
        """
        自定义评估函数
        """
        #y = y.values
        y = y.get_label()
        y = np.exp(y) - 1
        yhat = np.exp(yhat) -1
        w = ToWeight(y)
        rmspe = np.sqrt(np.mean(w*(y-yhat)**2))
        return 'rmspe', rmspe
    
    params = {"objective": "reg:linear",
              "booster": "gbtree",
              "eta": 0.01,
              "max_depth": 3,
              "min_child_weight": 3,
              "subsample": 0.9,
              "colsample_bytree": 0.7,
              "silent": 1
              }
    tsize = 0.05
    X_train, X_test = train_test_split(train, test_size=tsize)
    dtrain = xgb.DMatrix(X_train[features], np.log(X_train[goal] + 1))
    dvalid = xgb.DMatrix(X_test[features], np.log(X_test[goal] + 1))
    watchlist = [(dtrain, 'train'), (dvalid, 'eval')]
    gbm = xgb.train(params, dtrain, ntrees, evals=watchlist, early_stopping_rounds=100, feval=rmspe_xg, verbose_eval=True)
    

    Booster参数

    • eta[默认是0.3] 和GBM中的learning rate参数类似。通过减少每一步的权重,可以提高模型的鲁棒性。典型值0.01-0.2
    • min_child_weight[默认是1] 决定最小叶子节点样本权重和,。当它的值较大时,可以避免模型学习到局部的特殊样本。但如果这个值过高,会导致欠拟合。这个参数需要用cv来调整。孩子节点中最小的样本权重和。如果一个叶子节点的样本权重和小于min_child_weight则拆分过程结束。(minimum sum of instance weight (Hessian) needed in a child),在回归问题中可以理解为节点上样本的个数,在分类问题可以理解为节点样本上的纯度。
    • max_depth [默认是3] 树的最大深度,这个值也是用来避免过拟合的3-10
    • max_leaf_nodes 树上最大的节点或叶子的数量,可以代替max_depth的作用,应为如果生成的是二叉树,一个深度为n的树最多生成2n个叶子,如果定义了这个参数max_depth会被忽略
    • gamma[默认是0] 在节点分裂时,只有在分裂后损失函数的值下降了,才会分裂这个节点。Gamma指定了节点分裂所需的最小损失函数下降值。这个参数值越大,算法越保守。
    • max_delta_step[默认是0] 这参数限制每颗树权重改变的最大步长。如果是0意味着没有约束。如果是正值那么这个算法会更保守,通常不需要设置。
    • subsample[默认是1] 这个参数控制对于每棵树,随机采样的比例。减小这个参数的值算法会更加保守,避免过拟合。但是这个值设置的过小,它可能会导致欠拟合。典型值:0.5-1
    • colsample_bytree[默认是1] 用来控制每颗树随机采样的列数的占比每一列是一个特征0.5-1(要依据特征个数来判断)
    • colsample_bylevel[默认是1] 用来控制的每一级的每一次分裂,对列数的采样的占比。
    • lambda[默认是1] 权重的L2正则化项
    • alpha[默认是1] 权重的L1正则化项
    • scale_pos_weight[默认是1] 各类样本十分不平衡时,把这个参数设置为一个正数,可以使算法更快收敛。

    通用参数

    • booster[默认是gbtree ]
      选择每次迭代的模型,有两种选择:gbtree基于树的模型、gbliner线性模型
    • silent[默认是0]
      当这个参数值为1的时候,静默模式开启,不会输出任何信息。一般这个参数保持默认的0,这样可以帮我们更好的理解模型。
    • nthread[默认值为最大可能的线程数]
      这个参数用来进行多线程控制,应当输入系统的核数,如果你希望使用cpu全部的核,就不要输入这个参数,算法会自动检测。

    学习目标参数

    • objective[默认是reg:linear]
      这个参数定义需要被最小化的损失函数。最常用的值有:binary:logistic二分类的逻辑回归,返回预测的概率非类别。multi:softmax使用softmax的多分类器,返回预测的类别。在这种情况下,你还要多设置一个参数:num_class类别数目。

      "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
      
    • eval_metric[默认值取决于objective参数的取值]
      对于有效数据的度量方法。对于回归问题,默认值是rmse,对于分类问题,默认是error。典型值有:rmse均方根误差;mae平均绝对误差;logloss负对数似然函数值;error二分类错误率;merror多分类错误率;mlogloss多分类损失函数;auc曲线下面积。

    • seed[默认是0]
      随机数的种子,设置它可以复现随机数据的结果,也可以用于调整参数。

    xgboost中文文档

    展开全文
  • XGBOOST调参

    千次阅读 2017-12-20 10:30:32
    XGBOOST的威力不用赘述,反正我是离不开它了。...今天说下如何调参。 bias-variance trade-off xgboost一共有几十个参数: http://xgboost.readthedocs.io/en/latest/parameter.html 中文

    XGBOOST的威力不用赘述,反正我是离不开它了。

    具体XGBOOST的原理可以参见之前的文章《比XGBOOST更快--LightGBM介绍》

    今天说下如何调参。

    1. bias-variance trade-off

    xgboost一共有几十个参数:

    xgboost.readthedocs.io/

    中文版解释:

    blog.csdn.net/zc0205112


    文艺青年的调参一般这样的:

    1. 设定参数{parm},评判指标{metrics};

    2. 根据{metrics}在验证集上的大小,确定树的棵树n_estimators;

    3. 采用参数{parm}、n_estimators,训练模型,并应用到测试集

    一个字:糙!(kuai)

    数据挖掘师的调参一般这样的:

    1. 设定基础参数{parm0},基础评判指标{metrics0};

    2. 在训练集上做cross-validation,做训练集/交叉验证集上偏差/方差与树棵树的关系图;

    3. 判断模型是过拟合 or 欠拟合,更新相应参数{parm1};

    4. 重复2、3步,确定树的棵树n_estimators;

    5. 采用参数{parm1}、n_estimators,训练模型,并应用到测试集;

    数据集大小:70000*100,随机准确率 0.17%

    在设置了基础参数,设定了树的范围后,可以看到模型在训练集和交叉验证集上的效果是这样子滴:


    阴影部分,表示的是模型的方差

    从上图,可以得出以下几个结论:

    - 验证集上偏差最小&方差最小:n_estimators=66

    - 训练集和验证集误差较大:过拟合-----模型过于复杂

    - 方差较大----模型过于复杂

    这符合下面这个图

    以上特征,都表明我们需要降低模型复杂程度,有哪些参数可以调整呢:

    - 直接降低模型复杂度

    max_depth、min_child_weight、gamma

    - 随机化

    subsample、colsample_bytree

    - 正则化

    lambda、alpha

    通过,grid-search,再调整了以上的参数后,如下图。最佳trade-off点的variance从0.361降低到0.316,auc_mean从0.8312降低到0.8308。


    P-R的提升还是比较明显的:



    还有,先粗调,再微调

    -- 降低learning_rate,当然同时,提高n_estimators


    2. 非平衡数据集怎么办

    -- 想办法弄到更多的数据

    -- 想办法把数据弄平衡

    -- 利用smote等算法来过采样/欠采样

    -- 设置weight(初始化DMatrix时)

    -- 使用更好的metrics:auc、f1

    -- min_child_weight 设的小一点

    -- scale_pos_weight = 0值的样本数量/1值的样本数量

    -- max_delta_step

    -- 自定义评价函数

    xgb.train(params, dtrain, num_rounds, watchlist, feval=misclassified, maximize=False)

    def misclassified(pred_probs, dtrain):
        labels = dtrain.get_label() # obtain true labels
        preds = pred_probs > 0.5 # obtain predicted values
        return 'misclassified', np.sum(labels != preds)
    展开全文
  • xgboost 调参

    2019-04-04 21:16:00
    如果你的预测模型表现得有些不尽如人意,那就用XGBoost吧。XGBoost算法现在已经成为很多数据工程师的重要武器。它是一种十分精致的算法,可以处理各种不规则的数据。 构造一个使用XGBoost的模型十分简单。但是,...

    文章来自于:https://blog.csdn.net/zllnau66/article/details/81980876

    1. 简介

    如果你的预测模型表现得有些不尽如人意,那就用XGBoost吧。XGBoost算法现在已经成为很多数据工程师的重要武器。它是一种十分精致的算法,可以处理各种不规则的数据。
    构造一个使用XGBoost的模型十分简单。但是,提高这个模型的表现就有些困难(至少我觉得十分纠结)。这个算法使用了好几个参数。所以为了提高模型的表现,参数的调整十分必要。在解决实际问题的时候,有些问题是很难回答的——你需要调整哪些参数?这些参数要调到什么值,才能达到理想的输出?
    这篇文章最适合刚刚接触XGBoost的人阅读。在这篇文章中,我们会学到参数调优的技巧,以及XGboost相关的一些有用的知识。以及,我们会用Python在一个数据集上实践一下这个算法。

    2. 你需要知道的

    XGBoost(eXtreme Gradient Boosting)是Gradient Boosting算法的一个优化的版本。因为我在前一篇文章,基于Python的Gradient Boosting算法参数调整完全指南,里面已经涵盖了Gradient Boosting算法的很多细节了。我强烈建议大家在读本篇文章之前,把那篇文章好好读一遍。它会帮助你对Boosting算法有一个宏观的理解,同时也会对GBM的参数调整有更好的体会。

    特别鸣谢:我个人十分感谢Mr Sudalai Rajkumar (aka SRK)大神的支持,目前他在AV Rank中位列第二。如果没有他的帮助,就没有这篇文章。在他的帮助下,我们才能给无数的数据科学家指点迷津。给他一个大大的赞!

    3. 内容列表

    1、XGBoost的优势
    2、理解XGBoost的参数
    3、调参示例

    4. XGBoost的优势

    XGBoost算法可以给预测模型带来能力的提升。当我对它的表现有更多了解的时候,当我对它的高准确率背后的原理有更多了解的时候,我发现它具有很多优势:

    4.1 正则化

    • 标准GBM的实现没有像XGBoost这样的正则化步骤。正则化对减少过拟合也是有帮助的。
    • 实际上,XGBoost以“正则化提升(regularized boosting)”技术而闻名。

    4.2 并行处理

    • XGBoost可以实现并行处理,相比GBM有了速度的飞跃。
    • 不过,众所周知,Boosting算法是顺序处理的,它怎么可能并行呢?每一课树的构造都依赖于前一棵树,那具体是什么让我们能用多核处理器去构造一个树呢?我希望你理解了这句话的意思。如果你希望了解更多,点击这个链接
    • XGBoost 也支持Hadoop实现。

    4.3 高度的灵活性

    • XGBoost 允许用户定义自定义优化目标和评价标准
    • 它对模型增加了一个全新的维度,所以我们的处理不会受到任何限制。

    4.4 缺失值处理

    • XGBoost内置处理缺失值的规则。
    • 用户需要提供一个和其它样本不同的值,然后把它作为一个参数传进去,以此来作为缺失值的取值。XGBoost在不同节点遇到缺失值时采用不同的处理方法,并且会学习未来遇到缺失值时的处理方法。

    4.5 剪枝

    • 当分裂时遇到一个负损失时,GBM会停止分裂。因此GBM实际上是一个贪心算法
    • XGBoost会一直分裂到指定的最大深度(max_depth),然后回过头来剪枝。如果某个节点之后不再有正值,它会去除这个分裂。
    • 这种做法的优点,当一个负损失(如-2)后面有个正损失(如+10)的时候,就显现出来了。GBM会在-2处停下来,因为它遇到了一个负值。但是XGBoost会继续分裂,然后发现这两个分裂综合起来会得到+8,因此会保留这两个分裂。

    4.6 内置交叉验证

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

    4.7、在已有的模型基础上继续

        • XGBoost可以在上一轮的结果上继续训练。这个特性在某些特定的应用上是一个巨大的优势。
        • sklearn中的GBM的实现也有这个功能,两种算法在这一点上是一致的。
        • 二、网格调参


    五、网格调参

      用xgboost既可以用来做二分类、多分类,也可以用来做回归预测数值,除了特征之外,影响模型的是如何调参了,一般是按一定的步骤、网格搜索最优参数,如下两篇文章一个是用来分类,一个是用来预测  数值的案例,并且详细给出了调参的步骤和代码:

    https://blog.csdn.net/han_xiaoyang/article/details/52665396 (用来分类XGBClassifier)

    https://segmentfault.com/a/1190000014040317 (用来预测数字,XGBRegressor)

    六、实践


    参考以上的博客,用iris经典数据集进行多分类的预测(三个类别):

    import pandas as pd
    import numpy as np
    import xgboost as xgb
    from xgboost.sklearn import XGBClassifier
    from sklearn import model_selection, metrics   
    from sklearn.grid_search import GridSearchCV   #Perforing grid search
    
    import matplotlib.pylab as plt
    %matplotlib inline
    
    
    import warnings
    warnings.filterwarnings(module='sklearn*', action='ignore', category=DeprecationWarning)
    from sklearn import datasets
    data=iris.data
    label=iris.target
    from sklearn.cross_validation import train_test_split
    train_x, test_x, train_y, test_y = train_test_split(data, label,test_size=0.3, random_state=0)
    
    dtrain=xgb.DMatrix(train_x,label=train_y)
    dtest=xgb.DMatrix(test_x,label=test_y)
    cv_params = {'n_estimators': [1,2,3,4,5,6]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 500, 'max_depth': 5, 'min_child_weight': 1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 6 candidates, totalling 30 fits
    参数的最佳取值:{'n_estimators': 4}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done  30 out of  30 | elapsed:    8.9s finished
    cv_params = {'max_depth': [3, 4, 5, 6, 7, 8, 9, 10], 'min_child_weight': [1, 2, 3, 4, 5, 6]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 4, 'max_depth': 5, 'min_child_weight': 1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 48 candidates, totalling 240 fits
    参数的最佳取值:{'max_depth': 4, 'min_child_weight': 1}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done 240 out of 240 | elapsed:    8.7s finished
    cv_params = {'gamma': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 4, 'max_depth': 4, 'min_child_weight': 1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 6 candidates, totalling 30 fits
    参数的最佳取值:{'gamma': 0.1}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done  30 out of  30 | elapsed:    8.6s finished
    cv_params = {'subsample': [0.6, 0.7, 0.8, 0.9], 'colsample_bytree': [0.6, 0.7, 0.8, 0.9]}
    other_params = {'learning_rate': 0.1, 'n_estimators':4, 'max_depth': 4, 'min_child_weight':1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0.1, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 16 candidates, totalling 80 fits
    参数的最佳取值:{'colsample_bytree': 0.8, 'subsample': 0.8}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done  80 out of  80 | elapsed:    9.5s finished
    cv_params = {'reg_alpha': [0.05, 0.1, 1, 2, 3], 'reg_lambda': [0.05, 0.1, 1, 2, 3]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 4, 'max_depth': 4, 'min_child_weight': 1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0.1, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 25 candidates, totalling 125 fits
    参数的最佳取值:{'reg_alpha': 0.05, 'reg_lambda': 0.05}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done 125 out of 125 | elapsed:    8.6s finished
    cv_params = {'learning_rate': [0.01, 0.05, 0.07, 0.1, 0.2]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 4, 'max_depth': 4, 'min_child_weight': 1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0.1, 'reg_alpha': 0.05, 'reg_lambda': 0.05}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 5 candidates, totalling 25 fits
    参数的最佳取值:{'learning_rate': 0.1}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done  25 out of  25 | elapsed:    8.7s finished
    params={
            'booster':'gbtree',
            'objective': 'multi:softmax', #指明是分类问题
           # 'eval_metric': 'auc',
            'num_class':3, # 类数,与 multisoftmax 并用
            'gamma':0.1,  # 用于控制是否后剪枝的参数,越大越保守,一般0.1、0.2这样子。
            'max_depth':4, # 构建树的深度,越大越容易过拟合
            'lambda':0.05,  #控制模型复杂度的权重值的L2正则化项参数,参数越大,模型越不容易过拟合。
            'subsample':0.8, # 采样训练数据,设置为0.5,随机选择一般的数据实例 (0:1]
            'colsample_bytree':0.8, # 构建树树时的采样比率 (0:1]
            'min_child_weight':1, # 节点的最少特征数
            'silent':1 ,# 设置成1则没有运行信息输出,最好是设置为0.
            'eta': 0.1, # 如同学习率
            'seed':710,
            'alpha':0.05,
            'nthread':4,# cpu 线程数,根据自己U的个数适当调整
    }
    plst = list(params.items())
    num_rounds=100
    watchlist = [(dtrain,'train'),(dtest,'eval')]
    model=xgb.train(plst,dtrain,num_rounds,evals=watchlist)
    [0] train-merror:0.038095   eval-merror:0.088889
    [1] train-merror:0.019048   eval-merror:0.022222
    [2] train-merror:0.028571   eval-merror:0.022222
    [3] train-merror:0.019048   eval-merror:0.022222
    [4] train-merror:0.019048   eval-merror:0.022222
    [5] train-merror:0.019048   eval-merror:0.022222
    [6] train-merror:0.019048   eval-merror:0.022222
    [7] train-merror:0.019048   eval-merror:0.022222
    [8] train-merror:0.019048   eval-merror:0.022222
    [9] train-merror:0.019048   eval-merror:0.022222
    [10]    train-merror:0.019048   eval-merror:0.022222
    [11]    train-merror:0.019048   eval-merror:0.022222
    [12]    train-merror:0.019048   eval-merror:0.022222
    [13]    train-merror:0.019048   eval-merror:0.022222
    [14]    train-merror:0.019048   eval-merror:0.022222
    [15]    train-merror:0.019048   eval-merror:0.022222
    [16]    train-merror:0.019048   eval-merror:0.022222
    [17]    train-merror:0.019048   eval-merror:0.022222
    [18]    train-merror:0.019048   eval-merror:0.022222
    [19]    train-merror:0.009524   eval-merror:0.022222
    [20]    train-merror:0.019048   eval-merror:0.022222
    [21]    train-merror:0.009524   eval-merror:0.022222
    [22]    train-merror:0.009524   eval-merror:0.022222
    [23]    train-merror:0  eval-merror:0.022222
    [24]    train-merror:0  eval-merror:0.022222
    [25]    train-merror:0  eval-merror:0.022222
    [26]    train-merror:0.009524   eval-merror:0.022222
    [27]    train-merror:0  eval-merror:0.022222
    [28]    train-merror:0.009524   eval-merror:0.022222
    [29]    train-merror:0  eval-merror:0.022222
    [30]    train-merror:0  eval-merror:0.022222
    [31]    train-merror:0  eval-merror:0.022222
    [32]    train-merror:0  eval-merror:0.022222
    [33]    train-merror:0  eval-merror:0.022222
    [34]    train-merror:0  eval-merror:0.022222
    [35]    train-merror:0  eval-merror:0.022222
    [36]    train-merror:0  eval-merror:0.022222
    [37]    train-merror:0  eval-merror:0.022222
    [38]    train-merror:0  eval-merror:0.022222
    [39]    train-merror:0  eval-merror:0.022222
    [40]    train-merror:0  eval-merror:0.022222
    [41]    train-merror:0  eval-merror:0.022222
    [42]    train-merror:0  eval-merror:0.022222
    [43]    train-merror:0  eval-merror:0.022222
    [44]    train-merror:0  eval-merror:0.022222
    [45]    train-merror:0  eval-merror:0.022222
    [46]    train-merror:0  eval-merror:0.022222
    [47]    train-merror:0  eval-merror:0.022222
    [48]    train-merror:0  eval-merror:0.022222
    [49]    train-merror:0  eval-merror:0.022222
    [50]    train-merror:0  eval-merror:0.022222
    [51]    train-merror:0  eval-merror:0.022222
    [52]    train-merror:0  eval-merror:0.022222
    [53]    train-merror:0  eval-merror:0.022222
    [54]    train-merror:0  eval-merror:0.022222
    [55]    train-merror:0  eval-merror:0.022222
    [56]    train-merror:0  eval-merror:0.022222
    [57]    train-merror:0  eval-merror:0.022222
    [58]    train-merror:0  eval-merror:0.022222
    [59]    train-merror:0  eval-merror:0.022222
    [60]    train-merror:0  eval-merror:0.022222
    [61]    train-merror:0  eval-merror:0.022222
    [62]    train-merror:0  eval-merror:0.022222
    [63]    train-merror:0  eval-merror:0.022222
    [64]    train-merror:0  eval-merror:0.022222
    [65]    train-merror:0  eval-merror:0.022222
    [66]    train-merror:0  eval-merror:0.022222
    [67]    train-merror:0  eval-merror:0.022222
    [68]    train-merror:0  eval-merror:0.022222
    [69]    train-merror:0  eval-merror:0.022222
    [70]    train-merror:0  eval-merror:0.022222
    [71]    train-merror:0  eval-merror:0.022222
    [72]    train-merror:0  eval-merror:0.022222
    [73]    train-merror:0  eval-merror:0.022222
    [74]    train-merror:0  eval-merror:0.022222
    [75]    train-merror:0  eval-merror:0.022222
    [76]    train-merror:0  eval-merror:0.022222
    [77]    train-merror:0  eval-merror:0.022222
    [78]    train-merror:0  eval-merror:0.022222
    [79]    train-merror:0  eval-merror:0.022222
    [80]    train-merror:0  eval-merror:0.022222
    [81]    train-merror:0  eval-merror:0.022222
    [82]    train-merror:0  eval-merror:0.022222
    [83]    train-merror:0  eval-merror:0.022222
    [84]    train-merror:0  eval-merror:0.022222
    [85]    train-merror:0  eval-merror:0.022222
    [86]    train-merror:0  eval-merror:0.022222
    [87]    train-merror:0  eval-merror:0.022222
    [88]    train-merror:0  eval-merror:0.022222
    [89]    train-merror:0  eval-merror:0.022222
    [90]    train-merror:0  eval-merror:0.022222
    [91]    train-merror:0  eval-merror:0.022222
    [92]    train-merror:0  eval-merror:0.022222
    [93]    train-merror:0  eval-merror:0.022222
    [94]    train-merror:0  eval-merror:0.022222
    [95]    train-merror:0  eval-merror:0.022222
    [96]    train-merror:0  eval-merror:0.022222
    [97]    train-merror:0  eval-merror:0.022222
    [98]    train-merror:0  eval-merror:0.022222
    [99]    train-merror:0  eval-merror:0.022222

    以上是通过网格参数取得了最佳参数后,代入xgb.train()得出的结果,和用XGBClassifier其实是一样的,只不过两者的参数命名略有不同:

    xgb1 = XGBClassifier(
         learning_rate=0.1, 
         n_estimators=4, 
         max_depth=4,
         min_child_weight=1,
         seed=0,
         subsample=0.8, 
         colsample_bytree=0.8, 
         gamma=0.1, 
         reg_alpha=0.05, 
         reg_lambda=0.05)
    xgb1.fit(train_x,train_y)
    ypred1=xgb1.predict(test_x)
    print(metrics.accuracy_score(test_y, ypred1))

     

    转载于:https://www.cnblogs.com/liuyicai/p/10657111.html

    展开全文
  • 这次小编来聊聊机器学习文章比较长,觉得有用的可以关注一下方便后续查阅本文主要关于需要调参的模型(以XGBoost为例),在跨时间任务上(以信贷场景为例),调参需要注意的问题会出现的问题一共有4个:验证集时间...
  • XGBoost调参

    2019-05-04 19:48:24
    import pandas as pd import numpy as np from sklearn.metrics import mean_absolute_error,make_...import xgboost as xgb from sklearn.model_selection import GridSearchCV import warnings warnings.filt...
  • 第二步: max_depth 和 min_weight 对最终结果有很大的影响 ‘max_depth’:range(3,10,2), ‘min_child_weight’:range(1,6,2) 先大范围地粗参数,然后再小范围地微调。 第三步:gamma参数调优 ‘gamma’:[i/10.0...
  • 机器学习实战项目Xgboost调参,完整的项目,机器学习实战项目Xgboost调参

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,186
精华内容 474
关键字:

xgboost调参