零基础入门金融风控之贷款违约预测—建模与调参

基本模型

逻辑回归模型

• 逻辑回归是一个假设样本服从伯努利分布 ($f(x|p)=p^x(1-p{)}^{n-x}$)，利用极大似然估计和梯度下降求解的二分类模型。
• 逻辑回归本质上是线性回归，只是在特征到结果的映射中加入了一个 sigmoid 函数，即先把特征线性求和，然后使用非线性的函数将连续值映射到 0 与 1 之间。
   
• 优点
  • 训练速度较快，分类的时候，计算量仅仅只和特征的数目相关
  • 简单易理解，模型的可解释性非常好，从特征的权重可以看到不同的特征对最后结果的影响
  • 适合二分类问题，不需要缩放输入特征
  • 内存资源占用小，只需要存储各个维度的特征值
• 缺点
  • 逻辑回归需要预先处理缺失值和异常值
  • 不能用逻辑回归去解决非线性问题，因为逻辑回归的决策面是线性的
  • 对多重共线性数据较为敏感，且很难处理数据不平衡的问题
  • 准确率并不是很高，因为形式非常简单，很难去拟合数据的真实分布

更多细节参见：
逻辑回归初步
Logistic Regression 逻辑回归

决策树模型

• 决策树是机器学习中的一种分类方法，其结构为树形结构，包含一个根结点、多个内部结点和多个叶结点。根结点包含样本全集，每个内部结点表示在一个属性上的判断，每个分支代表一个判断结果的输出，叶结点代表最终分类的结果。

• 决策树算法通过计算每个属性上的信息增益（属性 X 上的分割使得类 Y 不确定性减少的程度），选择信息增益最大的特征作为根节点，其他特征依次选为内部结点，重复此过程直到将所有样本分到叶结点上。

• 信息增益也可以换为其他的衡量标准，根据衡量标准的不同可以分为，ID3，C4.5，CART 等算法。

• 决策树通过剪枝策略来防止过拟合，有预剪枝和后剪枝两种方法。预剪枝方法在建立决策树的过程中进行剪枝（例如设置信息增益的阈值，当信息增益大于阈值时才进行分裂），更为实用。后剪枝方法在建立完决策树之后进行剪枝操作。

• 优点

  • 简单直观，生成的决策树可以可视化展示
  • 数据不需要预处理及归一化，也不需要处理缺失数据
  • 既可以处理离散值，也可以处理连续值

• 缺点

  • 决策树算法非常容易过拟合，导致泛化能力不强（可进行适当的剪枝）
  • 采用的是贪心算法，容易得到局部最优解

更多细节参见：
决策树实战

集成算法

• 通过组合多个学习器来完成学习任务，通过集成方法，可以将多个弱学习器组合成一个强分类器，因此集成学习的泛化能力一般比单一分类器要好。
• 集成方法主要包括 Bagging 和 Boosting，Bagging 和 Boosting 都是将已有的分类或回归算法通过一定方式组合起来，形成一个更加强大的分类。
• 常见的基于 Baggin 思想的集成模型有：随机森林
• 基于 Boosting 思想的集成模型有：Adaboost、GBDT、XgBoost、LightGBM 等。

Baggin 和 Boosting的区别：

• 样本选择上： Bagging 方法的训练集是从原始数据集中有放回的选取，所以从原始集中选出的各训练集之间是独立的；而 Boosting 方法需要每一轮的训练集不变，只是训练集中每个样本在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整。
• 样例权重上： Bagging 方法使用均匀取样，所以每个样本的权重相等；而 Boosting 方法根据错误率不断调整样本的权值，错误率越大则权重越大 。
• 预测函数上： Bagging 方法中所有预测函数的权重相等；而 Boosting 方法中每个弱分类器都有相应的权重，对于分类误差小的分类器会有更大的权重。
• 并行计算上： Bagging 方法中各个预测函数可以并行生成；而 Boosting 方法各个预测函数只能顺序生成，因为后一个模型参数需要前一轮模型的结果。

梯度提升树 (GBDT) 模型

