Question

7.1 数据接口

7.1.1 数据格式

1. xgboost 的数据存储在DMatrix 对象中

2. xgboost 支持直接从下列格式的文件中加载数据：

   • libsvm 文本格式的文件。其格式为：

     
     xxxxxxxxxx
      [label] [index1]:[value1] [index2]:[value2] ...
      [label] [index1]:[value1] [index2]:[value2] ...
      ...

   • xgboost binary buffer 文件

   
   xxxxxxxxxx
   dtrain = xgb.DMatrix('train.svm.txt') #libsvm 格式
   dtest = xgb.DMatrix('test.svm.buffer') # xgboost binary buffer 文件

3. xgboost 也支持从二维的numpy array 中加载数据

   
   xxxxxxxxxx
   data = np.random.rand(5, 10)  
   label = np.random.randint(2, size=5) 
   dtrain = xgb.DMatrix(data, label=label)#从 numpy array 中加载

4. 你也可以从scipy.sparse array 中加载数据

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

7.1.2 DMatrix

1. DMatrix： 由xgboost 内部使用的数据结构，它存储了数据集，并且针对了内存消耗和训练速度进行了优化。

   
   xxxxxxxxxx
   xgboost.DMatrix(data, label=None, missing=None, weight=None, silent=False, 
        feature_names=None, feature_types=None, nthread=None)

   • 参数：

     • data：表示数据集。可以为：

       • 一个字符串，表示文件名。数据从该文件中加载
       • 一个二维的 numpy array， 表示数据集。

     • label：一个序列，表示样本标记。

     • missing： 一个值，它是缺失值的默认值。

     • weight：一个序列，给出了数据集中每个样本的权重。

     • silent： 一个布尔值。如果为True，则不输出中间信息。

     • feature_names： 一个字符串序列，给出了每一个特征的名字

     • feature_types： 一个字符串序列，给出了每个特征的数据类型

     • nthread：

2. 属性：

   • feature_names： 返回每个特征的名字
   • feature_types： 返回每个特征的数据类型

3. 方法：

   • .get_base_margin()： 返回一个浮点数，表示DMatrix 的 base margin。

     .set_base_margin(margin)： 设置DMatrix 的 base margin

     • 参数：margin： t一个序列，给出了每个样本的prediction margin

   • .get_float_info(field)： 返回一个numpy array， 表示DMatrix 的 float property 。

     .set_float_info(field,data)： 设置DMatrix 的 float property 。

     .set_float_info_npy2d(field,data)： 设置DMatrix 的 float property 。这里的data 是二维的numpy array

     • 参数：

       • field： 一个字符串，给出了information 的字段名。注：意义未知。
       • data： 一个numpy array，给出了数据集每一个点的float information

   • .get_uint_info(field)： 返回DMatrix 的 unsigned integer property 。

     .set_unit_info(field,data)： 设置DMatrix 的 unsigned integer property 。

     • 参数：

       • field： 一个字符串，给出了information 的字段名。注：意义未知。
       • data： 一个numpy array， 给出了数据集每个点的uint information

     • 返回值：一个numpy array，表示数据集的unsigned integer information

   • .get_label()： 返回一个numpy array，表示DMatrix 的 label 。

     .set_label(label)： 设置样本标记。

     .set_label_npy2d(label)： 设置样本标记。这里的label 为二维的numpy array

     • 参数： label： 一个序列，表示样本标记

   • .get_weight()： 一个numpy array，返回DMatrix 的样本权重。

     .set_weight(weight)： 设置样本权重。

     .set_weight_npy2d(weight)： 设置样本权重。这里的weight 为二维的numpy array

     • 参数：weight：一个序列，表示样本权重

   • .num_col()： 返回DMatrix 的列数

     • 返回值：一个整数，表示特征的数量

   • .num_row()： 返回DMatrix 的行数

     • 返回值：一个整数，表示样本的数量

   • save_binary(fname,silent=True)： 保存DMatrix 到一个 xgboost buffer 文件中

     • 参数：

       • fname： 一个字符串，表示输出的文件名
       • silent： 一个布尔值。如果为True，则不输出中间信息。

   • .set_group(group)： 设置DMatrix 每个组的大小（用于排序任务）

     • 参数：group： 一个序列，给出了每个组的大小

   • slice(rindex)： 切分DMaxtrix ，返回一个新的DMatrix。 该新的DMatrix 仅仅包含rindex

     • 参数：rindex： 一个列表，给出了要保留的index
     • 返回值：一个新的DMatrix 对象

