四、API - 4.2 模型接口 - 《AI算法工程师手册》

4.2 模型接口

4.2 模型接口

4.2.1 Booster

LightGBM 中的 Booster类：
```
class lightgbm.Booster(params=None, train_set=None, model_file=None, silent=False)
```
参数：
- params：一个字典或者None，给出了Booster 的参数。默认为None
- train_set：一个Dataset对象或者None，给出了训练集。默认为None
- model_file：一个字符串或者None，给出了model file 的路径。默认为None
- silent：一个布尔值，指示是否在构建过程中打印消息。默认为False
方法：
- .add_valid(data,name)：添加一个验证集。
  - 参数：
    - data：一个Dataset，代表一个验证集
    - name：一个字符串，表示该验证集的名字。不同的验证集通过名字来区分
- .attr(key)：获取属性的值。
  - 参数：key：一个字符串，表示属性的名字
  - 返回值：该属性的名字。如果属性不存在则返回None
- .current_iteration()：返回当前的迭代的index（即迭代的编号）
- .dump_model(num_iteration=-1)： dump 当前的Booster 对象为json 格式。
  - 参数：num_iteration：一个整数，指定需要dump 第几轮训练的结果。如果小于0，则最佳迭代步的结果（如果存在的话）将被dump。默认为-1。
  - 返回值：一个字典，它表示dump 之后的json
- .eval(data,name,feval=None)：对指定的数据集evaluate
  - 参数：
    - data：一个Dataset 对象，代表被评估的数据集
    - name：一个字符串，表示被评估的数据集的名字。不同的验证集通过名字来区分
    - feval：一个可调用对象或者None，它表示自定义的evaluation 函数。默认为None。它的输入为(y_true, y_pred)、或者( y_true, y_pred, weight) 、或者(y_true, y_pred, weight, group)，返回一个元组：(eval_name,eval_result,is_higher_better) 。或者返回该元组的列表。
  - 返回值：一个列表，给出了evaluation 的结果。
- .eval_train(feval=None)：对训练集进行evaluate
  - 参数：feval：参考.eval() 方法
  - 返回值：一个列表，给出了evaluation 的结果。
- .eval_valid(feval=None)：对验证集进行evaluate
  - 参数：feval：参考.eval() 方法
  - 返回值：一个列表，给出了evaluation 的结果。
- .feature_importance(importance_type='split', iteration=-1)：获取特征的importance
  - 参数：
    - importance_type：一个字符串，给出了特征的importance衡量指标。默认为'split'。可以为：
      - 'split'：此时特征重要性衡量标准为：该特征在所有的树中，被用于划分数据集的总次数。
      - 'gain'：此时特征重要性衡量标准为：该特征在所有的树中获取的总收益。
    - iteration：一个整数，指定需要考虑的是第几轮训练的结果。如果小于0，则最佳迭代步的结果（如果存在的话）将被考虑。默认为-1。
  - 返回值：一个numpy array，表示每个特征的重要性
- .feature_name()：获取每个特征的名字。
  - 返回值：一个字符串的列表，表示每个特征的名字
- .free_dataset()：释放Booster 对象的数据集
- .free_network()：释放Booster 对象的Network
- .get_leaf_output(tree_id, leaf_id)：获取指定叶子的输出
  - 输入：
    - tree_id：一个整数，表示子学习器的编号
    - leaf_id：一个整数，表示该子学习器的叶子的编号
  - 返回值：一个浮点数，表示该叶子节点的输出