• GBDT 是一个集成模型，可以看做是很多个基模型的线性相加，其中的基模型就是 CART 回归树。
• CART 树是一个决策树模型，与普通的 ID3，C4.5 相比，CART 树的主要特征是，它是一颗二分树，每个节点特征取值为“是”和“不是”。例如，在 ID3 中如果天气是一个特征，那么基于此的节点特征取值为“晴天”、“阴天”、“雨天”，而 CART 树中就是“不是晴天”与“是晴天”。
• 这样的决策树递归的划分每个特征，并且在输入空间的每个划分单元中确定唯一的输出。
• 算法流程：
   
  

更多细节参见：
机器学习大杀器——梯度提升树GBDT

XGBoost 模型

• 传统 GBDT 以 CART 作为基分类器，xgboost 还支持线性分类器，这个时候 xgboost 相当于带 L1 和 L2 正则化项的逻辑回归或者线性回归。
• 传统 GBDT 在优化时只用到一阶导数信息，xgboost 则对代价函数进行了二阶泰勒展开，同时用到了一阶和二阶导数。（xgboost 支持自定义代价函数，只要函数可导）
• xgboost 在代价函数里加入了正则项，用于控制模型的复杂度。正则项里包含了树的叶子节点个数、每个叶子节点上输出的 score 的 L2 模的平方和。
• 学习速率（xgboost 中的 eta）。xgboost 在进行完一次迭代后，会将叶子节点的权重乘上该系数，主要是为了削弱每棵树的影响，让后面有更大的学习空间。（传统GBDT的实现也有学习速率）
• 列抽样（column subsampling）。xgboost 借鉴了随机森林的做法，支持列抽样，不仅能降低过拟合，还能减少计算。
• 缺失值的处理。对于特征的值有缺失的样本，xgboost 可以自动学习出它的分裂方向。
• xgboost 工具支持并行。xgboost 的并行是在特征粒度上的。

更多细节参见：
白话机器学习算法理论+实战番外篇之Xgboost
机器学习算法中 GBDT 和 XGBOOST 的区别有哪些？

LightGBM 模型

更多细节参见：
白话机器学习算法理论+实战番外篇之LightGBM

CatBoost 模型

更多细节参见：
深入理解CatBoost

RNN 模型

更多细节参见：
深度理解RNN

LSTM 模型

更多细节参见：
人人都能看懂的LSTM介绍及反向传播算法推导

模型评估方法

• 在训练集上面的误差称为训练误差或者经验误差，在测试集上的误差称为测试误差。

• 对于数据集的划分，通常要保证满足以下条件：

  • 训练集和测试集的分布要与样本真实分布一致，即训练集和测试集都要保证是从样本真实分布中独立同分布采样而得。
  • 训练集和测试集要互斥

• 数据集的划分有三种方法：留出法、交叉验证法和自助法

  • 留出法
    直接将数据集 D 划分为两个互斥的集合，其中一个集合作为训练集 S，另一个作为测试集 T。在划分的时候要尽可能保证数据分布的一致性，避免因数据划分过程引入额外的偏差而对最终结果产生影响。为了保证数据分布的一致性，通常采用分层采样的方式。
  • 交叉验证法
    k 折交叉验证通常将数据集 D 分为 k 份，其中 k-1 份作为训练集，剩余的 1 份作为测试集，这样就可以获得 k 组训练/测试集，可以进行 k 次训练与测试，最终返回的是 k 次测试结果的均值。交叉验证中数据集的划分依然是依据分层采样的方式来进行。对于交叉验证法，k 值的选取往往决定了评估结果的稳定性和保真性，通常k值选取10。当 k=1 的时候，称之为留一法。
  • 自助法
    每次从数据集 D 中取一个样本作为训练集中的元素，然后把该样本放回，重复该行为 m 次，得到大小为 m 的训练集，把那些没有出现过的样本作为测试集。这样采样得到的测试集的大小大约为 D 的 36.8%.

• 总结

  • 对于数据量充足的时候，通常采用留出法或者 k 折交叉验证法。
  • 对于数据集小且难以有效划分时使用自助法。
  • 对于数据集小且可有效划分的时候最好使用留一法来进行划分，因为这种方法最为准确。

更多内容参见：
交叉验证——对数据集的划分

模型调参

初始化

import pandas as pd
import numpy as np
import warnings
import os
import seaborn as sns
import matplotlib.pyplot as plt

读取数据

通过调整数据类型，减少数据在内存中占用的空间