4. 示例：

   data/train.svm.txt 的内容：

   
   xxxxxxxxxx
   1 1:1 2:2
   1 1:2 2:3
   1 1:3 2:4
   1 1:4 2:5
   0 1:5 2:6
   0 1:6 2:7
   0 1:7 2:8
   0 1:8 2:9

   测试代码：

   ​x
   import xgboost as xgt
   import numpy as np
   ​
   class MatrixTest:
     '''
     测试 DMatrix
     '''
     def __init__(self):
       self._matrix1 = xgt.DMatrix('data/train.svm.txt')
       self._matrix2 = xgt.DMatrix(data=np.arange(0, 12).reshape((4, 3)),
                           label=[1, 2, 3, 4], weight=[0.5, 0.4, 0.3, 0.2],
                           silent=False, feature_names=['a', 'b', 'c'],
                           feature_types=['int','int','float'], nthread=2)
   ​
     def print(self,matrix):
       print('feature_names:%s'%matrix.feature_names)
       print('feature_types:%s' % matrix.feature_types)
     def run_get(self,matrix):
       print('get_base_margin():', matrix.get_base_margin())
       print('get_label():', matrix.get_label())
       print('get_weight():', matrix.get_weight())
       print('num_col():', matrix.num_col())
       print('num_row():', matrix.num_row())
   ​
     def test(self):
       print('查看 matrix1 :')
       self.print(self._matrix1)
       # feature_names:['f0', 'f1', 'f2']
       # feature_types:None
       
       print('\n查看 matrix2 :')
       self.print(self._matrix2)
       # feature_names:['a', 'b', 'c']
       # feature_types:['int', 'int', 'float']
       
       print('\n查看 matrix1 get:')
       self.run_get(self._matrix1)
       # get_base_margin(): []
       # get_label(): [1. 1. 1. 1. 0. 0. 0. 0.]
       # get_weight(): []
       # num_col(): 3
       # num_row(): 8
       
       print('\n查看 matrix2 get:')
       self.run_get(self._matrix2)
       # get_base_margin(): []
       # get_label(): [1. 2. 3. 4.]
       # get_weight(): [0.5 0.4 0.3 0.2]
       # num_col(): 3
       # num_row(): 4
       
       print(self._matrix2.slice([0,1]).get_label())
       # [1. 2.]

   ​

7.2 模型接口

7.2.1 Booster

1. Booster 是xgboost 的模型，它包含了训练、预测、评估等任务的底层实现。

   
   xxxxxxxxxx
   xbgoost.Booster(params=None,cache=(),model_file=None)

   • 参数：

     • params： 一个字典，给出了模型的参数。

       该Booster 将调用self.set_param(params) 方法来设置模型的参数。

     • cache：一个列表，给出了缓存的项。其元素是DMatrix 的对象。模型从这些DMatrix 对象中读取特征名字和特征类型（要求这些DMatrix 对象具有相同的特征名字和特征类型）

     • model_file： 一个字符串，给出了模型文件的位置。

       如果给出了model_file，则调用self.load_model(model_file) 来加载模型。

2. 属性：

   通过方法来存取、设置属性。