- .num_feature()：获取特征的数量（即由多少列特征）
- .predict(data, num_iteration=-1, raw_score=False, pred_leaf=False, pred_contrib=False, data_has_header=False, is_reshape=True, pred_parameter=None)：执行预测
  - 参数：
    - data：一个字符串、numpy array 或者scipy.sparse，表示被测试的数据集。如果为字符串，则表示测试集所在的文件的文件名。
      
      注意：如果是numpy array 或者 pandas dataframe 时，要求数据的列必须与训练时的列顺序一致。
    - num_iteration：一个整数，表示用第几轮的迭代结果来预测。如果小于0，则最佳迭代步的结果（如果存在的话）将被使用。默认为-1。
    - raw_score：一个布尔值，指示是否输出raw scores。默认为False
    - pred_leaf：一个布尔值。如果为True，则会输出每个样本在每个子树的哪个叶子上。它是一个nsample x ntrees 的矩阵。默认为False。
      
      每个子树的叶节点都是从1 开始编号的。
    - pred_contrib：一个布尔值。如果为True，则输出每个特征对每个样本预测结果的贡献程度。它是一个nsample x ( nfeature+1) 的矩阵。默认为False。
      
      之所以加1，是因为有bias 的因素。它位于最后一列。
      
      其中样本所有的贡献程度相加，就是该样本最终的预测的结果。
    - data_has_header：一个布尔值，指示数据集是否含有标题。仅当data 是字符串时有效。默认为False。
    - is_reshape：一个布尔值，指示是否reshape 结果成[nrow,ncol]。默认为True
    - pred_parameter：一个字典或者None，给出了其它的参数。默认为None
  - 返回值：一个numpy array，表示预测结果
- .reset_parameter(params)：重设Booster 的参数。
  - 参数：params：一个字典，给出了新的参数
- .rollback_one_iter()：将Booster 回滚一个迭代步
- .save_model(filename,num_iteration=-1)：保存Booster 对象到文件中。
  - 参数：
    - filename：一个字符串，给出了保存的文件的文件名
    - num_iteration：一个整数，指定需要保存的是第几轮训练的结果。如果小于0，则最佳迭代步的结果（如果存在的话）将被保存。默认为-1。
- .set_attr(**kwargs)：设置Booster 的属性。
  - 参数：kwargs：关键字参数，用于设定Booster 属性。对于值为None 的设置，等效于删除该属性。
- .set_network(machines,local_listen_port=12400,listen_time_out=120,num_machines=1)：配置网络
  - 参数：
    - machines：一个字符串的列表、或者字符串的集合。它给出了每台机器的名字
    - local_listen_port：一个整数，默认为 12400，指定了监听端口
    - listen_time_out：一个整数，默认为120，制定了socket 超时的时间（单位为分钟）
    - num_machines：一个整数，默认为1，表示并行学习的机器的数量
- .set_train_data_name(name)：设置训练集的名字
  - 参数：name：一个字符串，表示训练集的名字
- .update(train_set=None, fobj=None)：更新一个迭代步
  - 参数：
    - train_set：一个Dataset 或者None，表示训练集。如果为None，则上一个训练集被使用
    - fobj：一个可调用对象或者None，表示自定义的目标函数。
      
      注意：如果是多类别分类任务，则：score 首先根据class_id 进行分组，然后根据row_id 分组。如果你想得到第i 个样本在第j 个类别上的得分，访问方式为：score[j*num_data+i]。同理：grad 和 hess 也是以这样的方式访问。
  - 返回值：一个布尔值，指示该次更新迭代步是否成功结束。

示例：

_label_map={
  # 'Iris-setosa':0,
  'Iris-versicolor':0,
  'Iris-virginica':1
}
class BoosterTest:
  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)
    print([item.shape for item in (train_X, test_X, train_Y, test_Y)])
    self._train_set = lgb.Dataset(data=train_X, label=train_Y, 
                                  feature_name=_feature_names)
    self._validate_set = lgb.Dataset(data=test_X, label=test_Y, 
                                  reference=self._train_set)
    self._booster = lgb.Booster(params={
      'boosting': 'gbdt',
      'verbosity': 1,  # 打印消息
      'learning_rate': 0.1,  # 学习率
      'num_leaves':5,
      'max_depth': 5,
      'objective': 'binary',
      'metric': 'auc',
      'seed': 321,
    },
      train_set=self._train_set)
    self._booster.add_valid(self._validate_set,'validate1')
    self._booster.set_train_data_name('trainAAAAA')
  def print_attr(self):
    print('feature name:',self._booster.feature_name())
    # feature name: ['Sepal_Length', 'Sepal_Width', 'Petal_Length', 'Petal_Width']
    print('feature nums:', self._booster.num_feature())
    # feature nums: 4
  def test_train(self):
    for i in range(0,4):
      self._booster.update(self._train_set)
      print('after iter:%d'%self._booster.current_iteration())
      print('train eval:',self._booster.eval(self._train_set, name='train'))
      print('test eval:',self._booster.eval(self._validate_set,name='eval'))
   # after iter:1
   # train eval: [('train', 'auc', 0.9776530612244898, True)]
   # test eval: [('eval', 'auc', 0.9783333333333334, True)]
   # after iter:2
   # train eval: [('train', 'auc', 0.9907142857142858, True)]
   # test eval: [('eval', 'auc', 0.9872222222222222, True)]
   # after iter:3
   # train eval: [('train', 'auc', 0.9922448979591837, True)]
   # test eval: [('eval', 'auc', 0.9888888888888889, True)]
   # after iter:4
   # train eval: [('train', 'auc', 0.9922448979591837, True)]
   # test eval: [('eval', 'auc', 0.9888888888888889, True)]
  def test(self):
    self.print_attr()
    self.test_train()