def reduce_mem_usage(df):
    start_mem = df.memory_usage().sum() 
    print('Memory usage of dataframe is {:.2f} B'.format(start_mem))
    
    for col in df.columns:
        col_type = df[col].dtype
        
        if col_type != object:
            c_min = df[col].min()
            c_max = df[col].max()
            if str(col_type)[:3] == 'int':
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: # int8 类型数据可以表示的最小、最大的数
                    df[col] = df[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df[col] = df[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df[col] = df[col].astype(np.int32)
                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
                    df[col] = df[col].astype(np.int64)  
            else:
                if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                    df[col] = df[col].astype(np.float16)
                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                    df[col] = df[col].astype(np.float32)
                else:
                    df[col] = df[col].astype(np.float64)
        else:
            df[col] = df[col].astype('category')

    end_mem = df.memory_usage().sum() 
    print('Memory usage after optimization is: {:.2f} B'.format(end_mem))
    print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
    
    return df

# 读取数据
INPUT_PATH = 'G:\代码\数据挖掘实践\\' 
data = pd.read_csv(INPUT_PATH +'train.csv')
data = reduce_mem_usage(data)

Memory usage of dataframe is 300800128.00 B
Memory usage after optimization is: 72834944.00 B
Decreased by 75.8%

建模

from sklearn.model_selection import KFold
# 分离数据集，方便进行交叉验证
X_train = data.drop(['id','issueDate','isDefault'], axis=1)
y_train = data['isDefault']

# 5 折交叉验证
folds = 5
seed = 2020
kf = KFold(n_splits=folds, shuffle=True, random_state=seed)

使用 Lightgbm：

from sklearn.model_selection import train_test_split
import lightgbm as lgb
# 划分训练集与验证集
X_train_split, X_val, y_train_split, y_val = train_test_split(X_train, y_train, test_size=0.2)
train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
valid_matrix = lgb.Dataset(X_val, label=y_val)
params = {
            'boosting_type': 'gbdt',
            'objective': 'binary',
            'learning_rate': 0.1,
            'metric': 'auc',
            'min_child_weight': 1e-3,
            'num_leaves': 31,
            'max_depth': -1,
            'reg_lambda': 0,
            'reg_alpha': 0,
            'feature_fraction': 1,
            'bagging_fraction': 1,
            'bagging_freq': 0,
            'seed': 2020,
            'nthread': 8,
            'verbose': -1,
}

# 进行训练
model = lgb.train(params, train_set=train_matrix, valid_sets=valid_matrix, num_boost_round=20000, verbose_eval=1000, early_stopping_rounds=200)

Training until validation scores don't improve for 200 rounds
Early stopping, best iteration is:
[111]	valid_0's auc: 0.719222

画出 roc 曲线：

from sklearn import metrics
from sklearn.metrics import roc_auc_score

val_pre_lgb = model.predict(X_val, num_iteration=model.best_iteration) # 计算在验证集上的预测值
fpr, tpr, threshold = metrics.roc_curve(y_val, val_pre_lgb) # 计算画 roc 曲线图需要的数据
roc_auc = metrics.auc(fpr, tpr)
print('未调参前 lightgbm 模型在验证集上的 AUC：{}'.format(roc_auc))
plt.figure(figsize=(8, 8))
plt.title('Validation ROC')
plt.plot(fpr, tpr, 'b', label = 'Val AUC = %0.4f' % roc_auc)
plt.ylim(0,1)
plt.xlim(0,1)
plt.legend(loc='best')
plt.title('ROC')
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')
plt.plot([0,1],[0,1],'r--') # 画对角线
plt.show()

未调参前 lightgbm 模型在验证集上的 AUC：0.719221672733664

使用 5 折交叉验证进行模型性能评估：

cv_scores = []
for i, (train_index, valid_index) in enumerate(kf.split(X_train, y_train)):
    print('************************************ {} ************************************'.format(str(i+1)))
    X_train_split, y_train_split, X_val, y_val = X_train.iloc[train_index], y_train[train_index], X_train.iloc[valid_index], y_train[valid_index]
    train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
    valid_matrix = lgb.Dataset(X_val, label=y_val)
    params = {
                'boosting_type': 'gbdt',
                'objective': 'binary',
                'learning_rate': 0.1,
                'metric': 'auc',
                'min_child_weight': 1e-3,
                'num_leaves': 31,
                'max_depth': -1,
                'reg_lambda': 0,
                'reg_alpha': 0,
                'feature_fraction': 1,
                'bagging_fraction': 1,
                'bagging_freq': 0,
                'seed': 2020,
                'nthread': 8,
                'verbose': -1,
    }    
    model = lgb.train(params, train_set=train_matrix, num_boost_round=20000, valid_sets=valid_matrix, verbose_eval=1000, early_stopping_rounds=200)
    val_pred = model.predict(X_val, num_iteration=model.best_iteration)
    
    cv_scores.append(roc_auc_score(y_val, val_pred))
    print(cv_scores)

print("lgb_scotrainre_list:{}".format(cv_scores))
print("lgb_score_mean:{}".format(np.mean(cv_scores)))
print("lgb_score_std:{}".format(np.std(cv_scores)))

lgb_score_mean:0.718386632269293
lgb_score_std:0.0015284427925435235

调参

贪心调参

• 先对对模型影响最大的参数进行调优，其他参数保持不变，找到该模型的最优取值，再对对模型影响次之的参数进行调优，如此下去，直到所有的参数调整完毕

• 该方法的缺点就是可能会调到局部最优而不是全局最优

• 需要注意的是在树模型中参数调整的顺序，也就是各个参数对模型的影响程度，日常调参过程中常用的参数和调参顺序如下：
  ①：max_depth、num_leaves
  ②：min_data_in_leaf、min_child_weight
  ③：bagging_fraction、 feature_fraction、bagging_freq
  ④：reg_lambda、reg_alpha
  ⑤：min_split_gain

# 贪心调参示例
from sklearn.model_selection import cross_val_score

best_obj = dict()
for obj in objective:
    model = LGBMRegressor(objective=obj)
    # 预测并计算 roc 的相关指标
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    best_obj[obj] = score

# num_leaves
best_leaves = dict()
for leaves in num_leaves:
    model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0], num_leaves=leaves)
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    best_leaves[leaves] = score
    
