金融风险预测赛 task4 建模与调参

deep learning 人工智能 python machine learning 决策树 pandas numpy LightGBM 调参 贝叶斯优化
个人项目 机器学习 深度学习
Publish Date:   2025-03-06
Word Count:   7.4k
Read Times:   32 Min
Read Count:  

金融风险预测赛-task4-建模与调参

比赛地址：https://tianchi.aliyun.com/competition/entrance/531830/introduction

1 模型对比与性能评估

逻辑回归

  • 优点
    • 训练速度较快，分类的时候，计算量仅仅只和特征的数目相关；
    • 简单易理解，模型的可解释性非常好，从特征的权重可以看到不同的特征对最后结果的影响；
    • 适合二分类问题，不需要缩放输入特征；
    • 内存资源占用小，只需要存储各个维度的特征值；
  • 缺点
    • 逻辑回归需要预先处理缺失值和异常值【可参考task3特征工程】；
    • 不能用Logistic回归去解决非线性问题，因为Logistic的决策面是线性的；
    • 对多重共线性数据较为敏感，且很难处理数据不平衡的问题；
    • 准确率并不是很高，因为形式非常简单，很难去拟合数据的真实分布；

决策树模型

  • 优点
    • 简单直观，生成的决策树可以可视化展示
    • 数据不需要预处理，不需要归一化，不需要处理缺失数据
    • 既可以处理离散值，也可以处理连续值
  • 缺点
    • 决策树算法非常容易过拟合，导致泛化能力不强（可进行适当的剪枝）
    • 采用的是贪心算法，容易得到局部最优解

集成模型学习方法

通过组合多个学习器来完成学习任务，通过集成方法，可以将多个弱学习器组合成一个强分类器，因此集成学习的泛化能力一般比单一分类器要好。

集成方法主要包括Bagging和Boosting，Bagging和Boosting都是将已有的分类或回归算法通过一定方式组合起来，形成一个更加强大的分类。两种方法都是把若干个分类器整合为一个分类器的方法，只是整合的方式不一样，最终得到不一样的效果。常见的基于Baggin思想的集成模型有：随机森林、基于Boosting思想的集成模型有：Adaboost、GBDT、XgBoost、LightGBM等。

Baggin和Boosting的区别总结如下：

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

模型评估方法

可看吴恩达机器学习Course2 week3 https://js6288.github.io/2025/02/09/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E5%90%B4%E6%81%A9%E8%BE%BEcourse2week3/

对于模型来说，其在训练集上面的误差我们称之为训练误差或者经验误差，而在测试集上的误差称之为测试误差。

对于我们来说，我们更关心的是模型对于新样本的学习能力，即我们希望通过对已有样本的学习，尽可能的将所有潜在样本的普遍规律学到手，而如果模型对训练样本学的太好，则有可能把训练样本自身所具有的一些特点当做所有潜在样本的普遍特点，这时候我们就会出现过拟合的问题。

因此我们通常将已有的数据集划分为训练集和测试集两部分，其中训练集用来训练模型，而测试集则是用来评估模型对于新样本的判别能力。

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

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