4.2.2 直接学习

lightgbm.train() 函数执行直接训练。
```
lightgbm.train(params, train_set, num_boost_round=100, valid_sets=None,
  valid_names=None, fobj=None, feval=None, init_model=None, feature_name='auto',
  categorical_feature='auto', early_stopping_rounds=None, evals_result=None, 
  verbose_eval=True, learning_rates=None, keep_training_booster=False, callbacks=None)
```
参数：
- params：一个字典，给出了训练参数
- train_set：一个Dataset对象，给出了训练集
- num_boost_round：一个整数，给出了boosting iteration 的次数。默认为100
- valid_sets：一个Dataset 的列表或者None，给出了训练期间用于evaluate的数据集。默认为None
- valid_names：一个字符串列表或者None，给出了valid_sets 中每个数据集的名字。默认为None
- fobj：一个可调用对象或者None，表示自定义的目标函数。默认为None
- feval：一个可调用对象或者None，它表示自定义的evaluation 函数。默认为None。它的输入为(y_true, y_pred)、或者( y_true, y_pred, weight) 、或者(y_true, y_pred, weight, group)，返回一个元组：(eval_name,eval_result,is_higher_better) 。或者返回该元组的列表。
- init_model：一个字符串或者None，它给出了lightgbm model 保存的文件名，或者Booster实例的名字。后续的训练在该model 或者Booster 实例的基础上继续训练。默认为None
- feature_name：一个字符串列表或者'auto'，它指定了特征的名字。默认为'auto'
  - 如果数据源为pandas DataFrame 并且feature_name='auto'，则使用DataFrame 的 column names
- categorical_feature：一个字符串列表、整数列表、或者'auto'。它指定了categorical 特征。默认为'auto'
  - 如果是整数列表，则给定了categorical 特征的下标
  - 如果是字符串列表，在给定了categorical 特征的名字。此时必须设定feature_name 参数。
  - 如果是'auto' 并且数据源为pandas DataFrame，则DataFrame 的 categorical 列将作为categorical 特征
- early_stopping_rounds：一个整数或者None，表示验证集的score 在连续多少轮未改善之后就早停。默认为None
  
  该参数要求至少有一个验证集以及一个metric。
  
  如果由多个验证集或者多个metric，则对所有的验证集和所有的metric 执行。
  
  如果发生了早停，则模型会添加一个best_iteration字段。该字段持有了最佳的迭代步。
- evals_result：一个字典或者None，这个字典用于存储在valid_sets 中指定的所有验证集的所有验证结果。默认为None
- verbose_eval：一个布尔值或者整数。默认为True
  - 如果是True，则在验证集上每个boosting stage 打印对验证集评估的metric。
  - 如果是整数，则每隔verbose_eval 个 boosting stage 打印对验证集评估的metric。
  - 否则，不打印这些
  该参数要求至少由一个验证集。
- learning_rates：一个列表、None、可调用对象。它指定了学习率。默认为None
  - 如果为列表，则它给出了每一个boosting 步的学习率
  - 如果为一个可调用对象，则在每个boosting 步都调用它，从而生成一个学习率
  - 如果为一个数值，则学习率在学习期间都固定为它。
  你可以使用学习率衰减从而生成一个更好的学习率序列。
- keep_training_booster：一个布尔值，指示训练得到的Booster对象是否还会继续训练。默认为False
  - 如果为False，则返回的booster 对象在返回之前将被转换为_InnerPredictor 。
    
    当然你也可以将_InnerPredictor 传递给init_model 参数从而继续训练。