# max_depth
best_depth = dict()
for depth in max_depth:
    model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0],
                          num_leaves=min(best_leaves.items(), key=lambda x:x[1])[0],
                          max_depth=depth)
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    best_depth[depth] = score
    
# 依次将模型的参数通过上面的方式进行调整优化，并且通过可视化观察在每一个最优参数下模型的得分情况

网格搜索

sklearn 提供 GridSearchCV 用于进行网格搜索，只需要把模型的参数输进去，就能给出最优化的结果和参数。相比起贪心调参，网格搜索的结果会更优，但是网格搜索只适合于小数据集，对于大数据集调参的成本会变得很大。

# 网格搜索示例
from sklearn.model_selection import GridSearchCV,StratifiedKFold
def get_best_cv_params(learning_rate=0.1, n_estimators=581, num_leaves=31, max_depth=-1, bagging_fraction=1.0, 
                       feature_fraction=1.0, bagging_freq=0, min_data_in_leaf=20, min_child_weight=0.001, 
                       min_split_gain=0, reg_lambda=0, reg_alpha=0, param_grid=None):
    cv_fold = StratifiedKFold(n_splits=5, random_state=0, shuffle=True) 
    # 5 折交叉验证，StratifiedKFold 保证分的每一个 fold 里的正负样本比例和原数据的相同
    model_lgb = lgb.LGBMClassifier(learning_rate=learning_rate,
                                   n_estimators=n_estimators,
                                   num_leaves=num_leaves,
                                   max_depth=max_depth,
                                   bagging_fraction=bagging_fraction,
                                   feature_fraction=feature_fraction,
                                   bagging_freq=bagging_freq,
                                   min_data_in_leaf=min_data_in_leaf,
                                   min_child_weight=min_child_weight,
                                   min_split_gain=min_split_gain,
                                   reg_lambda=reg_lambda,
                                   reg_alpha=reg_alpha,
                                   n_jobs= 8
                                  )
    grid_search = GridSearchCV(estimator=model_lgb, 
                               cv=cv_fold,
                               param_grid=param_grid,
                               scoring='roc_auc'
                              )
    grid_search.fit(X_train, y_train)
    print('模型当前最优参数为:{}'.format(grid_search.best_params_))
    print('模型当前最优得分为:{}'.format(grid_search.best_score_))

