sklearn与XGBoost

最新推荐文章于 2024-09-07 09:42:54 发布

momokofly

最新推荐文章于 2024-09-07 09:42:54 发布

阅读量6k

点赞数 7

分类专栏：机器学习文章标签： sklearn

本文链接：https://blog.csdn.net/momokofly/article/details/122780716

版权

1 在学习XGBoost之前

1.1 xgboost库与XGB的sklearn API

陈天奇创造了XGBoost算法后，很快和一群机器学习爱好者建立了专门调用XGBoost库，名为xgboost。xgboost是一个独立的、开源的，并且专门提供梯度提升树以及XGBoost算法应用的算法库。它和sklearn类似，有一个详细的官方网站可以提供学习资料，并且可以与C、Python、R、Julia等语言连用，但需要单独安装和下载。
xgboost documents：https://xgboost.readthedocs.io/en/latest/index.html
本文基于Pythonl来运行。xgboost库要求必须提供适合的Scipy环境。接下来提供在windows中使用pip安装xgboost的代码：

pip install xgboost  #安装xgboost库
pip install --upgrade xgboost   #更新xgboost库

安装完毕之后，就能够使用这个库中所带的XGB相关的类了。

import xgboost as xgb

现在有两种方式来使用xgboost库。第一种方式，是直接使用xgboost库自己的建模流程。
在这里插入图片描述
其中最核心的是DMatrix这个读取数据的类，以及train()这个用于训练的类。与sklearn把所有的参数都写在类中的方式不同，xgboost库中必须先使用字典设定参数集，再使用train来将参数集输入，然后进行训练。会这样设计的原因，是因为XGB所涉及到的参数实在太多，全部写在xgb.train()太长也容易出错。下面给出params可能的取值以及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库中的sklearn中的API。这就是说，可以调用如下的类，并用sklearn当中的惯例的实例化，fit和predict的流程来运行XGB，并且也可以调用属性（比如coef_）等等。当然，这是回归的类，也有用于分类、排序的类。他们与回归的类非常相似，因此了解一个类即可。
xgboost.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.train和调用sklearn API中的类XGBRegressor，需要输入的参数是不同的，而且看起来相当的不同。但其实，这些参数只是写法不同，功能是相同的。如params字典中的第一个参数eta，其实就是XGBRegressor里面的参数learning_rate，他们的含义和实现的功能是一模一样的。只不过在sklearn API中，开发团队友好的将参数的名称调节成了与sklearn中其他算法类更相似的样子。
所以，使用xgboost中设定的建模流程来建模，和使用sklearn API中的类来建模，模型效果是比较相似的，但是xgboost库本身的运算速度（尤其是交叉验证）以及调参手段比sklearn要简单。

1.2 XGBoost的三大板块

XGBoost本身的核心是基于梯度提升树实现的集成算法，整体来说可以有三个核心部分：集成算法本身，用于集成的弱评估器，以及应用中的其他过程。三个部分中，前两个部分包含了XGBoost的核心原理以及数学过程，最后的部分主要是在XGBoost应用中占有一席之地。

参数	集成算法	弱评估器	其他过程
n_estimators	$\ast$
learning_rate	$\ast$
silent(verbosity)	$\ast$
subsample	$\ast$
max_depth		$\ast$
objective		$\ast$
booster		$\ast$
gamma		$\ast$
min_child_weight		$\ast$
max_delta_step		$\ast$
colsample_bytree		$\ast$
colsample_bylevel		$\ast$
reg_alpha		$\ast$
reg_lambda		$\ast$
nthread			$\ast$
n_jobs			$\ast$
scale_pos_weight			$\ast$
base_score			$\ast$
seed			$\ast$
random_state			$\ast$
missing			$\ast$
importance_type			$\ast$

2 梯度提升树

2.1 提升集成算法：重要参数n_estimators

XGBoost的基础是梯度提升算法，因此必须先从了解梯度提升算法开始。梯度提升（Gradient boosting）算法是构建预测模型的最强大技术之一，它是集成算法中提升法（Boosting）的代表算法。集成算法通过在数据集上建立多个弱评估器，汇总所有弱评估器的预测模型，以获取比单个模型更好的回归或分类表现。弱评估器被要求至少比随机猜测更好的模型，即预测准确度不低于50%的任意模型。
集成不同弱评估器的方法有很多种，有一次性建立多个平行独立的弱评估器的装袋法（Bagging），也有逐一构建弱评估器，经过多次迭代逐渐累积多个弱评估器的提升法（Boosting）。提升法中最著名的算法包括Adaboost和梯度提升树，XGBoost就是由梯度提升树发展而来的。梯度提升树中可以有回归树也可以有分类树，两者都是以CART树算法作为主流，XGBoost背后也是CART树，这意味着XGBoost中所有的树都是二叉的。以梯度提升回归树为例，了解一下Boosting算法的工作原理。
首先梯度提升回归树是专注于回归的树模型的提升集成模型，其建模过程大致如下：最开始先建立一棵树，然后逐渐迭代，每次迭代过程中都增加一棵树，逐渐形成众多树模型集成的强评估器。

对于决策树而言，每个被放入模型的任意样本 $i$ 最终一定都会落到一个叶子节点上。而对于回归树，每个叶子节点上的值是这个叶子节点上所有样本的均值。