3. 方法：

   • .attr(key)： 获取booster 的属性。如果该属性不存在，则返回None

     • 参数：

       • key： 一个字符串，表示要获取的属性的名字

   • .set_attr(**kwargs)： 设置booster 的属性

     • 参数：kwargs： 关键字参数。注意：参数的值目前只支持字符串。

       如果参数的值为None，则表示删除该参数

   • .attributes()： 以字典的形式返回booster 的属性

   • .set_param(params,value=None)： 设置booster 的参数

     • 参数：

       • params： 一个列表（元素为键值对）、一个字典、或者一个字符串。表示待设置的参数
       • value： 如果params 为字符串，那么params 就是键，而value就是参数值。

   • .boost(dtrain,grad,hess)： 执行一次训练迭代

     • 参数：

       • dtrain： 一个 DMatrix 对象，表示训练集
       • grad： 一个列表，表示一阶的梯度
       • hess： 一个列表，表示二阶的偏导数

   • .update(dtrain,iteration,fobj=None)： 对一次迭代进行更新

     • 参数：

       • dtrain： 一个 DMatrix 对象，表示训练集
       • iteration： 一个整数，表示当前的迭代步数编号
       • fobj： 一个函数，表示自定义的目标函数

     由于Booster 没有.train() 方法，因此需要用下面的策略进行迭代：

     
     xxxxxxxxxx
     for i in range(0,100):
           booster.update(train_matrix,iteration=i)

   • .copy()： 拷贝当前的booster，并返回一个新的Booster 对象

   • .dump_model(fout,fmap='',with_stats=False)： dump 模型到一个文本文件中。

     • 参数：

       • fout： 一个字符串，表示输出文件的文件名

       • fmap： 一个字符串，表示存储feature map 的文件的文件名。booster 需要从它里面读取特征的信息。

         该文件每一行依次代表一个特征。每一行的格式为：feature name:feature type。 其中feature type 为int、float 等表示数据类型的字符串。

       • with_stats： 一个布尔值。如果为True，则输出split 的统计信息

   • .get_dump(fmap='',with_stats=False,dump_format='text')： dump 模型为字符的列表（而不是存到文件中）。

     • 参数：

       • fmap： 一个字符串，表示存储feature map 的文件的文件名。booster 需要从它里面读取特征的信息。
       • with_stats： 一个布尔值。如果为True，则输出split 的统计信息
       • dump_format： 一个字符串，给出了输出的格式

     • 返回值：一个字符串的列表。每个字符串描述了一棵子树。

   • .eval(data,name='eval',iteration=0)： 对模型进行评估

     • 参数：

       • data： 一个DMatrix 对象，表示数据集
       • name： 一个字符串，表示数据集的名字
       • iteration： 一个整数，表示当前的迭代编号

     • 返回值：一个字符串，表示评估结果

   • .eval_set(evals,iteration=0,feval=None)： 评估一系列的数据集

     • 参数：

       • evals： 一个列表，列表元素为元组(DMatrix,string)， 它给出了待评估的数据集
       • iteration： 一个整数，表示当前的迭代编号
       • feval： 一个函数，给出了自定义的评估函数

     • 返回值：一个字符串，表示评估结果

   • .get_fscore(fmap='')： 返回每个特征的重要性

     • 参数：

       • fmap： 一个字符串，给出了feature map 文件的文件名。booster 需要从它里面读取特征的信息。

     • 返回值：一个字典，给出了每个特征的重要性

   • .get_score(fmap='',importance_type='weight')： 返回每个特征的重要性

     • 参数：

       • fmap： 一个字符串，给出了feature map 文件的文件名。booster 需要从它里面读取特征的信息。

       • importance_type： 一个字符串，给出了特征的衡量指标。可以为：

         • 'weight'： 此时特征重要性衡量标准为：该特征在所有的树中，被用于划分数据集的总次数。
         • 'gain'： 此时特征重要性衡量标准为：该特征在树的'cover' 中，获取的平均增益。

     • 返回值：一个字典，给出了每个特征的重要性

   • .get_split_value_histogram(feature,fmap='',bins=None,as_pandas=True)： 获取一个特征的划分value histogram。

     • 参数：

       • feature： 一个字符串，给出了划分特征的名字
       • fmap： 一个字符串，给出了feature map 文件的文件名。booster 需要从它里面读取特征的信息。
       • bins： 最大的分桶的数量。如果bins=None 或者 bins>n_unique，则分桶的数量实际上等于n_unique。 其中 n_unique 是划分点的值的unique
       • as_pandas ：一个布尔值。如果为True，则返回一个pandas.DataFrame； 否则返回一个numpy ndarray。

     • 返回值：以一个numpy ndarray 或者 pandas.DataFrame 形式返回的、代表拆分点的histogram 的结果。

   • .load_model(fname)： 从文件中加载模型。

     • 参数：fname： 一个文件或者一个内存buffer， xgboost 从它加载模型

   • .save_model(fname)： 保存模型到文件中

     • 参数：fname： 一个字符串，表示文件名

   • save_raw()： 将模型保存成内存buffer

     • 返回值：一个内存buffer，代表该模型

   • .load_rabit_checkpoint()： 从rabit checkpoint 中初始化模型。

     • 返回值：一个整数，表示模型的版本号

   • .predict(data,output_margin=False,ntree_limit=0,pred_leaf=False,pred_contribs=False,approx_contribs=False)： 执行预测

     该方法不是线程安全的。对于每个 booster 来讲，你只能在某个线程中调用它的.predict 方法。如果你在多个线程中调用.predict 方法，则可能会有问题。

     要想解决该问题，你必须在每个线程中调用booster.copy() 来拷贝该booster 到每个线程中

     • 参数：

       • data： 一个 DMatrix 对象，表示测试集

       • output_margin： 一个布尔值。表示是否输出原始的、未经过转换的margin value

       • ntree_limit： 一个整数。表示使用多少棵子树来预测。默认值为0，表示使用所有的子树。

         如果训练的时候发生了早停，则你可以使用booster.best_ntree_limit。

       • pred_leaf： 一个布尔值。如果为True，则会输出每个样本在每个子树的哪个叶子上。它是一个nsample x ntrees 的矩阵。

         每个子树的叶节点都是从1 开始编号的。

       • pred_contribs： 一个布尔值。如果为True， 则输出每个特征对每个样本预测结果的贡献程度。它是一个nsample x ( nfeature+1) 的矩阵。

         之所以加1，是因为有bias 的因素。它位于最后一列。

         其中样本所有的贡献程度相加，就是该样本最终的预测的结果。

       • approx_contribs： 一个布尔值。如果为True，则大致估算出每个特征的贡献程度。

     • 返回值：一个ndarray，表示预测结果

4. Booster 没有 train 方法。因此有两种策略来获得训练好的 Booster

   • 从训练好的模型的文件中.load_model() 来获取
   • 多次调用.update() 方法