# 每一步的最优参数需要在下一步进行手动更新

# 设置 n_estimators 为581，调整 num_leaves 和 max_depth，先粗调再细调
lgb_params = {'num_leaves': range(10, 80, 5), 'max_depth': range(3,10,2)}
get_best_cv_params(learning_rate=0.1, n_estimators=581, num_leaves=None, max_depth=None, min_data_in_leaf=20, 
                   min_child_weight=0.001,bagging_fraction=1.0, feature_fraction=1.0, bagging_freq=0, 
                   min_split_gain=0, reg_lambda=0, reg_alpha=0, param_grid=lgb_params)

# 上一步得到的最优 num_leaves为 30，max_depth为 7，进一步细调 num_leaves 和 max_depth
lgb_params = {'num_leaves': range(25, 35, 1), 'max_depth': range(5,9,1)}
get_best_cv_params(learning_rate=0.1, n_estimators=85, num_leaves=None, max_depth=None, min_data_in_leaf=20, 
                   min_child_weight=0.001,bagging_fraction=1.0, feature_fraction=1.0, bagging_freq=0, 
                   min_split_gain=0, reg_lambda=0, reg_alpha=0, param_grid=lgb_params)


# 固定 min_data_in_leaf 为 45，min_child_weight 为 0.001，对 bagging_fraction、feature_fraction 和 bagging_freq 进行调参
lgb_params = {'bagging_fraction': [i/10 for i in range(5,10,1)], 
              'feature_fraction': [i/10 for i in range(5,10,1)],
              'bagging_freq': range(0,81,10)
             }
get_best_cv_params(learning_rate=0.1, n_estimators=85, num_leaves=29, max_depth=7, min_data_in_leaf=45, 
                   min_child_weight=0.001,bagging_fraction=None, feature_fraction=None, bagging_freq=None, 
                   min_split_gain=0, reg_lambda=0, reg_alpha=0, param_grid=lgb_params)


# 固定 bagging_fraction 为 0.4、feature_fraction 为 0.6、bagging_freq 为 40，对 reg_lambda、reg_alpha 进行调参
lgb_params = {'reg_lambda': [0,0.001,0.01,0.03,0.08,0.3,0.5], 'reg_alpha': [0,0.001,0.01,0.03,0.08,0.3,0.5]}
get_best_cv_params(learning_rate=0.1, n_estimators=85, num_leaves=29, max_depth=7, min_data_in_leaf=45, 
                   min_child_weight=0.001,bagging_fraction=0.9, feature_fraction=0.9, bagging_freq=40, 
                   min_split_gain=0, reg_lambda=None, reg_alpha=None, param_grid=lgb_params)


# 固定 reg_lambda、reg_alpha 为 0，对 min_split_gain 进行调参
lgb_params = {'min_split_gain': [i/10 for i in range(0,11,1)]}
get_best_cv_params(learning_rate=0.1, n_estimators=85, num_leaves=29, max_depth=7, min_data_in_leaf=45, 
                   min_child_weight=0.001,bagging_fraction=0.9, feature_fraction=0.9, bagging_freq=40, 
                   min_split_gain=None, reg_lambda=0, reg_alpha=0, param_grid=lgb_params)

# 参数确定好了以后，设置一个比较小的 learning_rate 0.005，来确定最终的 num_boost_round
cv_fold = StratifiedKFold(n_splits=5, random_state=0, shuffle=True)
final_params = {
                'boosting_type': 'gbdt',
                'learning_rate': 0.01,
                'num_leaves': 29,
                'max_depth': 7,
                'min_data_in_leaf':45,
                'min_child_weight':0.001,
                'bagging_fraction': 0.9,
                'feature_fraction': 0.9,
                'bagging_freq': 40,
                'min_split_gain': 0,
                'reg_lambda':0,
                'reg_alpha':0,
                'nthread': 6
               }
cv_result = lgb.cv(train_set=lgb_train,
                   early_stopping_rounds=20,
                   num_boost_round=5000,
                   nfold=5,
                   stratified=True,
                   shuffle=True,
                   params=final_params,
                   metrics='auc',
                   seed=0,
                  )