对于梯度提升树回归树来说，每个样本的预测结果可以表示为所有树上的结果的加权求和： $\hat y_i^{(k)}=\sum_k^K\gamma_kh_k(x_i)$
其中， $K$ 是树的总数量， $k$ 代表第 $k$ 棵树， $\gamma_k$ 是这棵树的权重， $h_k$ 表示这棵树上的预测结果。
值得注意的是，XGB作为GBDT的改进，在 $\hat y$ 上却有所不同。对于XGB来说，每个叶子节点上会有一个预测分数（prediction score），也被称为叶子权重。这个叶子权重就是所有在这个叶子节点上的样本在这一棵树上的回归取值，用 $f_k(x_i)$ 或者 $w$ 来表示，其中 $f_k$ 表示第 $k$ 棵决策树， $x_i$ 表示样本 $i$ 对应的特征向量。当只有一棵树的时候， $f_1(x_i)$ 就是提升集成算法返回的结果，但这个结果往往非常糟糕。当有多棵树的时候，集成模型的回归结果就是所有树的预测分数之和，假设这个集成模型中总共有 $K$ 棵决策树，则整个模型在这个样本 $i$ 上给出的预测结果为： $\hat y_i^{(k)}=\sum_k^Kf_k(x_i)$

XGB和GBDT核心区别1：求解预测值 $\hat y$ 的方式不同
GBDT中预测值是由所有弱分类器上的预测结果的加权求和，其中每个样本上的预测结果就是样本所在的叶子节点的均值。而GBDT中的预测值是所有弱分类器上的叶子权重直接求和得到，计算叶子权重是一个复杂的过程。

从上式来看，在集成中需要考虑的第一件事是超参数 $K$ ，究竟要建多少棵树？

参数含义	xgb.train()	xgb.XGBRegressor()
集成中弱评估器的数量	num_round，默认为10	n_estimators，默认为100
训练者是否打印每次训练的结果	silent，默认为False	silent，默认True

在最新版本的xgboost中没有参数silent，改为verbosity，可以取值0-3，其中取0时表示silent。
在随机森林中理解n_estimators：n_estimators越大，模型的学习能力就会越强，模型也越容易过拟合。在随机森林中，调整的第一个参数就是n_estimators，这个参数非常强大，常常能够一次性将模型调整到极限。在XGB中，也期待相似的表现，虽然XGB的集成方式与随机森林不同，但使用更多的弱分类器来增强模型整体的学习能力这件事是一致的。

#导入需要的库，模块以及数据
from xgboost import XGBRegressor as XGBR
from sklearn.ensemble import RandomForestRegressor as RFR
from sklearn.linear_model import LinearRegression as LinearR
from sklearn.datasets import load_boston
from sklearn.model_selection import KFold,cross_val_score as CVS,train_test_split as TTS
from sklearn.metrics import mean_squared_error as MSE
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from time import time
import datetime

data = load_boston()#波士顿数据集非常简单，但它涉及到的问题却很多
#data
x = data.data
y = data.target
x.shape
#结果：(506, 13)
y.shape
#结果：(506,)