5. 示例：

   
   xxxxxxxxxx
   import xgboost as xgt
   import numpy as np
   import pandas as pd
   from sklearn.model_selection import train_test_split
   ​
   _label_map={
     # 'Iris-setosa':0, #经过裁剪的，去掉了 iris 中的 setosa 类
     'Iris-versicolor':0,
     'Iris-virginica':1
   }
   class BoosterTest:
     '''
     测试 Booster
     '''
     def __init__(self):
       df=pd.read_csv('./data/iris.csv')
       _feature_names=['Sepal Length','Sepal Width','Petal Length','Petal Width']
       x=df[_feature_names]
       y=df['Class'].map(lambda x:_label_map[x])
   ​
       train_X,test_X,train_Y,test_Y=train_test_split(x,y,
               test_size=0.3,stratify=y,shuffle=True,random_state=1)
       self._train_matrix=xgt.DMatrix(data=train_X,label=train_Y,
                           eature_names=_feature_names,
                           feature_types=['float','float','float','float'])
       self._validate_matrix = xgt.DMatrix(data=test_X, label=test_Y, 
                           feature_names=_feature_names,
                           feature_types=['float', 'float', 'float', 'float'])
       self._booster=xgt.Booster(params={
         'booster':'gbtree',
         'silent':0,#打印消息
         'eta':0.1, #学习率
         'max_depth':5,
         'tree_method':'exact',
         'objective':'binary:logistic',
         'eval_metric':'auc',
         'seed':321},
         cache=[self._train_matrix,self._validate_matrix])
   ​
     def test_attribute(self):
       '''
       测试属性的设置和获取
       :return:
       '''
       self._booster.set_attr(key1= '1')
       print('attr:key1 -> ',self._booster.attr('key1'))
       print('attr:key2 -> ',self._booster.attr('key2'))
       print('attributes -> ',self._booster.attributes())
     def test_dump_model(self):
       '''
       测试 dump 模型
       :return:
       '''
       _dump_str=self._booster.get_dump(fmap='model/booster.feature',
                                        with_stats=True,dump_format='text')
       print('dump:',_dump_str[0][:20]+'...' if _dump_str else [])
       self._booster.dump_model('model/booster.model',
                                fmap='model/booster.feature',with_stats=True)
     def test_train(self):
       '''
       训练
       :return:
       '''
       for i in range(0,100):
         self._booster.update(self._train_matrix,iteration=i)
         print(self._booster.eval(self._train_matrix, name='train', iteration=i))
         print(self._booster.eval(self._validate_matrix,name='eval',iteration=i))
     def test_importance(self):
       '''
       测试特征重要性
       :return:
       '''
       print('fscore:',self._booster.get_fscore('model/booster.feature'))
       print('score.weight:', self._booster.get_score(importance_type='weight'))
       print('score.gain:', self._booster.get_score(importance_type='gain'))
   ​
     def test(self):
       self.test_attribute()
       # attr:key1 ->  1
       # attr:key2 ->  None
       # attributes ->  {'key1': '1'}
       self.test_dump_model()
       # dump: []
       self.test_train()
       # [0]   train-auc:0.980816
       # [0]   eval-auc:0.933333
       # ...
       # [99]  train-auc:0.998367
       # [99]  eval-auc:0.995556
       self.test_dump_model()
       # dump: 0:[f2<4.85] yes=1,no...
       self.test_importance()
       # score: {'f2': 80, 'f3': 72, 'f0': 6, 'f1': 5}
       # score.weight: {'Petal Length': 80, 'Petal Width': 72, 'Sepal Length': 6, 'Sepal Width': 5}
       # score.gain: {'Petal Length': 3.6525380337500004, 'Petal Width': 2.2072901486111114, 'Sepal Length': 0.06247816666666667, 'Sepal Width': 0.09243024}
   ​
   if __name__ == '__main__':
     BoosterTest().test()

7.2.2 直接学习

1. xgboost.train()： 使用给定的参数来训练一个booster

   
   xxxxxxxxxx
   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)

   • 参数：

     • params： 一个列表（元素为键值对）、一个字典，表示训练的参数

     • dtrain：一个DMatrix 对象，表示训练集

     • num_boost_round： 一个整数，表示boosting 迭代数量

     • evals： 一个列表，元素为(DMatrix,string)。 它给出了训练期间的验证集，以及验证集的名字（从而区分验证集的评估结果）。

     • obj：一个函数，它表示自定义的目标函数

     • feval： 一个函数，它表示自定义的evaluation 函数

     • maximize： 一个布尔值。如果为True，则表示是对feval 求最大值；否则为求最小值

     • early_stopping_rounds：一个整数，表示早停参数。

       如果在early_stopping_rounds 个迭代步内，验证集的验证误差没有下降，则训练停止。

       • 该参数要求evals 参数至少包含一个验证集。如果evals 参数包含了多个验证集，则使用最后的一个。

       • 返回的模型是最后一次迭代的模型（而不是最佳的模型）。

       • 如果早停发生，则模型拥有三个额外的字段：

         • .best_score： 最佳的分数
         • .best_iteration： 最佳的迭代步数
         • .best_ntree_limit： 最佳的子模型数量

     • evals_result： 一个字典，它给出了对测试集要进行评估的指标。

     • verbose_eval： 一个布尔值或者整数。

       • 如果为True，则evalutation metric 将在每个boosting stage 打印出来
       • 如果为一个整数，则evalutation metric 将在每隔verbose_eval个boosting stage 打印出来。另外最后一个boosting stage，以及早停的boosting stage 的 evalutation metric 也会被打印

     • learning_rates： 一个列表，给出了每个迭代步的学习率。

       • 你可以让学习率进行衰减

     • xgb_model： 一个Booster实例，或者一个存储了xgboost 模型的文件的文件名。它给出了待训练的模型。

       这种做法允许连续训练。

     • callbacks： 一个回调函数的列表，它给出了在每个迭代步结束之后需要调用的那些函数。

       你可以使用xgboost 中预定义的一些回调函数（位于xgboost.callback 模块） 。如：

       xgboost.reset_learning_rate(custom_rates)

   • 返回值：一个Booster 对象，表示训练好的模型