print('迭代次数{}'.format(len(cv_result['auc-mean'])))
print('交叉验证的AUC为{}'.format(max(cv_result['auc-mean']))) 

贝叶斯调参

贝叶斯调参的主要思想是：给定优化的目标函数（广义的函数，只需指定输入和输出即可，无需知道内部结构以及数学性质），通过不断地添加样本点来更新目标函数的后验分布（高斯过程,直到后验分布基本贴合于真实分布）。简单的说，就是考虑了上一次参数的信息，从而更好的调整当前的参数。

贝叶斯调参的步骤如下：

• 定义优化函数（rf_cv）
• 建立模型
• 定义待优化的参数
• 得到优化结果，并返回要优化的分数指标

from sklearn.model_selection import cross_val_score
# 定义优化函数
def rf_cv_lgb(num_leaves, max_depth, bagging_fraction, feature_fraction, bagging_freq, min_data_in_leaf, 
              min_child_weight, min_split_gain, reg_lambda, reg_alpha):
    # 建立模型
    model_lgb = lgb.LGBMClassifier(boosting_type='gbdt', bjective='binary', metric='auc',
                                   learning_rate=0.1, n_estimators=5000,
                                   num_leaves=int(num_leaves), max_depth=int(max_depth), 
                                   bagging_fraction=round(bagging_fraction, 2), feature_fraction=round(feature_fraction, 2),
                                   bagging_freq=int(bagging_freq), min_data_in_leaf=int(min_data_in_leaf),
                                   min_child_weight=min_child_weight, min_split_gain=min_split_gain,
                                   reg_lambda=reg_lambda, reg_alpha=reg_alpha,
                                   n_jobs= 8
                                  )    
    val = cross_val_score(model_lgb, X_train_split, y_train_split, cv=5, scoring='roc_auc').mean()    
    return val

from bayes_opt import BayesianOptimization
# 定义优化参数
bayes_lgb = BayesianOptimization(
    rf_cv_lgb, 
    {
        'num_leaves':(10, 200),
        'max_depth':(3, 20),
        'bagging_fraction':(0.5, 1.0),
        'feature_fraction':(0.5, 1.0),
        'bagging_freq':(0, 100),
        'min_data_in_leaf':(10,100),
        'min_child_weight':(0, 10),
        'min_split_gain':(0.0, 1.0),
        'reg_alpha':(0.0, 10),
        'reg_lambda':(0.0, 10),
    }
)

# 开始优化
bayes_lgb.maximize(n_iter=10)
# 显示优化结果
bayes_lgb.max

# 在验证集上验证调参之后的模型
cv_scores = []
for i, (train_index, valid_index) in enumerate(kf.split(X_train, y_train)):
    print('************************************ {} ************************************'.format(str(i+1)))
    X_train_split, y_train_split, X_val, y_val = X_train.iloc[train_index], y_train[train_index], X_train.iloc[valid_index], y_train[valid_index]    
    train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
    valid_matrix = lgb.Dataset(X_val, label=y_val)
    params = {
                'boosting_type': 'gbdt',
                'objective': 'binary',
                'metric': 'auc',
                'learning_rate': 0.01,
                'num_leaves': 14,
                'max_depth': 19,
                'min_data_in_leaf': 37,
                'min_child_weight':1.6,
                'bagging_fraction': 0.98,
                'feature_fraction': 0.69,
                'bagging_freq': 96,
                'reg_lambda': 9,
                'reg_alpha': 7,
                'min_split_gain': 0.4,
                'nthread': 8,
                'seed': 2020,
                'silent': True,
    }    
    model = lgb.train(params, train_set=train_matrix, num_boost_round=14269, valid_sets=valid_matrix, verbose_eval=1000, early_stopping_rounds=200)
    val_pred = model.predict(X_val, num_iteration=model.best_iteration)    
    cv_scores.append(roc_auc_score(y_val, val_pred))
    print(cv_scores)

print("lgb_scotrainre_list:{}".format(cv_scores))
print("lgb_score_mean:{}".format(np.mean(cv_scores)))
print("lgb_score_std:{}".format(np.std(cv_scores)))

lgb_score_mean:0.7232948166594191
lgb_score_std:0.001465571038410448

更多内容参见：
lightgbm 调包侠自救指南