#建模，查看其他接口和属性
xtrain,xtest,ytrain,ytest = TTS(x,y,test_size = 0.3, random_state = 420)
reg = XGBR(n_estimators = 100).fit(xtrain,ytrain)#训练
reg.predict(xtest)#传统接口predict
'''
结果：
array([ 6.6689262, 22.34918  , 31.052807 , 13.911595 ,  9.467966 ,
       22.658588 , 14.514282 , 15.092699 , 15.293644 , 12.680115 ,
       24.140797 , 35.890083 , 21.573483 , 27.07066  , 19.052658 ,
        9.89033  , 23.386076 , 23.588493 , 23.311466 , 22.401644 ,
       18.98444  , 15.766946 , 25.8352   , 20.193802 , 19.982517 ,
       15.611423 , 22.883228 , 29.838228 , 22.815304 , 16.779037 ,
       37.13194  , 20.133305 , 19.67352  , 23.525528 , 22.845137 ,
       23.87397  , 15.17887  , 23.45934  , 16.685331 , 31.761686 ,
       18.525843 , 22.441063 , 38.48728  , 17.93719  , 15.10122  ,
       28.980541 , 46.363487 , 12.842797 ,  9.618281 , 35.40579  ,
       25.657566 , 20.605602 , 20.800055 , 49.228447 , 31.355848 ,
       29.382515 , 18.911947 , 21.049877 , 16.165182 , 18.098577 ,
       14.659002 , 21.720213 , 19.413454 , 28.932102 , 30.573524 ,
       19.228426 , 20.531511 , 15.666289 , 23.52929  , 19.30554  ,
       28.384985 , 42.83562  , 29.429724 , 23.306015 , 19.741224 ,
       24.202463 , 38.735516 , 26.782232 , 22.168324 , 20.67139  ,
       19.534992 , 47.360317 , 24.008802 ,  8.184814 , 25.613977 ,
       20.691843 , 17.127483 , 21.10027  , 22.279167 ,  7.755469 ,
       20.0476   , 15.406112 , 42.38165  , 33.828186 , 22.788246 ,
        9.302419 , 10.416187 , 20.033014 ,  8.241165 , 12.816478 ,
       30.793974 , 10.078776 , 25.383692 , 21.933594 , 30.53568  ,
       42.866497 , 19.598145 ,  8.321976 , 23.194368 , 12.547767 ,
       46.838867 , 22.961082 , 20.244467 , 23.170694 , 18.948856 ,
       29.682056 , 24.363865 , 19.715958 , 44.975193 , 17.64582  ,
       24.3169   , 24.946495 , 18.23235  , 16.922577 , 14.77714  ,
       21.757038 , 33.83876  , 10.938419 , 20.035763 , 21.085218 ,
       19.331562 , 20.505526 ,  8.285518 , 28.01946  , 29.631227 ,
       19.908175 , 18.30325  , 14.204149 , 10.795732 , 18.232307 ,
       42.266888 , 17.304502 , 22.974121 , 20.946724 , 30.724297 ,
       20.072989 , 12.772859 , 41.472908 , 27.652838 , 22.20476  ,
       14.235871 , 25.88964  ], dtype=float32)
'''
reg.score(xtest,ytest)#R^2，shift+tab可以看函数具体原理
#结果：0.9050988968414799
MSE(ytest,reg.predict(xtest))
#结果：8.830916343629323
reg.feature_importances_#树模型的优势之一：能够查看模型的重要性分数，可以使用嵌入法(SelectFromModel)进行特征选择
'''
结果：
array([0.01902167, 0.0042109 , 0.01478316, 0.00553537, 0.02222196,
       0.37914088, 0.01679686, 0.0469872 , 0.04073574, 0.05491759,
       0.06684221, 0.00869464, 0.3201119 ], dtype=float32)
'''
#交叉验证，与线性回归&随机森林回归进行对比
reg = XGBR(n_estimators = 100)#交叉验证中导入没有经过训练的模型
CVS(reg,xtrain,ytrain,cv = 5).mean()#这里返回的模型评估指标是R^2
#严谨的交叉验证与不严谨的交叉验证之间的讨论：训练集 or 全数据？
#结果：0.7995062821902295
CVS(reg,xtrain,ytrain,cv = 5,scoring = "neg_mean_squared_error").mean()
#结果：-16.215644229762717
#来查看一下sklearn中所有的模型评估指标
import sklearn
sorted(sklearn.metrics.SCORERS.keys())
'''
结果：
['accuracy',
 'adjusted_mutual_info_score',
 'adjusted_rand_score',
 'average_precision',
 'balanced_accuracy',
 'completeness_score',
 'explained_variance',
 'f1',
 'f1_macro',
 'f1_micro',
 'f1_samples',
 'f1_weighted',
 'fowlkes_mallows_score',
 'homogeneity_score',
 'jaccard',
 'jaccard_macro',
 'jaccard_micro',
 'jaccard_samples',
 'jaccard_weighted',
 'max_error',
 'mutual_info_score',
 'neg_brier_score',
 'neg_log_loss',
 'neg_mean_absolute_error',
 'neg_mean_absolute_percentage_error',
 'neg_mean_gamma_deviance',
 'neg_mean_poisson_deviance',
 'neg_mean_squared_error',
 'neg_mean_squared_log_error',
 'neg_median_absolute_error',
 'neg_root_mean_squared_error',
 'normalized_mutual_info_score',
 'precision',
 'precision_macro',
 'precision_micro',
 'precision_samples',
 'precision_weighted',
 'r2',
 'rand_score',
 'recall',
 'recall_macro',
 'recall_micro',
 'recall_samples',
 'recall_weighted',
 'roc_auc',
 'roc_auc_ovo',
 'roc_auc_ovo_weighted',
 'roc_auc_ovr',
 'roc_auc_ovr_weighted',
 'top_k_accuracy',
 'v_measure_score']
'''
#使用随机森林和线性回归进行一个对比
rfr = RFR(n_estimators = 100)
CVS(rfr,xtrain,ytrain,cv = 5).mean()
#结果：0.7922215794897552
CVS(rfr,xtrain,ytrain,cv = 5,scoring = "neg_mean_squared_error").mean()
#结果：-16.71229234925553
lr = LinearR()
CVS(lr,xtrain,ytrain,cv = 5).mean()
#结果：0.6835070597278079
CVS(lr,xtrain,ytrain,cv = 5,scoring = "neg_mean_squared_error").mean()
#结果：-25.349507493648463
#如果开启参数silent：在数据巨大，预料到算法运行会非常缓慢的时候可以使用这个参数来监控模型的训练进度
#最新版本的sklearn中的XGBR的参数中没有silent这一参数，改为verbosity
#verbosity : Optional[int]        The degree of verbosity. Valid values are 0 (silent) - 3 (debug).
reg = XGBR(n_estimators = 10, verbosity = 0)
CVS(reg,xtrain,ytrain,cv = 5,scoring = 'neg_mean_squared_error').mean()
#结果为：-18.633733952333067

#定义绘制以训练样本数为横坐标的学习曲线的函数
def plot_learning_curve(estimator, title, x, y
                       ,ax = None  #选择子图
                       ,ylim = None  #设置纵坐标的取值范围
                       ,cv = None  #交叉验证
                       ,n_jobs = None  #设定索要使用的线程
                       ):
    from sklearn.model_selection import learning_curve
    import matplotlib.pyplot as plt
    import numpy as np
    train_sizes, train_scores, test_scores = learning_curve(estimator, x, y
                                                           ,shuffle = True
                                                           ,cv = cv
                                                           #,random_state = 420
                                                            #random_state固定时绘制的图像不会每次运行都变化
                                                           ,n_jobs = n_jobs)
    if ax == None:
        ax = plt.gca()
    else:
        ax = plt.figure()
    ax.set_title(title)
    if ylim is not None:
        ax.set_ylim(*ylim)
    ax.set_xlabel("Training examples")
    ax.set_ylabel("Score")
    ax.grid()#绘制网格，不是必须
    ax.plot(train_sizes, np.mean(train_scores, axis = 1),"o-", color = "r", label = "Training score")
    ax.plot(train_sizes, np.mean(test_scores,axis = 1), "o-", color = "g", label = "Test score")
    ax.legend(loc = "best")
    return ax