2. xgboost.cv()： 使用给定的参数执行交叉验证 。它常用作参数搜索 。

   
   xxxxxxxxxx
   xgboost.cv(params, dtrain, num_boost_round=10, nfold=3, stratified=False, folds=None,
        metrics=(), obj=None, feval=None, maximize=False, early_stopping_rounds=None,
        fpreproc=None, as_pandas=True, verbose_eval=None, show_stdv=True, seed=0,
        callbacks=None, shuffle=True)

   • 参数：

     • params： 一个列表（元素为键值对）、一个字典，表示训练的参数

     • dtrain：一个DMatrix 对象，表示训练集

     • num_boost_round： 一个整数，表示boosting 迭代数量

     • nfold： 一个整数，表示交叉验证的fold 的数量

     • stratified： 一个布尔值。如果为True，则执行分层采样

     • folds： 一个scikit-learn 的 KFold 实例或者StratifiedKFold 实例。

     • metrics：一个字符串或者一个字符串的列表，指定了交叉验证时的evaluation metrics

       如果同时在params 里指定了eval_metric，则metrics 参数优先。

     • obj：一个函数，它表示自定义的目标函数

     • feval： 一个函数，它表示自定义的evaluation 函数

     • maximize： 一个布尔值。如果为True，则表示是对feval 求最大值；否则为求最小值

     • early_stopping_rounds：一个整数，表示早停参数。

       如果在early_stopping_rounds 个迭代步内，验证集的验证误差没有下降，则训练停止。

       • 返回evaluation history 结果中的最后一项是最佳的迭代步的评估结果

     • fpreproc： 一个函数。它是预处理函数，其参数为(dtrain,dtest,param)， 返回值是经过了变换之后的 (dtrain,dtest,param)

     • as_pandas： 一个布尔值。如果为True，则返回一个pandas.DataFrame ；否则返回一个numpy.ndarray

     • verbose_eval： 参考 xgboost.train()

     • show_stdv： 一个布尔值。是否verbose 中打印标准差。

       它对返回结果没有影响。返回结果始终包含标准差。

     • seed： 一个整数，表示随机数种子

     • callbacks： 参考 xgboost.train()

     • shuffle： 一个布尔值。如果为True，则创建folds 之前先混洗数据。

   • 返回值：一个字符串的列表，给出了evaluation history 。它给的是早停时刻的history(此时对应着最优模型)，早停之后的结果被抛弃。