对于数据集的划分有三种方法：留出法，交叉验证法和自助法，下面挨个介绍：

  • ①留出法

    留出法是直接将数据集D划分为两个互斥的集合，其中一个集合作为训练集S，另一个作为测试集T。需要注意的是在划分的时候要尽可能保证数据分布的一致性，即避免因数据划分过程引入额外的偏差而对最终结果产生影响。为了保证数据分布的一致性，通常我们采用分层采样的方式来对数据进行采样。

    Tips： 通常，会将数据集D中大约2/3~4/5的样本作为训练集，其余的作为测试集。

  • ②交叉验证法

    k折交叉验证通常将数据集D分为k份，其中k-1份作为训练集，剩余的一份作为测试集，这样就可以获得k组训练/测试集，可以进行k次训练与测试，最终返回的是k个测试结果的均值。交叉验证中数据集的划分依然是依据分层采样的方式来进行。

    对于交叉验证法，其k值的选取往往决定了评估结果的稳定性和保真性，通常k值选取10。

    将数据集中的每一个样本单独作为验证集，其余所有样本作为训练集。换句话说，K等于数据集中的样本数N。**(留一法)**留一法是一种极端形式的K折交叉验证，它最大限度地利用了数据，但同时也带来了较高的计算成本和时间开销。因此，它通常适用于样本量较小的数据集或对计算资源要求不高的场景。

    假设我们有一个数据集，并选择K=5：

    1. 数据划分：将数据集随机分成5个子集（折）。
    2. 循环训练与验证：
      • 第一次：使用第1个子集作为验证集，剩余4个子集作为训练集。
      • 第二次：使用第2个子集作为验证集，剩余4个子集作为训练集。
      • 依此类推，直到所有子集都作为验证集使用过一次。
    3. 结果汇总：计算5次验证结果的平均值和标准差。

  • ③自助法

    我们每次从数据集D中取一个样本作为训练集中的元素，然后把该样本放回，重复该行为m次，这样我们就可以得到大小为m的训练集，在这里面有的样本重复出现，有的样本则没有出现过，我们把那些没有出现过的样本作为测试集。

    进行这样采样的原因是因为在D中约有36.8%的数据没有在训练集中出现过。留出法与交叉验证法都是使用分层采样的方式进行数据采样与划分，而自助法则是使用有放回重复采样的方式进行数据采样

数据集划分总结

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

模型评价标准

对于本次比赛，我们选用auc作为模型评价标准，类似的评价标准还有ks、f1-score等，具体介绍与实现大家可以回顾下task1中的内容。

一起来看一下auc到底是什么？

在逻辑回归里面，对于正负例的界定，通常会设一个阈值，大于阈值的为正类，小于阈值为负类。如果我们减小这个阀值，更多的样本会被识别为正类，提高正类的识别率，但同时也会使得更多的负类被错误识别为正类。为了直观表示这一现象，引入ROC。

根据分类结果计算得到ROC空间中相应的点，连接这些点就形成ROC curve，横坐标为False Positive Rate(FPR：假正率)，纵坐标为True Positive Rate(TPR：真正率)。 一般情况下，这个曲线都应该处于(0,0)和(1,1)连线的上方,如图：

TPR：在所有实际为正例的样本中，被正确地判断为正例之比率
$$
TPR= \frac{TP}{TP+FN}
$$
FPR：在所有实际为负例的样本中，被错误地判断为正例之比率。
$$
FPR = \frac{FP}{FP+TN}
$$
ROC曲线中的四个点：

  • 点(0,1)：即FPR=0, TPR=1，意味着FN＝0且FP＝0，将所有的样本都正确分类；
  • 点(1,0)：即FPR=1，TPR=0，最差分类器，避开了所有正确答案；
  • 点(0,0)：即FPR=TPR=0，FP＝TP＝0，分类器把每个实例都预测为负类；
  • 点(1,1)：分类器把每个实例都预测为正类

总之：ROC曲线越接近左上角，该分类器的性能越好，其泛化性能就越好。而且一般来说，如果ROC是光滑的，那么基本可以判断没有太大的overfitting。

但是对于两个模型，我们如何判断哪个模型的泛化性能更优呢？这里我们有主要以下两种方法：

如果模型A的ROC曲线完全包住了模型B的ROC曲线，那么我们就认为模型A要优于模型B；

如果两条曲线有交叉的话，我们就通过比较ROC与X，Y轴所围得曲线的面积来判断，面积越大，模型的性能就越优，这个面积我们称之为AUC(area under ROC curve)

2 代码

import pandas as pd
import numpy as np
import warnings
import os
import seaborn as sns
import matplotlib.pyplot as plt
"""
sns 相关设置
@return:
"""
# 声明使用 Seaborn 样式
sns.set()
# 有五种seaborn的绘图风格，它们分别是：darkgrid, whitegrid, dark, white, ticks。默认的主题是darkgrid。
sns.set_style("whitegrid")
# 有四个预置的环境，按大小从小到大排列分别为：paper, notebook, talk, poster。其中，notebook是默认的。
sns.set_context('talk')
# 中文字体设置-黑体
plt.rcParams['font.sans-serif'] = ['SimHei']
# 解决保存图像是负号'-'显示为方块的问题
plt.rcParams['axes.unicode_minus'] = False
# 解决Seaborn中文显示问题并调整字体大小
sns.set(font='SimHei')