#使用学习曲线观察XGB在波士顿数据集上的潜力
cv = KFold(n_splits = 5, shuffle = True, random_state = 42)#交叉验证模式
plot_learning_curve(XGBR(n_estimators = 100, random_state = 420)
                   ,"XGB", xtrain,ytrain,ax = None,cv = cv)
plt.show()
#多次运行，观察结果，这是怎么造成的？——random_state
#在现在的状况下，如何看数据的潜力，还能调上去吗？

在这里插入图片描述
训练集上的表现展示了模型的学习能力，测试集上的表现展示了模型的泛化能力，通常模型在测试集上的表现不太可能超过训练集，因此希望测试集的学习曲线能够努力逼近训练集的学习曲线。观察三种学习曲线组合：希望将模型调整成什么样？能够将模型调整成什么样？

#使用参数学习曲线观察n_estimators对模型的影响
axisx = range(10,1010,50)
rs = []
for i in axisx:
    reg = XGBR(n_estimators = i, random_state = 420)
    rs.append(CVS(reg,xtrain,ytrain,cv = cv).mean())
print(axisx[rs.index(max(rs))],max(rs))
plt.figure(figsize = (20,5))
plt.plot(axisx,rs,c = "red",label = "XGB")
plt.legend()
plt.show()
#选出来的n_estimators非常不寻常，是否要选择准确率最高的n_estimators值呢？
#结果为：160 0.8320776498992342

在这里插入图片描述
进化的学习曲线：方差与泛化误差
在随机森林中有方差-偏差困境。在机器学习中，用来衡量模型在未知数据上的准确率的指标，叫做泛化误差（Genelization error）。一个集成模型(f)在未知数据集(D)上的泛化误差 $E (f; D)$ ，由方差(var)，偏差(bias)和噪声(e)共同决定。其中偏差就是训练集上的拟合程度决定，方差是模型的稳定性决定，噪音是不可控的。而泛化误差越小，模型就越理想。
$E(f;D)=bias^2+var+e^2$
过去往往直接取学习曲线获得的分数的最高点，即考虑偏差最小的点，是因为模型极度不稳定，方差很大的情况其实比较少见。但是现在的数据量非常少，模型会相对不稳定，因此应当方差也纳入考虑的范围。在绘制学习曲线时，不仅要考虑偏差的大小，还要考虑方差的大小，更要考虑泛化误差中可控的部分。当然，并不是说可控的部分比较小，整体的泛化误差就一定小，因为误差有时候可能占主导。基于这种思路改进学习曲线：

axisx = range(50,1050,50)
rs = []
var = []
ge = []
for i in axisx:
    reg = XGBR(n_estimators = i, random_state = 420)
    cvresult = CVS(reg, xtrain, ytrain, cv = cv)
    #记录  1-偏差
    rs.append(cvresult.mean())
    #记录  方差
    var.append(cvresult.var())
    #计算泛化误差的可控部分
    ge.append((1-cvresult.mean())**2 + cvresult.var())
#打印R2最高所对应的参数取值，并打印这个参数下的方差
print(axisx[rs.index(max(rs))], max(rs), var[rs.index(max(rs))])
#打印方差最低时对应的参数取值，并打印这个参数下的R2
print(axisx[var.index(min(var))], rs[var.index(min(var))], min(var))
#打印泛化误差可控部分的参数取值，并打印这个参数下的R2，方差以及泛化误差的可控部分
print(axisx[ge.index(min(ge))], rs[ge.index(min(ge))], var[ge.index(min(ge))], min(ge))
plt.figure(figsize = (20,5))
plt.plot(axisx, rs, c = "red", label = "XGB")
plt.legend()
plt.show()
'''
结果：
100 0.8320924293483107 0.005344212126112929
100 0.8320924293483107 0.005344212126112929
100 0.8320924293483107 0.005344212126112929 0.03353716440826495
'''

在这里插入图片描述

#细化学习曲线，找出最佳n_estimators
axisx = range(50,250,10)
rs = []
var = []
ge = []
for i in axisx:
    reg = XGBR(n_estimators = i, random_state = 420)
    cvresult = CVS(reg, xtrain, ytrain, cv = cv)
    rs.append(cvresult.mean())
    var.append(cvresult.var())
    ge.append((1-cvresult.mean())**2 + cvresult.var())
print(axisx[rs.index(max(rs))], max(rs), var[rs.index(max(rs))])
print(axisx[var.index(min(var))], rs[var.index(min(var))], min(var))
print(axisx[ge.index(min(ge))], rs[ge.index(min(ge))], var[ge.index(min(ge))], min(ge))
rs = np.array(rs)
var = np.array(var)*0.01
plt.figure(figsize = (20,5))
plt.plot(axisx,rs,c = "black",label = "XGB")
#添加方差线
plt.plot(axisx, rs+var, c = "red", linestyle = "-.")
plt.plot(axisx, rs-var, c = "red", linestyle = "-.")
plt.legend()
plt.show()
'''
结果：
100 0.8320924293483107 0.005344212126112929
100 0.8320924293483107 0.005344212126112929
100 0.8320924293483107 0.005344212126112929 0.03353716440826495
'''

