XGBT算法梳理

本文深入剖析XGBoost算法的工作原理,从预测值计算到损失函数优化,详细解读梯度提升树如何通过迭代减小预测误差。通过泰勒展开简化目标函数,利用正则化项避免过拟合,最后展示在sklearn中的应用实例。

XGBoost算法梳理

  1. 算法原理
    XGBT中的预测值是所有弱分类器上的叶子权重直接求和得到
    yi^=∑jwjxij\widehat{y_{i}}=\sum _{j}w_{j}x_{ij}yi=jwjxij
    损失函数:l(yi,yi^)=(yi−yi^)2l(y_{i},\widehat{y_{i}})=(y_{i}-\widehat{y_{i}})^{2}l(yi,yi)=(yiyi)2
    XGB的核心是每次迭代都是基于上一次的残差去拟合,大致过程如下
    yi^(0)=0\widehat{y_{i}}^{(0)}=0yi(0)=0
    yi^(1)=f1(xi)=yi^0+f1(xi)\widehat{y_{i}}^{(1)}=f_{1}(x_{i})=\widehat{y_{i}}^{0}+f_{1}(x_{i})yi(1)=f1(xi)=yi0+f1(xi)
    yi^(2)=f1(xi)+f2(xi)=yi^1+f2(xi)\widehat{y_{i}}^{(2)}=f_{1}(x_{i})+f_{2}(x_{i})=\widehat{y_{i}}^{1}+f_{2}(x_{i})yi(2)=f1(xi)+f2(xi)=yi1+f2(xi)

    yi^(t)=∑k=1tfk(xi)=yi^(t−1)+ft(xi)\widehat{y_{i}}^{(t)}=\sum_{k=1}^{t}f_{k}(x_{i})=\widehat{y_{i}}^{(t-1)}+f_{t}(x_{i})yi(t)=k=1tfk(xi)=yi(t1)+ft(xi)
    这里yi^(t)\widehat{y_{i}}^{(t)}yi(t)表示是第t轮的模型预测,ft(xi)f_{t}(x_{i})ft(xi)表示加入一个新的函数
    ft(x)=wq(x),w∈RT,q:Rd→1,2,...,Tf_{t}(x)=w_{q}(x),w\in R^{T},q:R^{d}\rightarrow {1,2,...,T}ft(x)=wq(x),wRT,q:Rd1,2,...,T
    接下来就是f的求解了,每一轮中,我们选取一个f来使得我们的目标函数尽量最大地降低
    Obj(t)=∑i=1nl(yi,yi^(t)+∑i=1tΩ(ft)=∑i=1nl(yi,yi^(t−1)+ft(xi))+Ω(ft)+constantObj^{(t)}=\sum_{i=1}^{n}l(y^{i},\widehat{y_{i}}^{(t)}+\sum_{i=1}^{t}\Omega(f_{t})=\sum_{i=1}^{n}l(y_{i},\widehat{y_{i}}^{(t-1)}+f_{t}(x_{i}))+\Omega(f_{t})+constantObj(t)=i=1nl(yi,yi(t)+i=1tΩ(ft)=i=1nl(yi,yi(t1)+ft(xi))+Ω(ft)+constant
    Obj(t)=∑i=1n(yi−(yi^(t−1)+ft(xi)))2+Ω(ft)+constantObj^{(t)}=\sum_{i=1}^{n}(y_{i}-(\widehat{yi}^{(t-1)}+f_t(x_{i})))^{2}+\Omega(f_{t})+constantObj(t)=i=1n(yi(yi(t1)+ft(xi)))2+Ω(ft)+constant
    ∑i=1n[2(yi^(t−1)−yi)+ft(xi)2]+Ω(ft)+constant\sum_{i=1}^{n}[2(\widehat{yi}^{(t-1)}-y_{i})+f_t(x_{i})^{2}]+\Omega(f_{t})+constanti=1n[2(yi(t1)yi)+ft(xi)2]+Ω(ft)+constant
  • [注 ] 一般我们把yi^(t−1)−yi\widehat{yi}^{(t-1)}-y_{i}yi(t1)yi叫做残差,这里的Ω(ft)=γT+12λ∑j=1Twj2\Omega(f_{t})=\gamma T+\frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^{2}Ω(ft)=γT+21λj=1Twj2是正则化处理,
    目标函数由两部分构成,第一部分用来衡量预测分数和真实分数的差距,另一部分则是正则化项。正则化项同样包含两部分,T表示叶子结点的个数,w表示叶子节点的分数。γ\gammaγ可以控制叶子结点的个数,λ\lambdaλ可以控制叶子节点的分数不会过大,防止过拟合。

下一步,用泰勒展开来近似我们原来的目标函数:∑i=1nl(yi,yi^(t−1)+ft(xi))+Ω(ft)+constant\sum_{i=1}^{n}l(y_{i},\widehat{y_{i}}^{(t-1)}+f_{t}(x_{i}))+\Omega(f_{t})+constanti=1nl(yi,yi(t1)+ft(xi))+Ω(ft)+constant
泰勒二阶展开:
f(x+Δx)≈f(x)+f′(x)Δx+12f′′(x)Δx2f(x+\Delta x)\approx f(x)+{f}'(x)\Delta x+\frac{1}{2}{f}''(x)\Delta x^{2}f(x+Δx)f(x)+f(x)Δx+21f(x)Δx2
定义:gi=∂l(yi,y^(t−1))∂y^(t−1)g_{i}=\frac{\partial l(yi,\widehat{y}^{(t-1)})}{\partial \widehat{y}^{(t-1)}}gi=y(t1)l(yi,y(t1))
hi=∂l(yi,y^(t−1))∂2y^(t−1)h_{i}=\frac{\partial l(yi,\widehat{y}^{(t-1)})}{\partial^{2} \widehat{y}^{(t-1)}}hi=2y(t1)l(yi,y(t1))
Obj(t)≈∑i=1n[l(yi,yi^(t−1))+gift(xi)+12hift2(xi)]+Ω(ft)+constantObj(t)\approx \sum_{i=1}^{n}[l(y_{i},\widehat{y_{i}}^{(t-1)})+g_{i}f_{t}(x_{i})+\frac{1}{2}h_{i}f{t}^{2}(xi)]+\Omega(f_{t})+constantObj(t)i=1n[l(yi,yi(t1))+gift(xi)+21hift2(xi)]+Ω(ft)+constant
进一步化简,因为这里的l(yi,yi^(t−1))l(y_{i},\widehat{y_{i}}^{(t-1)})l(yi,yi(t1))为常数,故
Obj(t)≈∑i=1n[gift(xi)+12hift2(xi)]+Ω(ft)Obj(t)\approx \sum_{i=1}^{n}[g_{i}f_{t}(x_{i})+\frac{1}{2}h_{i}f{t}^{2}(xi)]+\Omega(f_{t})Obj(t)i=1n[gift(xi)+21hift2(xi)]+Ω(ft)
因为样本最终会落到树的叶结点上,故我们可以直接在树上遍历,所以我们的求和可以基于树来进行:
Obj(t)≈∑i=1n[gift(xi)+12hift2(xi)]+Ω(ft)≈∑i=1n[gift(xi)+12hift2(xi)]+γT+12λ∑j=1Twj2=∑j=1T[(∑i∈Ijgi)wj+12(∑i∈Ijhi+λ)wj2]+γTObj(t)\approx \sum_{i=1}^{n}[g_{i}f_{t}(x_{i})+\frac{1}{2}h_{i}f{t}^{2}(xi)]+\Omega(f_{t})\approx \sum_{i=1}^{n}[g_{i}f_{t}(x_{i})+\frac{1}{2}h_{i}f{t}^{2}(xi)]+\gamma T+\frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^{2}=\sum_{j=1}^{T}[(\sum_{i\in I_{j}}g_{i})w_{j}+\frac{1}{2}(\sum_{i\in I_{j}}h_{i}+\lambda )w_{j}^{2}]+\gamma TObj(t)i=1n[gift(xi)+21hift2(xi)]+Ω(ft)i=1n[gift(xi)+21hift2(xi)]+γT+21λj=1Twj2=j=1T[(iIjgi)wj+21(iIjhi+λ)wj2]+γT
=∑j=1T[Gjwj+12(Hj+λ)wj2]+γT\sum_{j=1}^{T}[G_{j}w_{j}+\frac{1}{2}(H_{j}+\lambda )w^{2}_{j}]+\gamma Tj=1T[Gjwj+21(Hj+λ)wj2]+γT
每棵树的损失函数对wjw_{j}wj进行偏导令其为零,有Gj+(Hj+λ)wj=0G_{j}+(H_{j}+\lambda)w_{j}=0Gj+(Hj+λ)wj=0
所以wj=−GjHj+λw_{j}=-\frac{G_{j}}{H_{j}+\lambda}wj=Hj+λGj
带回原目标函数
Obj=−12∑j=1TGj2Hj+λ+λTObj=-\frac{1}{2}\sum_{j=1}^{T}\frac{G_{j}^{2}}{H_{j}+\lambda}+\lambda TObj=21j=1THj+λGj2+λT
. sklearn中的使用

# -*- coding: utf-8 -*-
"""
Created on Tue Dec  4 20:48:14 2018

@author: muli
"""

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


from sklearn.model_selection import train_test_split
from sklearn import metrics
from  sklearn.datasets  import  make_hastie_10_2
from xgboost.sklearn import XGBClassifier

# make_hastie_10_2:
#    产生一个相似的二元分类器数据集,有10个维度
X, y = make_hastie_10_2(random_state=0)
# X:(12000, 10)
# y:(12000,)

# test_size测试集合所占比例
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
clf = XGBClassifier(
        #树的个数
        n_estimators=100,
        # 如同学习率
        learning_rate= 0.3, 
        # 构建树的深度,越大越容易过拟合    
        max_depth=6, 
        # 随机采样训练样本 训练实例的子采样比
        subsample=1, 
        # 用于控制是否后剪枝的参数,越大越保守,一般0.1、0.2这样子
        gamma=0, 
        # 控制模型复杂度的权重值的L2正则化项参数,参数越大,模型越不容易过拟合。
        reg_lambda=1,  
        
        #最大增量步长,我们允许每个树的权重估计。
        max_delta_step=0,
        # 生成树时进行的列采样 
        colsample_bytree=1, 

        # 这个参数默认是 1,是每个叶子里面 h 的和至少是多少,对正负样本不均衡时的 0-1 分类而言
        # 假设 h 在 0.01 附近,min_child_weight 为 1 意味着叶子节点中最少需要包含 100 个样本。
        #这个参数非常影响结果,控制叶子节点中二阶导的和的最小值,该参数值越小,越容易 overfitting。
        min_child_weight=1, 

        #随机种子
        seed=1000 
        
        # L1 正则项参数
#        reg_alpha=0,
        
        #如果取值大于0的话,在类别样本不平衡的情况下有助于快速收敛。平衡正负权重
        #scale_pos_weight=1,
        
        #多分类的问题 指定学习任务和相应的学习目标
        #objective= 'multi:softmax', 
        
        # 类别数,多分类与 multisoftmax 并用
        #num_class=10,
        
        # 设置成1则没有运行信息输出,最好是设置为0.是否在运行升级时打印消息。
#        silent=0 ,
        # cpu 线程数 默认最大
#        nthread=4,
    
        #eval_metric= 'auc'
)

# 模型 训练
clf.fit(X_train,y_train,eval_metric='auc')
# 预测值
y_pred=clf.predict(X_test)
# 真实值 赋值
y_true= y_test

# 计算精度
print("Accuracy : %.4g" % metrics.accuracy_score(y_true, y_pred))
#运行结果 
Accuracy : 0.9258


### Python 极度梯度提升(XGBoost) **XGBoost**(Extreme Gradient Boosting)是一种基于决策树的集成学习方法,它在许多机器学习竞赛中表现出色,尤其是在结构化或表格型数据方面。XGBoost 通过一系列弱分类器(通常是浅层决策树)构建出强分类器,并利用梯度提升框架优化损失函数。 以下是 XGBoost 的一些关键特点: 1. **高效性能**: 相比于传统的 GBDT 算法,在内存消耗、计算速度等方面都有显著改进; 2. **正则化项**: 内置L1/L2 正则化,防止过拟合现象发生; 3. **并行处理支持**: 支持多核 CPU 上的任务分发,极大提高了训练效率; 4. **自定义目标函数和评价指标**: 用户可以根据实际需求设计特定的目标函数以及评估标准; 5. **缺失值处理机制**: 自动检测到特征中的空缺部分并在分裂节点时作出合理判断; 安装 XGBoost 非常简单,只需运行 pip install xgboost 即可完成环境配置工作。 接下来是一个简单的例子演示如何使用 XGBoost 进行二元分类任务: ```python # 导入必要的库 import xgboost as xgb from sklearn.model_selection import train_test_split from sklearn.datasets import make_classification from sklearn.metrics import accuracy_score # 创建模拟数据集 X, y = make_classification(n_samples=1000, n_features=20, n_informative=2, n_redundant=10, random_state=42) # 划分训练集与测试集 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42) # 定义DMatrix数据格式给xgboost使用 dtrain = xgb.DMatrix(X_train, label=y_train) dtest = xgb.DMatrix(X_test, label=y_test) # 设置参数字典 params = { 'objective': 'binary:logistic', # 对应于二元逻辑回归的问题设置 'eval_metric': ['error'], # 错误率作为评估指标之一 } # 训练模型 model = xgb.train(params=params, dtrain=dtrain, num_boost_round=10) # 测试预测效果 y_pred_probabilities = model.predict(dtest) > 0.5 accuracy = accuracy_score(y_test, y_pred_probabilities.astype(int)) print("Accuracy:", round(accuracy * 100, 2), "%") ``` 这段代码展示了基本的工作流程 - 包括准备数据、创建 DMatrix 格式的输入文件、指定超参并通过 `train()` 函数启动迭代过程最后评估结果质量等步骤。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值