reduce_mem_usage 函数通过调整数据类型，帮助我们减少数据在内存中占用的空间

def reduce_mem_usage(df):
    start_mem = df.memory_usage().sum() / (1024 ** 2)  # 转换为MB
    print('Memory usage of dataframe is {:.2f} MB'.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:
                    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() / (1024 ** 2)  # 转换为MB
    print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
    print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))

    return df

读取数据

from utils_jessie import reduce_mem_usage
data = pd.read_csv('user_data/data_for_model.csv')
data = reduce_mem_usage(data)

简单建模

Tips1：金融风控的实际项目多涉及到信用评分，因此需要模型特征具有较好的可解释性，所以目前在实际项目中多还是以逻辑回归作为基础模型。但是在比赛中以得分高低为准，不需要严谨的可解释性，所以大多基于集成算法进行建模。

Tips2：因为逻辑回归的算法特性，需要提前对异常值、缺失值数据进行处理【参考task3部分】

Tips3：基于树模型的算法特性，异常值、缺失值处理可以跳过，但是对于业务较为了解的同学也可以自己对缺失异常值进行处理，效果可能会更优于模型处理的结果。

注：以下建模的源数据参考baseline进行了相应的特征工程，对于异常缺失值未进行相应的处理操作。

建模之前的预操作

from sklearn.model_selection import KFold
from sklearn.model_selection import train_test_split
import lightgbm as lgb
# 分离数据集
features = [f for f in data.columns if f not in ['id','issueDate','isDefault']]

train = data[data.isDefault.notnull()].reset_index(drop=True)
test = data[data.isDefault.isnull()].reset_index(drop=True)

X_train = train[features]
X_test = test[features]

y_train = train['isDefault']

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

"""对训练集数据进行划分，分成训练集和验证集，并进行相应的操作"""


# 数据集划分
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,
            'silent': True,
            'verbose': -1,
}
"""使用训练集数据进行模型训练"""
model = lgb.train(params,train_set=train_matrix, valid_sets=valid_matrix,num_boost_round=20000,callbacks=[lgb.early_stopping(stopping_rounds=200),lgb.log_evaluation(1000)])

out

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

对验证集进行预测

from sklearn import metrics
from sklearn.metrics import roc_auc_score

"""预测并计算roc的相关指标"""
val_pre_lgb = model.predict(X_val, num_iteration=model.best_iteration)
fpr, tpr, threshold = metrics.roc_curve(y_val, val_pre_lgb)
roc_auc = metrics.auc(fpr, tpr)
print('未调参前lightgbm单模型在验证集上的AUC：{}'.format(roc_auc))
"""画出roc曲线图"""
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.7269890160490498

image-20250305234739384

更进一步的，使用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': 2025,
                'nthread': 8,
                'silent': True,
                'verbose': -1,
    }

    model = lgb.train(params, train_set=train_matrix, num_boost_round=20000, valid_sets=valid_matrix, callbacks=[lgb.early_stopping(stopping_rounds=200),lgb.log_evaluation(1000)])
    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)))
************************************ 1 ************************************
Training until validation scores don't improve for 200 rounds
Early stopping, best iteration is:
[460]	valid_0's auc: 0.729694
[0.7296937413945397]
************************************ 2 ************************************
Training until validation scores don't improve for 200 rounds
Early stopping, best iteration is:
[635]	valid_0's auc: 0.72572
[0.7296937413945397, 0.7257197647196477]
************************************ 3 ************************************
Training until validation scores don't improve for 200 rounds
Early stopping, best iteration is:
[469]	valid_0's auc: 0.730235
[0.7296937413945397, 0.7257197647196477, 0.7302346168205991]
************************************ 4 ************************************
Training until validation scores don't improve for 200 rounds
Early stopping, best iteration is:
[622]	valid_0's auc: 0.728993
[0.7296937413945397, 0.7257197647196477, 0.7302346168205991, 0.7289925687952793]
************************************ 5 ************************************
Training until validation scores don't improve for 200 rounds
Early stopping, best iteration is:
[746]	valid_0's auc: 0.728447
[0.7296937413945397, 0.7257197647196477, 0.7302346168205991, 0.7289925687952793, 0.7284465494481975]
lgb_scotrainre_list:[0.7296937413945397, 0.7257197647196477, 0.7302346168205991, 0.7289925687952793, 0.7284465494481975]
lgb_score_mean:0.7286174482356527
lgb_score_std:0.001570995403223042