3. 示例：

   
   xxxxxxxxxx
   class TrainTest:
     def __init__(self):
       df = pd.read_csv('./data/iris.csv')
       _feature_names = ['Sepal Length', 'Sepal Width', 'Petal Length', 'Petal Width']
       x = df[_feature_names]
       y = df['Class'].map(lambda x: _label_map[x])
   ​
       train_X, test_X, train_Y, test_Y = train_test_split(x, y, test_size=0.3, 
                   stratify=y, shuffle=True, random_state=1)
       self._train_matrix = xgt.DMatrix(data=train_X, label=train_Y, 
                   feature_names=_feature_names,
                   feature_types=['float', 'float', 'float', 'float'])
       self._validate_matrix = xgt.DMatrix(data=test_X, label=test_Y,
                   feature_names=_feature_names,
                   feature_types=['float', 'float', 'float', 'float'])
   ​
     def train_test(self):
       params={
         'booster':'gbtree',
         'eta':0.01,
         'max_depth':5,
         'tree_method':'exact',
         'objective':'binary:logistic',
         'eval_metric':['logloss','error','auc']
       }
       eval_rst={}
       booster=xgt.train(params,self._train_matrix,num_boost_round=20,
            evals=([(self._train_matrix,'valid1'),(self._validate_matrix,'valid2')]),
            early_stopping_rounds=5,evals_result=eval_rst,verbose_eval=True)
       ## 训练输出
       # Multiple eval metrics have been passed: 'valid2-auc' will be used for early stopping.
       # Will train until valid2-auc hasn't improved in 5 rounds.
       # [0]   valid1-logloss:0.685684 valid1-error:0.042857   valid1-auc:0.980816 valid2-logloss:0.685749 valid2-error:0.066667   valid2-auc:0.933333
       # ...
       # Stopping. Best iteration:
       # [1]   valid1-logloss:0.678149 valid1-error:0.042857   valid1-auc:0.99551  valid2-logloss:0.677882 valid2-error:0.066667   valid2-auc:0.966667
       
       print('booster attributes:',booster.attributes())
       # booster attributes: {'best_iteration': '1', 'best_msg': '[1]\tvalid1-logloss:0.678149\tvalid1-error:0.042857\tvalid1-auc:0.99551\tvalid2-logloss:0.677882\tvalid2-error:0.066667\tvalid2-auc:0.966667', 'best_score': '0.966667'} 
       
       print('fscore:', booster.get_fscore())
       # fscore: {'Petal Length': 8, 'Petal Width': 7}
       
       print('eval_rst:',eval_rst)
       # eval_rst: {'valid1': {'logloss': [0.685684, 0.678149, 0.671075, 0.663787, 0.656948, 0.649895], 'error': [0.042857, 0.042857, 0.042857, 0.042857, 0.042857, 0.042857], 'auc': [0.980816, 0.99551, 0.99551, 0.99551, 0.99551, 0.99551]}, 'valid2': {'logloss': [0.685749, 0.677882, 0.670747, 0.663147, 0.656263, 0.648916], 'error': [0.066667, 0.066667, 0.066667, 0.066667, 0.066667, 0.066667], 'auc': [0.933333, 0.966667, 0.966667, 0.966667, 0.966667, 0.966667]}}
       
     def cv_test(self):
       params = {
         'booster': 'gbtree',
         'eta': 0.01,
         'max_depth': 5,
         'tree_method': 'exact',
         'objective': 'binary:logistic',
         'eval_metric': ['logloss', 'error', 'auc']
       }
   ​
       eval_history = xgt.cv(params, self._train_matrix,num_boost_round=20, 
            nfold=3,stratified=True,metrics=['error', 'auc'],
            early_stopping_rounds=5,verbose_eval=True,shuffle=True)
       ## 训练输出
       # [0]   train-auc:0.974306+0.00309697   train-error:0.0428743+0.0177703 test-auc:0.887626+0.0695933 test-error:0.112374+0.0695933
       #....
       print('eval_history:', eval_history)
       # eval_history:    test-auc-mean  test-auc-std  test-error-mean  test-error-std  \
       # 0       0.887626      0.069593         0.112374        0.069593   
       # 1       0.925821      0.020752         0.112374        0.069593   
       # 2       0.925821      0.020752         0.098485        0.050631   
   ​
       # train-auc-mean  train-auc-std  train-error-mean  train-error-std  
       # 0        0.974306       0.003097          0.042874          0.01777  
       # 1        0.987893       0.012337          0.042874          0.01777  
       # 2        0.986735       0.011871          0.042874          0.01777  

7.2.3 Scikit-Learn API

1. xgboost 给出了针对scikit-learn 接口的API

2. xgboost.XGBRegressor： 它实现了scikit-learn 的回归模型API

   
   xxxxxxxxxx
   class 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, **kwargs)

   参数：

   • max_depth： 一个整数，表示子树的最大深度

   • learning_rate： 一个浮点数，表示学习率

   • n_estimators：一个整数，表示预期需要学习的子树的数量

   • silent： 一个布尔值。如果为False，则打印中间信息

   • objective： 一个字符串或者可调用对象，指定了目标函数。其函数签名为：objective(y_true,y_pred) -> gra,hess。 其中：

     • y_true： 一个形状为[n_sample] 的序列，表示真实的标签值
     • y_pred： 一个形状为[n_sample] 的序列，表示预测的标签值
     • grad： 一个形状为[n_sample] 的序列，表示每个样本处的梯度
     • hess： 一个形状为[n_sample] 的序列，表示每个样本处的二阶偏导数

   • booster： 一个字符串。指定了用哪一种基模型。可以为：'gbtree','gblinear','dart'

   • n_jobs： 一个整数，指定了并行度，即开启多少个线程来训练。如果为-1，则使用所有的CPU

   • gamma： 一个浮点数，也称作最小划分损失min_split_loss。 它刻画的是：对于一个叶子节点，当对它采取划分之后，损失函数的降低值的阈值。

     • 如果大于该阈值，则该叶子节点值得继续划分
     • 如果小于该阈值，则该叶子节点不值得继续划分

   • min_child_weight： 一个整数，子节点的权重阈值。它刻画的是：对于一个叶子节点，当对它采取划分之后，它的所有子节点的权重之和的阈值。

     • 如果它的所有子节点的权重之和大于该阈值，则该叶子节点值得继续划分
     • 如果它的所有子节点的权重之和小于该阈值，则该叶子节点不值得继续划分

     所谓的权重：

     • 对于线性模型(booster=gblinear)，权重就是：叶子节点包含的样本数量。 因此该参数就是每个节点包含的最少样本数量。
     • 对于树模型（booster=gbtree,dart），权重就是：叶子节点包含样本的所有二阶偏导数之和。

   • max_delta_step： 一个整数，每棵树的权重估计时的最大delta step。取值范围为 $ MathJax-Element-42 $ ，0 表示没有限制，默认值为 0 。

   • subsample：一个浮点数，对训练样本的采样比例。取值范围为 (0,1]，默认值为 1 。

     如果为 0.5， 表示随机使用一半的训练样本来训练子树。它有助于缓解过拟合。

   • colsample_bytree： 一个浮点数，构建子树时，对特征的采样比例。取值范围为 (0,1]， 默认值为 1。

     如果为 0.5， 表示随机使用一半的特征来训练子树。它有助于缓解过拟合。

   • colsample_bylevel： 一个浮点数，寻找划分点时，对特征的采样比例。取值范围为 (0,1]， 默认值为 1。

     如果为 0.5， 表示随机使用一半的特征来寻找最佳划分点。它有助于缓解过拟合。

   • reg_alpha： 一个浮点数，是L1 正则化系数。它是xgb 的alpha 参数

   • reg_lambda： 一个浮点数，是L2 正则化系数。它是xgb 的lambda 参数

   • scale_pos_weight： 一个浮点数，用于调整正负样本的权重，常用于类别不平衡的分类问题。默认为 1。

     一个典型的参数值为： 负样本数量/正样本数量

   • base_score：一个浮点数， 给所有样本的一个初始的预测得分。它引入了全局的bias

   • random_state： 一个整数，表示随机数种子。

   • missing： 一个浮点数，它的值代表发生了数据缺失。默认为np.nan

   • kwargs： 一个字典，给出了关键字参数。它用于设置Booster 对象