在这里插入图片描述

#看看泛化误差的可控部分如何？
plt.figure(figsize = (20,5))
plt.plot(axisx, ge, c = "gray", linestyle = "-.")
plt.show()

在这里插入图片描述

#检测模型效果是否提高了？
time0 = time()
print(XGBR(n_estimators = 10, random_state = 420).fit(xtrain, ytrain).score(xtest,ytest))
print(time()-time0)
'''
结果：
0.8894915063570491
0.02552485466003418
'''
time0 = time()
print(XGBR(n_estimators = 100, random_state = 420).fit(xtrain, ytrain).score(xtest,ytest))
print(time()-time0)
'''
结果：
0.9050988968414799
0.17356395721435547
'''

从这个过程中观察n_estimators参数对模型的影响，可以得出以下结论：
首先，XGB中的树的数量决定了模型的学习能力，树的数量越多，模型的学习能力越强。只要XGB中树的数量足够了，即便只有很少的数据，模型也能够学到训练数据100%的信息，所以XGB也是天生过拟合的模型。但在这种情况下，模型会变得非常不稳定。
第二，XGB中树的数量很少的时候，对模型的影响较大，当树的数量已经很多的时候，对模型的影响比较小，只能有微弱的变化。当数据本身就处于过拟合的时候，再使用过多的树能达到的效果甚微，反而浪费计算资源。当唯一指标 $R^2$ 或者准确率给出的n_estimators看起来不太可靠的时候，可以改造学习曲线来帮助选择参数。
第三，树的数量提升对模型的影响有极限，最开始，模型的表现会随着XGB的树的数量一起提升，但到达某个点之后，树的数量越多，模型的效果会逐步下降，这也说明了暴力增加n_estimators不一定有效果。
这些都和随机森林中的参数n_estimators表现出一致的状态。在随机森林中总是先调整n_estimators，当n_estimators的极限已达到，才考虑其他参数，但XGB中的状况明显更加复杂，当数据集不太寻常的时候会更加复杂，这是要给出的第一个超参数，因此还是建议优先调整n_estimators，一般都不会建议一个太大的数目，300以下为佳。

2.2 有放回随机抽样：重要参数subsample

确认了有多少棵树之后，来思考一个问题：建立了众多的树，怎么能够保证模型整体的效果变强呢？集成的目的是为了模型在样本上能表现出更好的效果，所以对于所有的提升集成算法，每构建一个评估器，集成模型的效果都会比之前更好。也就是随着迭代的进行，模型整体的效果必须要逐渐提升，最后要实现集成模型的效果最优，要实现这个目标，可以首先从训练数据上着手。
训练模型之前，必然会有一个巨大的数据集。都知道树模型是天生过拟合的模型，并且如果数据量太大，树模型的计算会非常缓慢。因此，要对原始数据集进行有放回抽样（bootstrap）。有放回的抽样每次只能抽取一个样本，若需要总共N个样本，就需要抽取N次。每次抽取一个样本的过程是独立的，这一次被抽到的样本会被放回数据集中，下一次还可能被抽到，因此抽出的数据集中，可能有一些重复的数据。
在这里插入图片描述
在无论是装袋还是提升的集成算法中，有放回抽样都是防止过拟合，让单一弱分类器变得更轻量的必要操作。实际应用中，每次抽取50%左右的数据就能够有不错的效果了。sklearn的随机森林类中也有名为bootstrap的参数来帮助控制这种随机有放回抽样。同时，这样做还可以保证集成算法中的每个弱分类器（每棵树）都是不同的模型，基于不同的数据集建立的自然是不同的模型，而集成一系列一模一样的弱分类器是没有意义的。
在梯度提升树中，每一次迭代都要建立一棵新的树，因此每次迭代中，都要有放回抽取一个新的训练样本。不过，这并不能保证每次建新树后，集成的效果都比之前要好。因此我们规定，这梯度提升树中，每构建一个评估器，都让模型更加集中于数据集中容易被判错的那些样本。
在这里插入图片描述
首先有一个巨大的数据集，在建第一棵树时，对数据进行初次有放回抽样，然后建模。建模完毕后，对模型进行一个评估，然后将模型预测错误的样本反馈给数据集，一次迭代就算完成。紧接着，建立第二棵决策树，于是开始进行第二次有放回抽样。但这次有放回抽样和初次的随机有放回抽样不同，在这次的抽样中，加大了被第一棵树判断错误的样本的权重。也就是说，被第一棵树判断错误的样本，更有可能被抽中。
基于这个有权者的训练集来建模，新建的决策树就会更加倾向于这些权重更大的，很容易被判错的样本。建模完毕之后，又将判错的样本反馈给原始数据集，下一次迭代的时候，被判错的样本的权重会更大，新的模型会更加倾向于很难被判断的这些样本，如此反复迭代，越后面建的树，越是之前的树们判错样本上的专家，越专注于攻克那些之前的树们不擅长的数据。对于一个样本而言，它被预测错误的次数越多，被加大权重的次数也就越多。相信只要弱分类器足够强大，随着模型整体不断在被判错的样本上发力，这些样本会渐渐被判断正确。如此就一定程度上实现了每新建一棵树模型的效果都会提升的目标。
在sklearn中，使用参数subsample来控制随机抽样。在xgb和sklearn中，这个参数都默认为1且不能取到0，这说明无法控制模型是否进行随机有放回抽样，只能控制抽样抽出来的样本量大概是多少。