- callbacks：一个可调用对象的列表，或者None。它给出了在每个迭代步之后需要执行的函数。默认为None
返回：一个Booster 实例
lightgbm.cv() 函数执行交叉验证训练。
```
lightgbm.cv(params, train_set, num_boost_round=10, folds=None, nfold=5,
    stratified=True, shuffle=True, metrics=None, fobj=None, feval=None,
    init_model=None, feature_name='auto', categorical_feature='auto', 
    early_stopping_rounds=None, fpreproc=None, verbose_eval=None, show_stdv=True,
    seed=0, callbacks=None)
```
参数：
- params：一个字典，给出了训练参数
- train_set：一个Dataset对象，给出了训练集
- num_boost_round：一个整数，给出了boosting iteration 的次数。默认为10
- folds：一个生成器、一个迭代器、或者None。如果是生成器或者迭代器，则其迭代结果为元组：(训练部分样本下标列表,测试部分样本下标列表)，分别给出了每个fold 的训练部分和测试部分的下标。默认为None。
  
  该参数比其它的拆分参数优先级更高。
- nfold：一个整数，指定了CV 的数量。默认为5 。
- stratified：一个布尔值，指示是否进行分层拆分。默认为True 。
- shuffle：一个布尔值，指示是否在拆分之前先混洗数据。默认为True 。
- metrics：一个字符串、字符串列表、或者None。指定在CV 过程中的evaluation metric 。默认为None。
  
  如果非None，则它会覆盖params 的metric 参数。
- fobj：参考lightgbm.train()
- feval：参考lightgbm.train()
- init_model：参考lightgbm.train()
- feature_name：参考lightgbm.train()
- categorical_feature：参考lightgbm.train()
- early_stopping_rounds：一个整数或者None，表示CV error在连续多少轮未改善之后就早停。默认为None
  
  在返回的evaluation history 中，最后一项就是最佳迭代时的结果（而不是最后一次迭代时的结果）。
- fpreproc：一个可调用对象或者None，默认为None 。它是一个预处理函数，在训练开始之前进行。
  
  它的参数为(dtrain,dtest,params)，返回值是经过处理之后的(dtrain,dtest,params)
- verbose_eval：参考lightgbm.train()
- show_stdv：一个布尔值，指示是否在训练过程中展示标准差信息。默认为True。
  
  注意：返回结果中始终包含标准差信息，与该参数无关。
- seed：一个整数，给出了生成fold 的随机数种子。默认为0
- callbacks：参考lightgbm.train()
返回值：evaluation history，它是一个字典，格式为：
```
{
    'metric1-mean': [values], 'metric1-stdv': [values], 
    'metric2-mean': [values], 'metric2-stdv': [values],
    ...
}
```

4.2.3 scikit-learn API

4.2.3.1 LGBMModel

LGBMModel 实现了lightgbm 类似于scikit-learn 的接口
```
class lightgbm.LGBMModel(boosting_type='gbdt', num_leaves=31, max_depth=-1,
   learning_rate=0.1, n_estimators=10, max_bin=255, subsample_for_bin=200000,
   objective=None, min_split_gain=0.0, min_child_weight=0.001, min_child_samples=20,
   subsample=1.0, subsample_freq=1, colsample_bytree=1.0, reg_alpha=0.0,
   reg_lambda=0.0, random_state=None, n_jobs=-1, silent=True,class_weight=None,
   **kwargs)
```
参数：
- boosting_type：一个字符串，指定了基学习器的算法。默认为'gbdt'。可以为：
  - 'gbdt'：表示传统的梯度提升决策树。默认值为'gbdt'
  - 'rf'：表示随机森林。
  - 'dart'：表示带dropout 的gbdt
  - goss：表示Gradient-based One-Side Sampling 的gbdt
- num_leaves：一个整数，给出了一棵树上的叶子数。默认为 31
- max_depth：一个整数，限制了树模型的最大深度，默认值为-1。
  - 如果小于0，则表示没有限制。
