lightGBM中的lightgbm.train

1. 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',
				keep_training_booster=False, callbacks=None)

• params ( dict ) – 训练参数。# 超参数设置
• train_set ( Dataset ) – 要训练的数据。# 训练数据
• num_boost_round ( int , optional ( default=100 ) ) – 提升迭代次数。# 循环的轮数
• valid_sets ( list of Dataset , or None , optional ( default=None ) ) – 训练期间要评估的数据列表。# 验证数据
• valid_names（str 列表，或None ，可选（默认=None ））- 的名称valid_sets。# 验证集名称
• early_stopping_rounds=200，# 如果200轮后没有提升，就停止循环

返回的是一个训练好的Booster模型

2.操作：
　　用于训练你的模型，返回的是一个训练好的Booster模型

2.返回 lightgbm.Booster

classlightgbm.Booster(params=None, train_set=None, model_file=None, model_str=None)

params ( dict or None , optional ( default=None ) ) – Booster 的参数。

train_set ( Dataset or None , optional ( default=None ) ) – 训练数据集。

model_file ( str , pathlib.Path or None , optional ( default=None ) ) – 模型文件的路径。

model_str ( str or None , optional ( default=None ) ) – 模型将从该字符串加载

methods

1、

feature_importance(importance_type='split', iteration=None)

Get feature importances.(获取特征重要性)
Parameters

importance_type (str, optional (default=“split”)) – 如何计算重要性。如果“拆分”，则结果包含该特征在模型中使用的次数。如果“增益”，结果包含使用该特征的分割的总增益。

iteration (int or None, optional (default=None)) –限制特征重要性计算中的迭代次数。如果None，如果存在最好的迭代，则使用它；否则，将使用所有树。如果 <= 0，则使用所有树（无限制）。

Returns：result – Array with feature importances.（结果- 具有特征重要性的数组）
Return type:numpy 数组 （numpy array）

2、

predict(data, start_iteration=0, num_iteration=None, raw_score=False, pred_leaf=False, pred_contrib=False, 
								data_has_header=False, is_reshape=True, **kwargs)

data:用于预测的数据源。如果是 str 或 pathlib.Path，它表示文本文件（CSV、TSV 或 LibSVM）的路径。
Returns:结果- 预测结果。对于特征贡献（何时），可以是稀疏对象或稀疏对象列表（每个元素代表一个类的预测pred_contrib=True）。
numpy 数组、scipy.sparse 或 scipy.sparse 列表

代码

# params 超参数设置

params = {'num_leaves': 491, # 叶节点数量
          'min_data_in_leaf': 106, # 每个叶子节点中的数据
          'objective': 'binary', # 任务：二分类
          'max_depth': -1, # -1 ： 不限制深度
          "boosting_type": "gbdt", # 'dart', 'goss', 'rf'
          "metric": 'auc', # 衡量标准
          "verbosity" : -1, # 不显示信息
          'random_state': 66, # 随机种子
         }

# params 超参数设置

params = {'num_leaves': 491, # 叶节点数量
          'min_data_in_leaf': 106, # 每个叶子节点中的数据
          'objective': 'binary', # 任务：二分类
          'max_depth': -1, # -1 ： 不限制深度
          "boosting_type": "gbdt", # 'dart', 'goss', 'rf'
          "metric": 'auc', # 衡量标准
          "verbosity" : -1, # 不显示信息
          'random_state': 66, # 随机种子
         }
         
# 创建DataFrame保存特征重要性
feature_importances = pd.DataFrame(index=None)

feature_importances['features'] = X.columns

# 5折交叉验证

#将原始数据随机分为两组，一组做为训练集，一组做为验证集，利用训练集训练分类器，
#然后利用验证集验证模型，记录最后的分类准确率为此分类器的性能指标。

folds = KFold(n_splits=5)

splits = folds.split(X, y) # 分割成5份，前4份是训练集索引，最后1份是验证集索引

next(iter(splits)) # 输出的是索引

best_auc = 0
best_model = None

for k, (train_indices, val_indices) in enumerate(splits):
    print("第 %d 折\n" % k)
    
    # iloc：根据标签的所在位置，从0开始计数，先选取行再选取列
    X_train_data, X_val_data = X.iloc[train_indices], X.iloc[val_indices] # 训练集， 验证集
    y_train, y_val = y.iloc[train_indices], y.iloc[val_indices] # 训练标签，验证标签
    #print("X_train_data shape : \t", X_train_data.shape, "X_val_data shape : \t", X_val_data.shape)
    
    #这里调用了 lightGBM 算法 ，第一个是传入数据，第二个是数据的标签
    train_dataset = lgb.Dataset(X_train_data, label=y_train) # 训练集
    val_dataset = lgb.Dataset(X_val_data, label=y_val) # 验证集
    
    lgb_model = lgb.train(params=params, # 超参数设置
                          train_set=train_dataset, # 训练数据
                          num_boost_round=10000, # 循环的轮数
                          valid_sets=val_dataset, # 验证数据
                          valid_names='validation', # 验证集名称
                          early_stopping_rounds=200,) # 如果200轮后没有提升，就停止循环
     
    # 保存特征重要性
    feature_importances[f'fold_{k+1}'] = lgb_model.feature_importance()
    #print("看一看有啥东西{}".format())
    # 对验证集进行预测
    y_val_pred = lgb_model.predict(X_val_data)
    
    # 计算roc_auc
    roc_auc = roc_auc_score(y_val, y_val_pred)
    print(f" Fold {k + 1} | AUC_ROC ： { roc_auc * 100}%")
    
    # 判断是否是最优模型
    if roc_auc > best_auc:
        best_auc = roc_auc
        best_model = lgb_model