参数含义	xgb.train()	xgb.XGBRegressor()
随机抽样的时候抽取的样本比例，范围(0,1]	subsample，默认为1	subsample，默认为1

那除了让模型更加集中于那些困难样本，采样还对模型造成了什么样的影响？采样会减少样本数量，而从学习曲线来看样本数量越少模型的过拟合会越严重，因为对模型来说，数据量越少模型学习越容易，学到的规则也会越具体越不适用于测试样本。所以subsample参数通常是在样本量本身很大的时候来调整和使用。
模型现在正处于样本量过少并且过拟合的状态，根据学习曲线展现出来的规律，训练样本量在200左右的时候，模型的效果有可能反而比更多训练数据的时候好，但这并不代表模型的泛化能力在更小的训练样本量下会更强。正常来说样本量越大，模型才不容易过拟合，现在展现出来的效果，是由于样本量太小造成的一个巧合。从这个角度来看，subsample参数对模型的影响应该会非常不稳定，大概率应该是无法提升模型的泛化能力的，但也不乏提升模型的可能性。依然使用波士顿房价数据集，来看学习曲线：

axisx = np.linspace(0,1,20)
rs = []
for i in axisx:
    reg = XGBR(n_estimators = 100,subsample = i, random_state = 420)
    rs.append(CVS(reg,xtrain,ytrain,cv = cv).mean())
print(axisx[rs.index(max(rs))],max(rs))
plt.figure(figsize = (20,5))
plt.plot(axisx,rs,c = "green", label = "XGB")
plt.legend()
plt.show()
#结果：1.0 0.8320924293483107

在这里插入图片描述

#继续细化学习曲线
axisx = np.linspace(0.05,1,20)
rs = []
var = []
ge = []
for i in axisx:
    reg = XGBR(n_estimators = 100, subsample = i, random_state = 420)
    cvresult = CVS(reg,xtrain,ytrain,cv = cv)
    rs.append(cvresult.mean())
    var.append(cvresult.var())
    ge.append((1-cvresult.mean())**2 + cvresult.var())
print(axisx[rs.index(max(rs))], max(rs), var[rs.index(max(rs))])
print(axisx[var.index(min(var))], rs[var.index(min(var))], min(var))
print(axisx[ge.index(min(ge))], rs[ge.index(min(ge))], var[ge.index(min(ge))], min(ge))
rs = np.array(rs)
var = np.array(var)
plt.figure(figsize = (20,5))
plt.plot(axisx,rs,c = "black", label = "XGB")
plt.plot(axisx,rs+var,c = "red",linestyle = "-.")
plt.plot(axisx,rs-var,c = "red",linestyle = "-.")
plt.legend()
plt.show()
'''
结果：
1.0 0.8320924293483107 0.005344212126112929
0.75 0.8173142984564995 0.0026778019326057657
1.0 0.8320924293483107 0.005344212126112929 0.03353716440826495
'''
#不要盲目找寻泛化误差可控部分的最低值，注意观察结果

在这里插入图片描述

#看看泛化误差的情况如何
reg = XGBR(n_estimators = 100
          ,subsample = 1.0
          ,random_state = 420).fit(xtrain,ytrain)
reg.score(xtest,ytest)
#结果：0.9050988968414799
MSE(ytest,reg.predict(xtest))
#结果：MSE(ytest,reg.predict(xtest))

参数选择的结果再预料之中，总体来说选择的这个参数还是使用全部训练数据集，这是由于数据量过少，降低抽样的比例反而会让数据的效果降低。

2.3 迭代决策树：重要参数eta