- learning_rate：一个浮点数，给出了学习率。默认为 0.1
- n_estimators：一个整数，给出了boosted trees 的数量。默认为 10
- max_bin：一个整数，指定每个特征的最大分桶数量。默认为255。
- class_weight：给出了每个类别的权重占比。
  - 可以为字符串'balanced'，此时类别权重反比与类别的频率。
  - 可以为字典，此时人工给出了每个类别的权重。
  - 如果为None，则认为每个类别的比例一样。
  该参数仅用于多类分类问题。对于二类分类问题，可以使用is_unbalance 参数。
- subsample_for_bin：一个整数，表示用来构建直方图的样本的数量。默认为200000。
- objective：一个字符串、可调用对象或者为None，表示问题类型以及对应的目标函数。参考2.2.1 核心参数->objective 。
  
  默认为None ，此时对于LGBMRegressor 为'regression'；对于LGBMClassifier 为'binary' 或者'multiclass'；对于LGBMRanker 为'lambdarank'。
  
  如果为自定义的可调用对象，则它的签名为：objective(y_true, y_pred) -> grad, hess ；或者签名为：objective(y_true, y_pred, group) -> grad, hess。其中：
  - y_true：一个形状为(n_samples,)（对于多类分类问题，则是(n_samples,n_classes)）的array-like 对象，给出了真实的标签值。
  - y_pred：一个形状为(n_samples,) （对于多类分类问题，则是(n_samples,n_classes)）的array-like 对象，给出了预测的标签值。
  - group：一个array-like对象，给出了数据的分组信息。它用于ranking 任务
  - grad：一个形状为(n_samples,)（对于多类分类问题，则是(n_samples,n_classes)）的array-like 对象，给出了每个样本的梯度值。
  - hess：一个形状为(n_samples,)（对于多类分类问题，则是(n_samples,n_classes)）的array-like 对象，给出了每个样本的二阶导数值。
- min_split_gain：一个浮点数，表示执行切分的最小增益，默认为0
- min_child_weight：一个浮点数，表示一个叶子节点上的最小hessian 之和。（也就是叶节点样本权重之和的最小值）默认为1e-3 。
- min_child_samples：一个整数，表示一个叶子节点上包含的最少样本数量。默认值为 20
- subsample：一个浮点数，表示训练样本的采样比例。参考2.2.2 学习控制参数->subsample 。
- subsample_freq：一个浮点数，表示训练样本的采样频率。参考2.2.2 学习控制参数->subsample_freq 。
- colsample_bytree：一个浮点数，表示特征的采样比例。参考2.2.2 学习控制参数->colsample_bytree 。
- reg_alpha：一个浮点数，表示L1正则化系数。默认为0
- reg_lambda：一个浮点数，表示L2正则化系数。默认为0
- random_state：一个整数或者None，表示随机数种子。如果为None，则使用默认的种子。默认为None
- n_jobs：一个整数，指定并行的线程数量。如果为-1，则表示使用所有的CPU。默认为-1
- silent：一个布尔值，指示是否在训练过程中屏蔽输出。默认为True。
- kwargs：其它的参数。
属性：
- .n_features_：一个整数，给出了特征的数量
- .classes_：一个形状为(n_classes,) 的numpy array，给出了样本的标签。（仅仅在分类问题中有效）
- .n_classes_：一个整数，给出了类别的数量。（仅仅在分类问题中有效）
- .best_score_：一个字典或者None，给出了训练完毕模型的最好的score
- .best_iteration_：一个字典或者None。当early_stopping_round 参数设定时，它给出了训练完毕模型的最好的迭代步。
- .objective_：一个字符串或者可调用对象，给出了训练模型的目标函数
- .booster_：一个Booster对象，给出了底层的Booster 对象。
- .evals_result_：一个字典或者None。当early_stopping_round 参数设定时，它给出了模型的evaluation results 。
- .feature_importances_：一个形状为(n_features,) 的 numpy array，给出了特征的重要性（值越大，则对于的特征越重要）。
方法：
- .apply(X,num_iteration=0)：预测每个样本在每个树的哪个叶节点上。
  - 参数：
    - X：一个array-like 对象，或者一个sparse matrix，其形状为(n_samples,n_features) ，表示测试样本集
    - num_iteration：一个整数，指示在预测时，使用多少个子树。默认为0，表示使用所有的子树。
  - 返回值：一个array-like对象，形状为(n_samples,n_trees)。它给出了每个样本在每个子树的哪个节点上。