3. xgboost.XGBClassifier ：它实现了scikit-learn 的分类模型API

   
   xxxxxxxxxx
   class xgboost.XGBClassifier(max_depth=3, learning_rate=0.1, n_estimators=100, 
        silent=True, objective='binary:logistic', 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, **kwargs)

   参数参考xgboost.XGBRegressor

4. xgboost.XGBClassifier 和 xgboost.XGBRegressor 的方法：

   • .fit()： 训练模型

     
     xxxxxxxxxx
     fit(X, y, sample_weight=None, eval_set=None, eval_metric=None,
         early_stopping_rounds=None,verbose=True, xgb_model=None)

     参数：

     • X： 一个array-like，表示训练集

     • y： 一个序列，表示标记

     • sample_weight： 一个序列，给出了每个样本的权重

     • eval_set： 一个列表，元素为(X,y)，给出了验证集及其标签。它们用于早停。

       如果有多个验证集，则使用最后一个

     • eval_metric： 一个字符串或者可调用对象，用于evaluation metric

       • 如果为字符串，则是内置的度量函数的名字
       • 如果为可调用对象，则它的签名为(y_pred,y_true)==>(str,value)

     • early_stopping_rounds： 指定早停的次数。参考xgboost.train()

     • verbose： 一个布尔值。如果为True，则打印验证集的评估结果。

     • xgb_model：一个Booster实例，或者一个存储了xgboost 模型的文件的文件名。它给出了待训练的模型。

       这种做法允许连续训练。

   • .predict()：执行预测

     
     xxxxxxxxxx
     predict(data, output_margin=False, ntree_limit=0)

     参数:

     • data： 一个 DMatrix 对象，表示测试集

     • output_margin： 一个布尔值。表示是否输出原始的、未经过转换的margin value

     • ntree_limit： 一个整数。表示使用多少棵子树来预测。默认值为0，表示使用所有的子树。

       如果训练的时候发生了早停，则你可以使用booster.best_ntree_limit。

     返回值：一个ndarray，表示预测结果

     • 对于回归问题，返回的就是原始的预测结果
     • 对于分类问题，返回的就是预测类别(阈值为 0.5 )

   • .predict_proba(data, output_margin=False, ntree_limit=0) ： 执行预测，预测的是各类别的概率

     参数：参考.predict()

     返回值：一个ndarray，表示预测结果

     它只用于分类问题，返回的是预测各类别的概率

   • .evals_result()： 返回一个字典，给出了各个验证集在各个验证参数上的历史值

     它不同于cv() 函数的返回值。cv() 函数返回evaluation history 是早停时刻的。而这里返回的是所有的历史值

5. 示例：

   
   xxxxxxxxxx
   class SKLTest:
     def __init__(self):
       df = pd.read_csv('./data/iris.csv')
       _feature_names = ['Sepal Length', 'Sepal Width', 'Petal Length', 'Petal Width']
       x = df[_feature_names]
       y = df['Class'].map(lambda x: _label_map[x])
   ​
       self.train_X, self.test_X, self.train_Y, self.test_Y = \
         train_test_split(x, y, test_size=0.3, stratify=y, shuffle=True, random_state=1)
         
     def train_test(self):
       clf=xgt.XGBClassifier(max_depth=3,learning_rate=0.1,n_estimators=100)
       clf.fit(self.train_X,self.train_Y,eval_metric='auc',
               eval_set=[( self.test_X,self.test_Y),],
               early_stopping_rounds=3)
       # 训练输出:
       # Will train until validation_0-auc hasn't improved in 3 rounds.
       # [0]   validation_0-auc:0.933333
       # ...
       # Stopping. Best iteration:
       # [2]   validation_0-auc:0.997778
       print('evals_result:',clf.evals_result())
       # evals_result: {'validation_0': {'auc': [0.933333, 0.966667, 0.997778, 0.997778, 0.997778]}}
       print('predict:',clf.predict(self.test_X))
       # predict: [1 1 0 0 0 1 1 1 0 0 0 1 1 0 1 1 0 1 0 0 0 0 0 1 1 0 0 1 1 0]