从数据的角度而言，让模型更加倾向于努力攻克那些难以判断的样本。但是，并不是说只要新建了一棵倾向于困难样本的决策树，它就能够帮助把困难样本判断正确。困难样本被加重权重是因为前面的树没有把它判断正确，所以对于下一棵树来说，它要判断的测试集的难度，是比之前的树所遇到的数据的难度都要高的，那要把这些样本都判断正确，会越来越难。如果新建的树在判断困难样本这件事上还没有前面的树做得好呢？如果新建的树刚好是一棵特别糟糕的树呢？所以，除了保证模型逐渐倾向于困难样本的方向，还必须控制新弱分类器的生成，必须保证每次新添加的树一定得是对这个新数据集预测效果最优的那一棵树。
思考：怎么保证每次新添加的树一定让集成学习的效果提升？
也许可以枚举？也许可以学习sklearn中的决策树构建树时一样随机生成固定数目的树，然后生成最好的那一棵？
平衡算法表现和运算速度是机器学习的艺术，希望能找出一种方法，直接帮我们求解出最优的集成算法结果。求解最优结果，能否把它转化成一个传统的最优化问题呢？
回顾一下最优化问题的老朋友——逻辑回归模型。在逻辑回归中，有方程：
$\frac{1}{1+e^{-\theta^T \textbf x}}$
目标是求解让逻辑回归的拟合效果最优的参数组合 $\theta$ 。首先找出了逻辑回归的损失函数 $J(\theta)$ ，这个损失函数可以通过带入 $\theta$ 来衡量逻辑回归在训练集上的拟合效果。然后，利用梯度下降来迭代 $\theta$ ：
$\theta_{k+1} = \theta_k-\alpha*d_{ki}$
让第 $k$ 次迭代中的 $\theta_k$ 减去通过步长和特征取值 $x$ 计算出来的一个量，以此来得到 $k + 1$ 次迭代后的参数向量 $\theta_{k+1}$ 。可以让这个过程持续下去，知道找到能够让损失函数最小化的参数 $\theta$ 为止。这是一个最典型的最优化过程。这个过程其实和现在希望做的事是相似的。
在这里插入图片描述
现在希望求解集成算法的最优结果，那应该可以使用同样的思路：首先找到一个损失函数 $O b j$ ，这个损失函数应该可以通过代入预测结果 $\hat y_i$ 来衡量梯度提升树在样本的预测结果。然后，利用梯度下降来迭代集成算法：
$\hat y_i^{(k+1)}=\hat y_i^{(k)}+f_{k+1}(x_i)$
在 $k$ 次迭代后，集成算法中总共有 $k$ 棵树，而前面讲明了， $k$ 棵树的集成结果是前面所有树上的叶子权重的累加 $\sum_k^Kf_k(x_i)$ 。所有让 $k$ 棵树的集成结果 $\hat y_i^{(k)}$ 加上新建的树上的叶子权重 $f_{k+1}(x_i)$ ，就可以得到第 $k + 1$ 次迭代后，总共 $k + 1$ 棵树的预测结果 $\hat y_i^{(k+1)}$ 了。让这个过程持续下去，直到找到能够让损失函数最小化的 $\hat y$ ，这个 $\hat y$ 就是模型的预测结果。参数可迭代，集成的树林也可以迭代。
但要注意，在逻辑回归中参数 $\theta$ 迭代的时候减去的部分是人为规定的步长和梯度相乘的结果。而在GBDT和XGB中，却希望能够求解出让预测结果 $\hat y$ 不断迭代的部分 $f_{k+1}(x_i)$ 。但无论如何，现在已经有了最优化的思路了，只要顺着这个思路求解下去，必然能够在每一个数据集上找到最优的 $\hat y$ 。
在逻辑回归中，自定义步长 $\alpha$ 来干涉迭代速率，在XGB中看起来却没有这样的设置，但其实不然。在XGB中，完整的迭代决策树的公式应该写作：
$\hat y_i^{(k+1)}=\hat y_i^{(k)}+\eta f_{k+1}(x_i)$
其中 $\eta$ 读作“eta”，是迭代决策树时的步长（shrinkage），又叫做学习率（learning rate）。和逻辑回归中的 $\alpha$ 类似， $\eta$ 越大，迭代的速度越快，算法的极限很快就被达到，有可能无法收敛到真正的最佳。 $\eta$ 越小，越有可能找到最精确的最佳值，更多的空间被留给了后面建立的树，但迭代的速度会比较缓慢。
在这里插入图片描述
在sklearn中，使用参数learning_rate来干涉学习速率：

参数含义	xgb.train()	xgb.XGBRegressor()
集成中的学习率，又称为步长，以控制迭代速率，常用于防止过拟合	eta，默认0.3，取值范围(0,1]	learning_rate，默认0.1，取值范围(0,1]

探索一下参数eta的性质：

#首先先来定义一个评分函数，这个评分函数能够帮助我们直接打印xtrain上的交叉验证结果
def regassess(reg,xtrain,ytrain,cv,scoring = ["r2"],show = True):
    score = []
    for i in range(len(scoring)):
        if show:
            print("{}:{:.2f}".format(scoring[i]  #模型评估指标的名字
                                    ,CVS(reg
                                        ,xtrain,ytrain
                                        ,cv = cv, scoring = scoring[i]).mean()))
        score.append(CVS(reg,xtrain,ytrain,cv = cv,scoring = scoring[i]).mean())
    return score
#运行一下函数来看看效果
regassess(reg,xtrain,ytrain,cv,scoring = ["r2","neg_mean_squared_error"])
'''
结果：
r2:0.83
neg_mean_squared_error:-12.11
[0.8320924293483107, -12.108495815458545]
'''
#关闭打印功能试试看
regassess(reg,xtrain,ytrain,cv,scoring = ["r2","neg_mean_squared_error"],show = False)
#结果：[0.8320924293483107, -12.108495815458545]
#观察一下eta如何影响模型
from time import time
import datetime
for i in [0,0.2,0.5,1]:
    time0 = time()
    reg = XGBR(n_estimators = 100, random_state = 420, learning_rate = i)
    print("learning_rate = {}".format(i))
    regassess(reg,xtrain,ytrain,cv,scoring = ["r2","neg_mean_squared_error"])
    print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))
    print("\t")
'''
结果：
learning_rate = 0
r2:-6.76
neg_mean_squared_error:-567.55
00:02:518612
	
learning_rate = 0.2
r2:0.83
neg_mean_squared_error:-12.30
00:03:455323
	
learning_rate = 0.5
r2:0.82
neg_mean_squared_error:-12.48
00:03:074720
	
learning_rate = 1
r2:0.71
neg_mean_squared_error:-20.06
00:02:524670
'''

除了运行时间，步长还是一个对模型效果影响巨大的参数，如果设置太大模型就无法收敛（可能导致 $R^2$ 很小或者MSE很大的情况），如果设置太小模型速度就会非常缓慢，但最后究竟会收敛到何处很难由经验来判定，在训练集上表现出来的模样和在测试集上相差甚远，很难直接探索出一个泛化误差很低的步长。