- .fit()：训练模型。
```
.fit(X, y, sample_weight=None, init_score=None, group=None, eval_set=None,
    eval_names=None, eval_sample_weight=None, eval_init_score=None,
    eval_group=None, eval_metric=None, early_stopping_rounds=None, verbose=True,
    feature_name='auto', categorical_feature='auto', callbacks=None)
```
  参数：
  - X：一个array-like 对象，或者一个sparse matrix，其形状为(n_samples,n_features) ，表示训练样本集
  - y：一个array-like对象，形状为(n_samples,)，给出了标签值。
  - sample_weight：一个形状为(n_samples,) 的array-like 对象，或者为None。给出了每个训练样本的权重。默认为None
  - init_score：一个形状为(n_samples,) 的array-like 对象，或者为None。给出了每个训练样本的init score 。默认为None
  - group：一个形状为(n_samples,) 的array-like 对象，或者为None。给出了每个训练样本的分组。默认为None
  - eval_set：一个元素为(X,y) 的列表，或者None。给出了验证集，用于早停。默认为None。
    
    其中X,y 的类型与参数X,y 相同。
  - eval_names：一个字符串的列表，或者None。给出了每个验证集的名字。默认为None。
  - eval_sample_weight：一个array-like 的列表，或者None。给出了每个验证集中，每个样本的权重。默认为None。
  - eval_init_score：一个array-like 的列表，或者None。给出了每个验证集中，每个样本的init score。默认为None。
  - eval_group：一个array-like 的列表，或者None。给出了每个验证集中，每个样本的分组。默认为None。
  - eval_metric：一个字符串、字符串列表、可调用对象、或者None。给出了验证的metric。默认为None。
  - early_stopping_rounds：一个整数或者None，默认为None。参考lightgbm.train()
  - verbose：一个布尔值。如果为True，并且至少有一个验证集，则输出evaluation 信息。
  - feature_name：一个字符串列表、或者'auto'。参考lightgbm.train()
  - categorical_feature：一个字符串列表、整数、或者'auto'。参考lightgbm.train()
  - callbacks：一个可调用对象的列表或者为None 。参考lightgbm.train()
  返回值：self，即当前LGBMModel 对象自己
- .predict(X,raw_score=False,num_iteration=0)：执行预测。
  
  参数：
  - X：一个array-like 对象，或者一个sparse matrix，其形状为(n_samples,n_features) ，表示测试样本集。
    
    注意：如果是numpy array 或者 pandas dataframe 时，要求数据的列必须与训练时的列顺序一致。
  - raw_score：一个布尔值，指示是否输出raw score。默认为False
  - num_iteration：一个整数，指示在预测时，使用多少个子树。默认为0，表示使用所有的子树。
  返回值：一个形状为(n_samples,) 或者形状为(n_samples,n_classed) 的array-like 对象，表示预测结果

4.2.3.2 LGBMClassifier

LGBMClassifier 是LGBMModel 的子类，它用于分类任务。

class lightgbm.LGBMClassifier(boosting_type='gbdt', num_leaves=31, max_depth=-1,
   learning_rate=0.1, n_estimators=10, max_bin=255, subsample_for_bin=200000,
   objective=None, min_split_gain=0.0, min_child_weight=0.001, min_child_samples=20, 
   subsample=1.0, subsample_freq=1, colsample_bytree=1.0, reg_alpha=0.0,
   reg_lambda=0.0, random_state=None, n_jobs=-1, silent=True, **kwargs)

参数：参考LGBMModel

属性：参考LGBMModel
方法：
- .fit()：训练模型
```
fit(X, y, sample_weight=None, init_score=None, eval_set=None, eval_names=None,
    eval_sample_weight=None, eval_init_score=None, eval_metric='logloss',
    early_stopping_rounds=None, verbose=True, feature_name='auto',
    categorical_feature='auto', callbacks=None)
```
  参数：参考LGBMModel.fit()
  
  返回值：参考LGBMModel.fit()
- .predict_proba(X, raw_score=False, num_iteration=0)：预测每个样本在每个类上的概率。
  
  参数：参考LGBMModel.predict()
  
  返回值：一个形状为(n_samples,n_classes) 的array-like 对象，给出了每个样本在每个类别上的概率。