3 模型调参

贪心调参

先使用当前对模型影响最大的参数进行调优，达到当前参数下的模型最优化，再使用对模型影响次之的参数进行调优，如此下去，直到所有的参数调整完毕。
这个方法的缺点就是可能会调到局部最优而不是全局最优，但是只需要一步一步的进行参数最优化调试即可，容易理解。
需要注意的是在树模型中参数调整的顺序，也就是各个参数对模型的影响程度，这里列举一下日常调参过程中常用的参数和调参顺序：

  • ①：max_depth、num_leaves
  • ②：min_data_in_leaf、min_child_weight
  • ③：bagging_fraction、 feature_fraction、bagging_freq
  • ④：reg_lambda、reg_alpha
  • ⑤：min_split_gain
import numpy as np
from sklearn.model_selection import cross_val_score
from lightgbm import LGBMClassifier  # 使用LGBMClassifier而不是LGBMRegressor，因为我们要计算ROC AUC

# 假设X_train, y_train已经加载并预处理好了
# X_train, y_train = ...

# 定义要测试的目标函数（objective）
objectives = ['binary', 'cross_entropy']

# 定义要测试的num_leaves值
num_leaves_values = [10, 20, 30, 40]

# 定义要测试的max_depth值
max_depth_values = [3, 5, 7, 9]

# 调整目标函数
best_obj = dict()
for obj in objectives:
    model = LGBMClassifier(objective=obj)
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    best_obj[obj] = score
    print(f"Objective: {obj}, ROC AUC Score: {score}")

# 获取最佳目标函数
best_objective = max(best_obj.items(), key=lambda x: x[1])[0]
print(f"Best Objective: {best_objective} with ROC AUC Score: {best_obj[best_objective]}")

# 调整num_leaves
best_leaves = dict()
for leaves in num_leaves_values:
    model = LGBMClassifier(objective=best_objective, num_leaves=leaves)
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    best_leaves[leaves] = score
    print(f"Num Leaves: {leaves}, ROC AUC Score: {score}")

# 获取最佳num_leaves
best_num_leaves = max(best_leaves.items(), key=lambda x: x[1])[0]
print(f"Best Num Leaves: {best_num_leaves} with ROC AUC Score: {best_leaves[best_num_leaves]}")

# 调整max_depth
best_depth = dict()
for depth in max_depth_values:
    model = LGBMClassifier(objective=best_objective, num_leaves=best_num_leaves, max_depth=depth)
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    best_depth[depth] = score
    print(f"Max Depth: {depth}, ROC AUC Score: {score}")

# 获取最佳max_depth
best_max_depth = max(best_depth.items(), key=lambda x: x[1])[0]
print(f"Best Max Depth: {best_max_depth} with ROC AUC Score: {best_depth[best_max_depth]}")

"""
可视化部分可以使用matplotlib来绘制每个参数的最佳得分情况
"""
import matplotlib.pyplot as plt

# 绘制不同目标函数的ROC AUC分数
plt.figure(figsize=(10, 6))
plt.bar(best_obj.keys(), best_obj.values(), color='skyblue')
plt.title('Objective Function vs ROC AUC Score')
plt.xlabel('Objective Function')
plt.ylabel('ROC AUC Score')
plt.show()

# 绘制不同num_leaves的ROC AUC分数
plt.figure(figsize=(10, 6))
plt.plot(list(best_leaves.keys()), list(best_leaves.values()), marker='o', linestyle='-', color='green')
plt.title('Num Leaves vs ROC AUC Score')
plt.xlabel('Num Leaves')
plt.ylabel('ROC AUC Score')
plt.show()

