XGBT算法梳理

1. 算法原理
   XGBT中的预测值是所有弱分类器上的叶子权重直接求和得到
   $\widehat{y_i}={\sum }_j{w}_j{x}_{ij}$
   损失函数:$l(y_i,\widehat{y_i})=(y_i-\widehat{y_i}{)}^2$
   XGB的核心是每次迭代都是基于上一次的残差去拟合,大致过程如下
   ${\widehat{y_i}}^{(0)}=0$
   ${\widehat{y_i}}^{(1)}=f_1(x_i)={\widehat{y_i}}^0+f_1(x_i)$
   ${\widehat{y_i}}^{(2)}=f_1(x_i)+f_2(x_i)={\widehat{y_i}}^1+f_2(x_i)$
   …
   ${\widehat{y_i}}^{(t)}={\sum }_{k=1}^t{f}_k(x_i)={\widehat{y_i}}^{(t-1)}+f_t(x_i)$
   这里${\widehat{y_i}}^{(t)}$表示是第t轮的模型预测,$f_t(x_i)$表示加入一个新的函数
   $f_t(x)=w_q(x),w\in R^T,q:R^d\to 1,2,...,T$
   接下来就是f的求解了,每一轮中,我们选取一个f来使得我们的目标函数尽量最大地降低
   $Ob{j}^{(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)+constant$
   $Ob{j}^{(t)}={\sum }_{i=1}^n(y_i-({\widehat{yi}}^{(t-1)}+f_t(x_i)){)}^2+\Omega (f_t)+constant$
   ${\sum }_{i=1}^n[2({\widehat{yi}}^{(t-1)}-y_i)+f_t(x_i{)}^2]+\Omega (f_t)+constant$

• [注 ] 一般我们把${\widehat{yi}}^{(t-1)}-y_i$叫做残差,这里的$\Omega (f_t)=\gamma T+\frac{1}{2}\lambda {\sum }_{j=1}^T{w}_j^2$是正则化处理,
  目标函数由两部分构成，第一部分用来衡量预测分数和真实分数的差距，另一部分则是正则化项。正则化项同样包含两部分，T表示叶子结点的个数，w表示叶子节点的分数。$\gamma$可以控制叶子结点的个数，$\lambda$可以控制叶子节点的分数不会过大，防止过拟合。

下一步,用泰勒展开来近似我们原来的目标函数:${\sum }_{i=1}^{n}l(y_i,{\widehat{y_i}}^{(t-1)}+f_t(x_i))+\Omega (f_t)+constant$
泰勒二阶展开:
$f(x+\Delta x)\approx f(x)+f^{\prime }(x)\Delta x+\frac{1}{2}{f}^{\prime \prime }(x)\Delta x^2$
定义:$g_i=\frac{\partial l(yi,{\hat{y}}^{(t-1)})}{\partial {\hat{y}}^{(t-1)}}$
$h_i=\frac{\partial l(yi,{\hat{y}}^{(t-1)})}{{\partial }^2{\hat{y}}^{(t-1)}}$
$Obj(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)+constant$
进一步化简,因为这里的$l(y_i,{\widehat{y_i}}^{(t-1)})$为常数,故
$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)\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 T$
=${\sum }_{j=1}^T[G_j{w}_j+\frac{1}{2}(H_j+\lambda )w_j^2]+\gamma T$
每棵树的损失函数对$w_j$进行偏导令其为零,有$G_j+(H_j+\lambda )w_j=0$
所以$w_j=-\frac{G_j}{H_j+\lambda }$
带回原目标函数
$Obj=-\frac{1}{2}{\sum }_{j=1}^T\frac{G_j^2}{H_j+\lambda }+\lambda 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