- 其它方法参考LGBMModel

4.2.3.3 LGBMRegressor

LGBMRegressor 是LGBMModel 的子类，它用于回归任务。

class lightgbm.LGBMRegressor(boosting_type='gbdt', num_leaves=31, max_depth=-1, 
   learning_rate=0.1, n_estimators=10, max_bin=255, subsample_for_bin=200000,
   objective=None, min_split_gain=0.0, min_child_weight=0.001, min_child_samples=20,
   subsample=1.0, subsample_freq=1, colsample_bytree=1.0, reg_alpha=0.0,
   reg_lambda=0.0, random_state=None, n_jobs=-1, silent=True, **kwargs)

参数：参考LGBMModel

属性：参考LGBMModel

方法：

.fit()：训练模型

fit(X, y, sample_weight=None, init_score=None, eval_set=None, eval_names=None,
    eval_sample_weight=None, eval_init_score=None, eval_metric='l2',
    early_stopping_rounds=None, verbose=True, feature_name='auto',
    categorical_feature='auto', callbacks=None)

参数：参考LGBMModel.fit()

返回值：参考LGBMModel.fit()

其它方法参考LGBMModel

4.2.3.4 LGBMRanker

LGBMRegressor 是LGBMModel 的子类，它用于ranking 任务。

class lightgbm.LGBMRanker(boosting_type='gbdt', num_leaves=31, max_depth=-1, 
   learning_rate=0.1, n_estimators=10, max_bin=255, subsample_for_bin=200000,
   objective=None, min_split_gain=0.0, min_child_weight=0.001, min_child_samples=20,
   subsample=1.0, subsample_freq=1, colsample_bytree=1.0, reg_alpha=0.0,
   reg_lambda=0.0, random_state=None, n_jobs=-1, silent=True, **kwargs)

参数：参考LGBMModel

属性：参考LGBMModel

方法：

.fit()：训练模型

fit(X, y, sample_weight=None, init_score=None, group=None, eval_set=None,
    eval_names=None, eval_sample_weight=None, eval_init_score=None,
    eval_group=None, eval_metric='ndcg', eval_at=[1], early_stopping_rounds=None, 
    verbose=True, feature_name='auto', categorical_feature='auto', callbacks=None)

参数：

eval_at：一个整数列表，给出了NDCG 的evaluation position 。默认为[1] 。
其它参数参考LGBMModel.fit()

返回值：参考LGBMModel.fit()

其它方法参考LGBMModel

4.2.3.5 Callbacks

这里介绍的callback 生成一些可调用对象，它们用于LGBMModel.fit() 方法的 callbacks 参数。
lightgbm.early_stopping(stopping_rounds,verbose=True)：创建一个回调函数，它用于触发早停。

触发早停时，要求至少由一个验证集以及至少有一种评估指标。如果由多个，则将它们都检查一遍。

参数：
- stopping_rounds：一个整数。如果一个验证集的度量在early_stopping_round 循环中没有提升，则停止训练。如果为0则表示不开启早停。
- verbose：一个布尔值。是否打印早停的信息。
返回值：一个回调函数。
lightgbm.print_evaluation(period=1,show_stdv=True)：创建一个回调函数，它用于打印evaluation 的结果。

参数：
- period：一个整数，默认为1。给出了打印evaluation 的周期。默认每个周期都打印。
- show_stdv：一个不热值，默认为True。指定是否打印标准差的信息（如果提供了标准差的话）。
返回值：一个回调函数。
lightgbm.record_evaluation(eval_result)：创建一个回调函数，它用于将evaluation history 写入到 eval_result 中。

参数：eval_result：一个字典，它将用于存放evaluation history。

返回值：一个回调函数。
lightgbm.reset_parameter(**kwargs)：创建一个回调函数，它用于在第一次迭代之后重新设置参数。

注意：当第一次迭代时，初始的参数仍然发挥作用。

参数：
- kwargs：一些关键字参数（如key=val），每个关键字参数的值必须是一个列表或者一个函数。给出了每一个迭代步的相应参数。
  - 如果是列表，则current_round 迭代时的参数为：val[current_round]
  - 如果是函数，则current_round 迭代时的参数值为：val(current_round)
返回值：一个回调函数。