# 绘制不同max_depth的ROC AUC分数
plt.figure(figsize=(10, 6))
plt.plot(list(best_depth.keys()), list(best_depth.values()), marker='o', linestyle='-', color='red')
plt.title('Max Depth vs ROC AUC Score')
plt.xlabel('Max Depth')
plt.ylabel('ROC AUC Score')
plt.show()

image-20250306003737380

image-20250306003749272

网格搜索

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

同样以Lightgbm算法为例，进行网格搜索调参：

from sklearn.model_selection import StratifiedKFold

"""通过网格搜索确定最优参数"""
from sklearn.model_selection import GridSearchCV

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):
    # 设置5折交叉验证
    cv_fold = StratifiedKFold(n_splits=5, random_state=0, shuffle=True, )

    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_))
"""以下代码未运行，耗时较长，请谨慎运行，且每一步的最优参数需要在下一步进行手动更新，请注意"""

"""
需要注意一下的是，除了获取上面的获取num_boost_round时候用的是原生的lightgbm（因为要用自带的cv）
下面配合GridSearchCV时必须使用sklearn接口的lightgbm。
"""
"""设置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为 ，下面进行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
"""
# 设置5折交叉验证
# 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'])))

在实际调整过程中，可先设置一个较大的学习率（上面的例子中0.1），通过Lgb原生的cv函数进行树个数的确定，之后再通过上面的实例代码进行参数的调整优化。

最后针对最优的参数设置一个较小的学习率（例如0.05），同样通过cv函数确定树的个数，确定最终的参数。

需要注意的是，针对大数据集，上面每一层参数的调整都需要耗费较长时间

贝叶斯调参（重点）

在使用之前需要先安装包bayesian-optimization，运行如下命令即可：

pip install bayesian-optimization

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

贝叶斯调参的步骤如下：

  • 定义优化函数(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), # 这是树的最大叶子节点数。LightGBM使用的是基于叶子生长的算法，这意味着它直接控制着每棵树的复杂度。较高的值可能导致过拟合。
        'max_depth':(3, 20), # 树的最大深度。这个参数用于限制树的生长深度，从而控制模型的复杂度和防止过拟合。注意，num_leaves 和 max_depth 都是用来控制树的大小，但它们之间没有直接的关系（例如，一个深度为5的树可以有少于或超过31个叶子节点）
        'bagging_fraction':(0.5, 1.0), # 每次迭代时用来训练树的数据比例。通过随机选择部分数据来构建树，这种方法可以减少方差，提高模型的稳定性。
        'feature_fraction':(0.5, 1.0), # 每次迭代时用来训练树的特征比例。类似于bagging_fraction，但它作用于特征而不是样本。这有助于增加模型的多样性，并可能改善模型性能。
        'bagging_freq':(0, 100), #bagging的频率，即每多少次迭代执行一次bagging。如果设置为0，则不使用bagging。
        'min_data_in_leaf':(10,100), # 一个叶子上最少需要包含的样本数量。适当增大这个值可以帮助防止过拟合，尤其是在处理大量分类问题时。
        'min_child_weight':(0, 10), # 叶子节点上的最小hessian和，或者说是样本权重总和的最小值。与min_data_in_leaf类似，但考虑了样本权重。该参数对于控制过拟合也很重要
        'min_split_gain':(0.0, 1.0), # 节点分裂所需的最小增益。值越大，分裂越严格，可能会导致生成更少的分裂，从而简化模型。
        'reg_alpha':(0.0, 10), # L1正则化系数。L1正则化能够促使一些不重要的特征对应的权重变为零，因此有利于特征选择。
        'reg_lambda':(0.0, 10), # L2正则化系数。L2正则化通过惩罚较大的权重值来防止过拟合，促进模型泛化能力。
    }
)