axisx = np.arange(0.05,1,0.05)
rs = []
te = []
for i in axisx:
    reg = XGBR(n_estimators = 100,random_state = 420,learning_rate = i)
    score = regassess(reg,xtrain,ytrain,cv,scoring = ["r2","neg_mean_squared_error"],show = False)
    test = reg.fit(xtrain,ytrain).score(xtest,ytest)
    rs.append(score[0])
    te.append(test)
print(axisx[rs.index(max(rs))],max(rs))
plt.figure(figsize = (20,5))
plt.plot(axisx,te,c = "gray",label = "test")
plt.plot(axisx,rs,c = "green",label = "train")
plt.legend()
plt.show()
#结果：0.1 0.8347040420775244

在这里插入图片描述
虽然从图上来说，默认的0.1看起来是一个比较理想的情况，并且看起来更小的步长更利于现在的数据，但是无法确定对于其他数据会有怎么样的效果。所以通常不调整 $\eta$ ，即便调整，一般也会在[0.01,0.2]之间变动。如果希望模型的效果更好，更多的可能是从树本身的角度来说，对树进行剪枝，而不会寄希望于调整 $\eta$ 。
梯度提升树是XGB的基础，已经介绍了XGB中与梯度提升树的过程相关的四个参数：n_estimators，learning_rate，silent（verbosity）,subsample。这四个参数的主要目的，其实并不是提升模型表现，更多是了解梯度提升树的原理。现在来看，梯度提升树可以说是由三个重要的部分组成：

一个能够衡量集成算法效果的，能够被最优化的损失函数 $O b j$
一个能够实现预测的弱评估器 $f_k(x)$
一种能够让弱评估器集成的手段，包括讲解的迭代方法，抽样手段，样本加权等等过程
XGBoost是在梯度提升树的这三个核心要素上运行，它重新定义了损失函数和弱评估器，并且对提升算法的集成手段进行了改进，实现了运算速度和模型效果的高度平衡。并且，XGBoost将原本的梯度提升树拓展开来，让XGBoost不再是单纯的树的集成模型，也不只是单单的回归模型。只要调节参数，可以选择任何希望集成的算法，以及任何希望实现的功能。

3 XGBoost的智慧

xgboost.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)

*args -> 指的是普通的参数
** kwargs -> key-value 参数，指的是那种字典参数

3.1 选择弱评估器：重要参数booster

梯度提升算法中不只有梯度提升树，XGB作为梯度提升算法的进化，自然也不只有树模型一种弱评估器。在XGB中，除了树模型，还可以选用线性模型，如逻辑回归、线性回归，来进行集成。虽然主流的XGB依然是树模型，但必须了解可以使用其他的模型。基于XGB的这种性质，有参数"booster"来控制究竟使用怎样的弱评估器。

xgb.train() & params	xgb.XGBRegressor()
xgb_model	booster
使用哪种弱评估器。可以输入gbtree、gblinear或dart。输入的评估器不同，使用的params参数也不同，每种评估器都有自己的params列表。评估器必须与params参数相匹配，否则报错。	使用哪种弱评估器。可以输入gbtree、gblinear或dart。gbtree代表梯度提升树，dart是Dropouts meet Multiple Additive Regression Trees，可译为抛弃提升树，在建树的过程中会抛弃一部分树，比梯度提升树有更好的防过拟合功能。输入gblinear使用线性模型。

两个参数都默认为“gbtree”，如果不想使用树模型，则可以自行调整。当XGB使用线性模型的时候，它的许多数学过程就与使用普通的Boosting集成非常相似，因此以使用更多，也更加核心的基于树模型的XGBoost为主。
简单看看现有的数据集上，是什么样的弱评估器表现更好：

for booster in ["gbtree","gblinear","dart"]:
    reg = XGBR(n_estimators = 100
              ,learning_rate = 0.1
              ,random_state = 420
              ,booster = booster).fit(xtrain,ytrain)
    print(booster)
    print(reg.score(xtest,ytest))
'''
结果：
gbtree
0.9257336963525182
gblinear
0.5988666782512837
dart
0.9257337087151665
'''

3.2 XGB的目标函数：重要参数objective

梯度提升算法中都存在着损失函数，不同于逻辑回归和SVM等算法中固定的损失函数写法，集成算法中的损失函数是可选的，要选用什么损失函数取决于希望解决什么问题，以及希望使用怎样的模型。比如，如果目标是进行回归预测，那可以选择调节后的均方误差RMSE作为损失函数；如果进行分类预测，那可以选择错误率error或者对数损失log_loss。只要选出的函数是一个可微的，能够代表某种损失函数，它就可以是XGB中的损失函数。
在众多机器学习算法中，损失函数的核心是衡量模型的泛化能力，即模型在未知数据上预测的准确与否，训练模型的核心目标也是希望模型能够预测准确。在XGB中，预测准确自然是非常重要的因素，但之前提到过，XGB是实现了模型表现和运算速度的平衡的算法。普通的损失函数，如错误率、均方误差等等，都只能够衡量模型的表现，无法衡量模型的运算速度。在许多模型中，使用空间复杂度和时间复杂度来衡量模型的运算速率。XGB因此引入了模型复杂度来衡量算法的运算效率。因此XGB的目标函数被写作：传统损失函数+模型复杂度。 $\sum_{i=1}^ml(y_i,\hat y_i) + \sum_{k=1}^K\Omega(f_k)$ 其中 $i$ 代表数据集中的第

最低0.47元/天解锁文章