7.3 绘图API

1. xgboost.plot_importance()：绘制特征重要性

   
   xxxxxxxxxx
   xgboost.plot_importance(booster, ax=None, height=0.2, xlim=None, ylim=None,
          title='Feature importance', xlabel='F score', ylabel='Features',
          importance_type='weight', max_num_features=None, grid=True, 
          show_values=True, **kwargs)

   参数：

   • booster： 一个Booster对象， 一个 XGBModel 对象，或者由Booster.get_fscore() 返回的字典

   • ax： 一个matplotlib Axes 对象。特征重要性将绘制在它上面。

     如果为None，则新建一个Axes

   • grid： 一个布尔值。如果为True，则开启axes grid

   • importance_type： 一个字符串，指定了特征重要性的类别。参考Booster.get_fscore()

   • max_num_features： 一个整数，指定展示的特征的最大数量。如果为None，则展示所有的特征

   • height： 一个浮点数，指定bar 的高度。它传递给ax.barh()

   • xlim： 一个元组，传递给 axes.xlim()

   • ylim： 一个元组，传递给 axes.ylim()

   • title： 一个字符串，设置Axes 的标题。默认为"Feature importance"。 如果为None，则没有标题

   • xlabel： 一个字符串，设置Axes 的X 轴标题。默认为"F score"。 如果为None，则X 轴没有标题

   • ylabel：一个字符串，设置Axes 的Y 轴标题。默认为"Features"。 如果为None，则Y 轴没有标题

   • show_values： 一个布尔值。如果为True，则在绘图上展示具体的值。

   • kwargs： 关键字参数，用于传递给ax.barh()

   返回ax （一个matplotlib Axes 对象）

2. xgboost.plot_tree()： 绘制指定的子树。

   
   xxxxxxxxxx
   xgboost.plot_tree(booster, fmap='', num_trees=0, rankdir='UT', ax=None, **kwargs)

   参数：

   • booster： 一个Booster对象， 一个 XGBModel 对象

   • fmap： 一个字符串，给出了feature map 文件的文件名

   • num_trees： 一个整数，制定了要绘制的子数的编号。默认为 0

   • rankdir： 一个字符串，它传递给graphviz的graph_attr

   • ax： 一个matplotlib Axes 对象。特征重要性将绘制在它上面。

     如果为None，则新建一个Axes

   • kwargs： 关键字参数，用于传递给graphviz 的graph_attr

   返回ax （一个matplotlib Axes 对象）

3. xgboost.tp_graphviz()： 转换指定的子树成一个graphviz 实例。

   在IPython中，可以自动绘制graphviz 实例；否则你需要手动调用graphviz 对象的.render() 方法来绘制。

   
   xxxxxxxxxx
   xgboost.to_graphviz(booster, fmap='', num_trees=0, rankdir='UT', yes_color='#0000FF',
        no_color='#FF0000', **kwargs)

   参数：

   • yes_color： 一个字符串，给出了满足node condition 的边的颜色
   • no_color： 一个字符串，给出了不满足node condition 的边的颜色
   • 其它参数参考 xgboost.plot_tree()

   返回ax （一个matplotlib Axes 对象）

4. 示例：

   
   xxxxxxxxxx
   class PlotTest:
     def __init__(self):
       df = pd.read_csv('./data/iris.csv')
       _feature_names = ['Sepal Length', 'Sepal Width', 'Petal Length', 'Petal Width']
       x = df[_feature_names]
       y = df['Class'].map(lambda x: _label_map[x])
   ​
       train_X, test_X, train_Y, test_Y = train_test_split(x, y, 
             test_size=0.3, stratify=y, shuffle=True, random_state=1)
       self._train_matrix = xgt.DMatrix(data=train_X, label=train_Y, 
                feature_names=_feature_names,
                feature_types=['float', 'float', 'float', 'float'])
       self._validate_matrix = xgt.DMatrix(data=test_X, label=test_Y, 
                feature_names=_feature_names,
                feature_types=['float', 'float', 'float', 'float'])
   ​
     def plot_test(self):
       params = {
         'booster': 'gbtree',
         'eta': 0.01,
         'max_depth': 5,
         'tree_method': 'exact',
         'objective': 'binary:logistic',
         'eval_metric': ['logloss', 'error', 'auc']
       }
       eval_rst = {}
       booster = xgt.train(params, self._train_matrix,
                num_boost_round=20, evals=([(self._train_matrix, 'valid1'),
                                            (self._validate_matrix, 'valid2')]),
                early_stopping_rounds=5, evals_result=eval_rst, verbose_eval=True)
       xgt.plot_importance(booster)
       plt.show()