"""开始优化"""
bayes_lgb.maximize(n_iter=10)
|   iter    |  target   | baggin... | baggin... | featur... | max_depth | min_ch... | min_da... | min_sp... | num_le... | reg_alpha | reg_la... |
-------------------------------------------------------------------------------------------------------------------------------------------------
| 1         | 0.7271    | 0.9931    | 11.53     | 0.521     | 10.99     | 7.394     | 63.61     | 0.4806    | 77.44     | 5.035     | 0.05619   |
| 2         | 0.7209    | 0.9812    | 50.53     | 0.9439    | 16.37     | 8.388     | 31.72     | 0.5239    | 56.71     | 0.4872    | 0.05511   |
| 3         | 0.7103    | 0.7282    | 56.53     | 0.5157    | 6.974     | 6.398     | 17.57     | 0.1437    | 193.0     | 5.971     | 2.299     |
| 4         | 0.7207    | 0.6776    | 81.37     | 0.7428    | 16.25     | 4.916     | 84.58     | 0.5109    | 33.45     | 3.469     | 5.095     |
| 5         | 0.7258    | 0.763     | 82.57     | 0.9972    | 13.72     | 7.786     | 15.33     | 0.6128    | 101.0     | 4.161     | 5.15      |
| 6         | 0.7265    | 0.9556    | 81.36     | 0.6473    | 13.15     | 5.886     | 17.21     | 0.4262    | 100.2     | 5.213     | 5.8       |
| 7         | 0.7077    | 0.7317    | 53.51     | 0.9043    | 19.48     | 1.668     | 56.33     | 0.1234    | 109.7     | 9.833     | 5.946     |
| 8         | 0.7084    | 0.7631    | 2.874     | 0.5811    | 11.16     | 4.936     | 57.08     | 0.3166    | 54.07     | 4.149     | 0.8002    |
| 9         | 0.7204    | 0.8934    | 9.184     | 0.5191    | 11.4      | 8.275     | 66.96     | 0.3591    | 89.28     | 6.256     | 9.558     |
| 10        | 0.6995    | 0.6747    | 21.95     | 0.7082    | 13.39     | 9.605     | 56.06     | 0.1606    | 82.57     | 1.762     | 0.01093   |
| 11        | 0.7017    | 0.9008    | 4.37      | 0.8852    | 8.091     | 7.599     | 68.99     | 0.1467    | 77.55     | 1.088     | 2.486     |
| 12        | 0.7238    | 0.5586    | 83.59     | 0.7312    | 13.31     | 1.363     | 13.65     | 0.8541    | 101.3     | 1.519     | 7.183     |
| 13        | 0.7275    | 0.8928    | 86.33     | 0.7456    | 13.16     | 4.83      | 14.43     | 0.6161    | 105.6     | 6.13      | 6.228     |
| 14        | 0.7275    | 0.7006    | 82.96     | 0.5886    | 7.2       | 6.598     | 14.67     | 0.4994    | 104.3     | 9.312     | 4.845     |
| 15        | 0.7218    | 0.5751    | 85.7      | 0.5523    | 10.78     | 3.893     | 22.01     | 0.3167    | 106.0     | 6.596     | 3.21      |
=================================================================================================================================================
"""显示优化结果"""
bayes_lgb.max
{'target': 0.7275442168806482,
 'params': {'bagging_fraction': 0.7006006252457107,
  'bagging_freq': 82.96446800456837,
  'feature_fraction': 0.5885852105566081,
  'max_depth': 7.199867173297536,
  'min_child_weight': 6.598336034908653,
  'min_data_in_leaf': 14.67034546089463,
  'min_split_gain': 0.49937757419359885,
  'num_leaves': 104.26693332469026,
  'reg_alpha': 9.31177341113749,
  'reg_lambda': 4.845204385655803}}
"""调整一个较小的学习率，并通过cv函数确定当前最优的迭代次数"""
base_params_lgb={
    'boosting_type': 'gbdt',
    'objective': 'binary',
    'metric': 'auc',
    'learning_rate': 0.01,
    'num_leaves': 37,
    'max_depth': 7,
    'min_data_in_leaf': 83,
    'min_child_weight':6.6,
    'bagging_fraction': 0.7,
    'feature_fraction': 0.58,
    'bagging_freq': 83,
    'reg_lambda': 4,
    'reg_alpha': 9,
    'min_split_gain': 0.5,
    'nthread': 8,
    'seed': 2025,
    'silent': True,
    'verbose': -1,
}

cv_result_lgb = lgb.cv(
    params=base_params_lgb,
    train_set=train_matrix,
    callbacks=[lgb.early_stopping(1000)],
    num_boost_round=20000,
    nfold=5,
    stratified=True,
    shuffle=True,
    metrics='auc',
    seed=0
)

print('迭代次数{}'.format(len(cv_result_lgb['auc-mean'])))
print('最终模型的AUC为{}'.format(max(cv_result_lgb['auc-mean'])))

迭代次数5971
最终模型的AUC为0.7311606929249331

模型参数已经确定，建立最终模型并对验证集进行验证

"""使用lightgbm 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',
                'metric': 'auc',
                'learning_rate': 0.01,
                'num_leaves': 37,
                'max_depth': 7,
                'min_data_in_leaf': 83,
                'min_child_weight':6.6,
                'bagging_fraction': 0.7,
                'feature_fraction': 0.58,
                'bagging_freq': 83,
                'reg_lambda': 4,
                'reg_alpha': 9,
                'min_split_gain': 0.5,
                'nthread': 8,
                'seed': 2025,
                'silent': True,
                'verbose': -1,
    }

    model = lgb.train(params, train_set=train_matrix, num_boost_round=5971, valid_sets=valid_matrix,callbacks=[lgb.log_evaluation(1000),lgb.early_stopping(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_scotrainre_list:[0.7327504680236936, 0.729543133208145, 0.733500226142979, 0.7326268181775848, 0.731541105300757]
lgb_score_mean:0.7319923501706319
lgb_score_std:0.001375010395661169

最终训练

base_params_lgb = {
                'boosting_type': 'gbdt',
                'objective': 'binary',
                'metric': 'auc',
                'learning_rate': 0.01,
                'num_leaves': 37,
                'max_depth': 7,
                'min_data_in_leaf': 83,
                'min_child_weight':6.6,
                'bagging_fraction': 0.7,
                'feature_fraction': 0.58,
                'bagging_freq': 83,
                'reg_lambda': 4,
                'reg_alpha': 9,
                'min_split_gain': 0.5,
                'nthread': 8,
                'seed': 2025,
                'silent': True,
                'verbose': -1,
    }

"""使用训练集数据进行模型训练"""
final_model_lgb = lgb.train(base_params_lgb, train_set=train_matrix, valid_sets=valid_matrix, num_boost_round=5971, callbacks=[lgb.log_evaluation(1000),lgb.early_stopping(200)])

"""预测并计算roc的相关指标"""
val_pre_lgb = final_model_lgb.predict(X_val)
fpr, tpr, threshold = metrics.roc_curve(y_val, val_pre_lgb)
roc_auc = metrics.auc(fpr, tpr)
print('调参后lightgbm单模型在验证集上的AUC：{}'.format(roc_auc))
"""画出roc曲线图"""
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()

Training until validation scores don’t improve for 200 rounds
[1000] valid_0’s auc: 0.725299
[2000] valid_0’s auc: 0.728653
[3000] valid_0’s auc: 0.730034
[4000] valid_0’s auc: 0.730817
[5000] valid_0’s auc: 0.731383
Early stopping, best iteration is:
[5724] valid_0’s auc: 0.731541
调参后lightgbm单模型在验证集上的AUC：0.731541105300757

image-20250306125256227

可以看到相比最早的原始参数，模型的性能还是有提升的

保存模型

"""保存模型到本地"""
# 保存模型
import pickle
pickle.dump(final_model_lgb, open('model/model_lgb_best-2025-0306.pkl', 'wb'))
Author: qwq小小舒
Link: https://js6288.github.io/2025/03/06/%E9%87%91%E8%9E%8D%E9%A3%8E%E9%99%A9%E9%A2%84%E6%B5%8B%E8%B5%9B-task4-%E5%BB%BA%E6%A8%A1%E4%B8%8E%E8%B0%83%E5%8F%82/
Reprint policy: All articles in this blog are used except for special statements CC BY 4.0 reprint policy. If reproduced, please indicate source qwq小小舒 !
deep learning 人工智能 python machine learning 决策树 pandas numpy LightGBM 调参 贝叶斯优化
赏
  TOC