当前位置：首页 > news >正文

【竞赛系列】机器学习实操项目05——客户信用评估模型进阶流程（含XGBoost、LightGBM、CatBoost 高级模型对比与参数优化）

news 2025/9/11 7:25:51

上一章：【竞赛系列】机器学习实操项目04——客户信用评估模型开发全流程（baseline）
下一章：
机器学习核心知识点目录：机器学习核心知识点目录
机器学习实战项目目录：【从 0 到 1 落地】机器学习实操项目目录：覆盖入门到进阶，大学生就业 / 竞赛必备

文章目录

- 任务总览
- 1. 导入核心工具库
- 2. 数据加载与初步预处理
- 3. 划分训练集与验证集
- 4. 特征预处理（标准化+独热编码）
- 5. 检查特征矩阵形状
- 6. 导入集成学习模型库
- 7. 三大集成模型训练与基础性能对比
- 8. 模型性能可视化对比
- 9. 贝叶斯优化超参数（以LightGBM为例）
- 10. 提取最佳超参数并训练最终模型
- 11. 模型融合策略1：加权平均融合
- 12. 模型融合策略2：Stacking融合
- 13. 最终模型选择与测试集预测
- 14. 总结与后续优化方向

任务总览

本项目旨在开发一个客户信用评估模型，通过分析客户的基本信息、账户特征等数据，预测客户是否为"好客户"（Target=1）或"坏客户"（Target=0）。这一模型可帮助金融机构在信贷审批过程中做出更合理的决策，平衡风险控制与业务发展。

本流程围绕客户信用风险分类任务（预测客户是否为“好客户”），依次完成数据加载预处理、基础模型对比、超参数优化、模型融合四大核心步骤，最终实现高精度分类预测。

通过网盘分享的文件：用户信用评分数据集
链接: https://pan.baidu.com/s/1F2R0rOLuw4_ntaKMPL8otg?pwd=1x27 提取码: 1x27

1. 导入核心工具库

该步骤加载数据处理、机器学习、模型评估所需的所有基础库，为后续流程提供工具支持。

# 导入必要的数据处理和机器学习库
import pandas as pd  # 用于数据处理和分析（如读取CSV、缺失值填充）
import numpy as np   # 用于数值计算（如矩阵操作、数组处理）
import matplotlib.pyplot as plt  # 用于数据可视化（如模型性能对比图）
from sklearn.model_selection import train_test_split  # 用于划分训练集和验证集
from sklearn.preprocessing import StandardScaler, OneHotEncoder  # 用于特征预处理（数值标准化、分类编码）
from sklearn.metrics import roc_auc_score, confusion_matrix, classification_report  # 用于模型评估（AUC、混淆矩阵等）

2. 数据加载与初步预处理

该步骤完成原始数据读取、缺失值处理，并分离特征与目标变量，为后续建模准备干净的输入数据。

# 2.1 数据加载与预处理
# 读取训练数据和测试数据（假设数据文件为train.csv和test.csv，包含客户特征与信用标签）
train = pd.read_csv('train.csv')  # 加载训练数据集（含目标变量）
test = pd.read_csv('test.csv')    # 加载测试数据集（不含目标变量，用于最终预测）# 处理缺失值 - 针对分类特征Credit_Product（客户是否有信贷产品）的缺失值，填充为'Unknown'（避免丢失样本）
train['Credit_Product'] = train['Credit_Product'].fillna('Unknown')
test['Credit_Product'] = test['Credit_Product'].fillna('Unknown')# 分离特征和目标变量（Target为目标变量，1表示“好客户”，0表示“坏客户”）
# 训练数据中删除ID列（无预测意义）和Target列（目标变量），得到特征矩阵X
X = train.drop(['ID', 'Target'], axis=1)
# 提取目标变量（客户信用标签），得到标签向量y
y = train['Target']

3. 划分训练集与验证集

该步骤将训练数据拆分为“训练集”（用于模型训练）和“验证集”（用于模型性能评估），采用分层抽样确保目标变量分布一致，避免数据偏差。

# 3.1 划分训练集和验证集
# 将数据分为训练集和验证集，验证集占20%（常见比例，平衡训练量与评估可靠性）
# 使用分层抽样（stratify=y）确保训练集和验证集的目标变量分布一致，避免类别不平衡导致的评估偏差
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2,   # 验证集比例20%stratify=y,      # 按目标变量分层抽样random_state=42  # 设置随机种子（42为常用值），确保结果可复现
)

4. 特征预处理（标准化+独热编码）

该步骤针对不同类型特征（数值型、分类型）进行针对性预处理，消除量纲影响并将分类特征转换为模型可识别的数值格式，是建模前的关键步骤。

# 4.1 特征预处理
# 定义分类特征和数值特征（根据业务逻辑和数据类型划分）
# 分类特征：取值为离散类别的特征（如性别、职业、地区编码）
cat_cols = ['Gender', 'Region_Code', 'Occupation', 'Channel_Code', 'Credit_Product', 'Is_Active']
# 数值特征：取值为连续数值的特征（如年龄、账户余额、客户在网时长）
num_cols = ['Age', 'Vintage', 'Avg_Account_Balance']# 对分类变量进行独热编码（One-Hot Encoding）：将离散类别转换为二进制向量，避免类别间的“大小关系”误导模型
# 创建独热编码器，handle_unknown='ignore'表示遇到测试集中的未知类别时，编码为全0向量
encoder = OneHotEncoder(handle_unknown='ignore')
# 在训练集上拟合并转换分类特征（先拟合训练集数据分布，再转换，避免数据泄露）
X_train_encoded = encoder.fit_transform(X_train[cat_cols])
# 在验证集上转换分类特征（仅使用训练集拟合的编码器，确保预处理逻辑一致）
X_val_encoded = encoder.transform(X_val[cat_cols])
# 在测试集上转换分类特征（同样使用训练集编码器，避免数据泄露）
X_test_encoded = encoder.transform(test[cat_cols])# 数值特征标准化（Z-score标准化）：将数值特征转换为均值为0、标准差为1的分布，消除量纲影响（如年龄“岁”与余额“元”）
# 创建标准化器
scaler = StandardScaler()
# 在训练集上拟合并转换数值特征
X_train_num = scaler.fit_transform(X_train[num_cols])
# 在验证集上转换数值特征
X_val_num = scaler.transform(X_val[num_cols])
# 在测试集上转换数值特征
X_test_num = scaler.transform(test[num_cols])# 合并处理后的特征（水平堆叠数值特征和编码后的分类特征，形成最终输入矩阵）
X_train_final = np.hstack([X_train_num, X_train_encoded.toarray()])  # 训练集最终特征矩阵
X_val_final = np.hstack([X_val_num, X_val_encoded.toarray()])        # 验证集最终特征矩阵
X_test_final = np.hstack([X_test_num, X_test_encoded.toarray()])     # 测试集最终特征矩阵

5. 检查特征矩阵形状

该步骤验证预处理后的数据维度是否符合预期，确保训练集、验证集、测试集的特征数量一致，避免后续建模报错。

# 5.1 打印形状检查（验证特征矩阵维度是否正确）
print(f"训练集形状: {X_train_final.shape}")  # 输出格式：(样本数, 特征数)，如(156580, 53)表示156580个样本，53个特征
print(f"验证集形状: {X_val_final.shape}")    # 验证集样本数应为训练集的20%左右，特征数与训练集一致
print(f"测试集形状: {X_test_final.shape}")    # 测试集特征数需与训练集一致，样本数为原始测试集数量

输出结果：

训练集形状: (156580, 53)
验证集形状: (39145, 53)
测试集形状: (50000, 53)

6. 导入集成学习模型库

该步骤加载XGBoost、LightGBM、CatBoost三大主流集成学习模型库，以及模型训练时间统计、性能评估所需工具，为后续模型对比做准备。

import time  # 用于统计模型训练时间
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score  # 核心评估指标：AUC（适用于二分类任务，越高模型性能越好）
import xgboost as xgb  # XGBoost：梯度提升树模型，性能强、泛化能力好
import lightgbm as lgb  # LightGBM：基于直方图的梯度提升树，训练速度快、内存占用低
import catboost as cb   # CatBoost：自动处理分类特征的梯度提升树，减少预处理工作量

7. 三大集成模型训练与基础性能对比

该步骤初始化XGBoost、LightGBM、CatBoost模型（使用默认参数+基础调参），训练后通过AUC指标和训练时间对比模型性能，筛选初始最优模型。

# 7.1 三大模型对比（初始化模型并设置基础参数，确保公平对比）
models = {"XGBoost": xgb.XGBClassifier(n_estimators=500,  # 树的数量：500棵树（平衡训练效果与时间）max_depth=6,       # 树的最大深度：6（避免过拟合）learning_rate=0.05,# 学习率：0.05（控制每棵树的贡献权重）subsample=0.8,     # 样本抽样比例：0.8（随机抽样80%样本训练单棵树，增强泛化）colsample_bytree=0.8,  # 特征抽样比例：0.8（随机抽样80%特征训练单棵树，避免过拟合）random_state=42,   # 随机种子：确保结果可复现n_jobs=-1          # 并行计算：使用所有CPU核心，加速训练),"LightGBM": lgb.LGBMClassifier(n_estimators=500,max_depth=6,learning_rate=0.05,subsample=0.8,colsample_bytree=0.8,random_state=42,n_jobs=-1),"CatBoost": cb.CatBoostClassifier(iterations=500,    # 迭代次数（对应XGBoost的n_estimators）depth=6,           # 树的深度（对应XGBoost的max_depth）learning_rate=0.05,random_seed=42,    # 随机种子verbose=0,         # 训练过程不打印日志（减少输出干扰）thread_count=-1    # 并行线程数：使用所有CPU核心)
}# 7.2 模型性能记录（存储模型名称、AUC、训练时间、参数，用于后续对比）
results = {"Model": [],"AUC": [],"Time (s)": [],"Parameters": []
}# 7.3 训练并评估每个模型（循环训练三大模型，计算AUC和训练时间）
for name, model in models.items():print(f"\nTraining {name}...")  # 打印当前训练的模型名称start_time = time.time()  # 记录训练开始时间# 训练模型（使用训练集最终特征矩阵和标签）model.fit(X_train_final, y_train)# 预测并计算AUC（验证集预测：输出“为好客户”的概率，取概率列[:,1]计算AUC）y_pred = model.predict_proba(X_val_final)[:, 1]auc = roc_auc_score(y_val, y_pred)# 记录训练时间（当前时间 - 开始时间）train_time = time.time() - start_time# 存储结果到results字典results["Model"].append(name)results["AUC"].append(auc)results["Time (s)"].append(train_time)results["Parameters"].append(str(model.get_params()))  # 存储模型参数（字符串格式）# 打印当前模型的性能结果print(f"{name} - AUC: {auc:.4f}, Time: {train_time:.2f}s")

输出结果：

Training XGBoost...
XGBoost - AUC: 0.8673, Time: 9.93sTraining LightGBM...LightGBM - AUC: 0.8671, Time: 4.71sTraining CatBoost...
CatBoost - AUC: 0.8679, Time: 11.33s

8. 模型性能可视化对比

该步骤将三大模型的AUC和训练时间整理为DataFrame，并通过柱状图可视化对比，直观展示模型性能差异（AUC越高越好，时间越短越好）。

# 8.1 创建结果DataFrame（将字典转换为表格，便于查看和后续分析）
results_df = pd.DataFrame(results)
print("\n模型性能对比:")
print(results_df)  # 打印表格形式的性能结果# 8.2 可视化对比（创建1行2列的子图，分别展示AUC和训练时间）
plt.figure(figsize=(12, 6))  # 设置图的大小（宽度12，高度6）# 子图1：AUC对比（柱状图，AUC越高表示模型分类能力越强）
plt.subplot(1, 2, 1)  # 1行2列，第1个子图
plt.bar(results_df['Model'], results_df['AUC'], color=['#1f77b4', '#ff7f0e', '#2ca02c'])  # 三种颜色区分模型
plt.title('模型AUC对比')  # 子图标题
plt.ylabel('AUC')  # y轴标签（AUC值，范围0.5-1.0）
plt.ylim(0.8, 0.9)  # 限定y轴范围（聚焦AUC差异，避免视觉不明显）# 子图2：训练时间对比（柱状图，时间越短表示训练效率越高）
plt.subplot(1, 2, 2)  # 1行2列，第2个子图
plt.bar(results_df['Model'], results_df['Time (s)'], color=['#1f77b4', '#ff7f0e', '#2ca02c'])
plt.title('训练时间对比')  # 子图标题
plt.ylabel('时间 (秒)')  # y轴标签（训练时间）plt.tight_layout()  # 自动调整子图间距，避免标签重叠
plt.show()  # 显示图片

输出结果：

模型性能对比:Model       AUC   Time (s)  \
0   XGBoost  0.867335   9.933995   
1  LightGBM  0.867121   4.710284   
2  CatBoost  0.867898  11.330254   Parameters  
0  {'objective': 'binary:logistic', 'base_score':...  
1  {'boosting_type': 'gbdt', 'class_weight': None...  
2  {'iterations': 500, 'learning_rate': 0.05, 'de...

在这里插入图片描述

9. 贝叶斯优化超参数（以LightGBM为例）

该步骤针对基础性能较好的LightGBM模型，使用贝叶斯优化算法搜索最优超参数（相比网格搜索更高效），通过5折交叉验证确保参数稳定性，进一步提升模型性能。

from bayes_opt import BayesianOptimization  # 贝叶斯优化库（需提前安装：pip install bayesian-optimization）
from sklearn.model_selection import cross_val_score  # 交叉验证工具（用于评估参数组合的稳定性）# 9.1 定义贝叶斯优化的目标函数（输入超参数，输出5折交叉验证的平均AUC，目标是最大化AUC）
def lgb_cv(n_estimators, learning_rate, max_depth, num_leaves, subsample, colsample_bytree, min_child_samples):"""LightGBM交叉验证目标函数：输入超参数，返回5折AUC均值"""# 将浮点数参数转换为整数（部分超参数需为整数，如树的数量、深度）max_depth = int(max_depth)num_leaves = int(num_leaves)min_child_samples = int(min_child_samples)n_estimators = int(n_estimators)# 创建LightGBM模型（使用当前超参数组合）model = lgb.LGBMClassifier(n_estimators=n_estimators,learning_rate=learning_rate,max_depth=max_depth,num_leaves=num_leaves,subsample=subsample,colsample_bytree=colsample_bytree,min_child_samples=min_child_samples,random_state=42,n_jobs=12  # 并行核心数（根据CPU配置调整，避免内存不足）)# 5折交叉验证（cv=5）：在训练集上划分5份，每次用4份训练、1份验证，计算AUC并取均值auc_scores = cross_val_score(model, X_train_final, y_train, cv=5, scoring='roc_auc', n_jobs=12  # 评估指标为AUC，并行计算)# 返回平均AUC（贝叶斯优化会最大化该值）return auc_scores.mean()# 9.2 定义参数搜索空间（根据LightGBM参数特性设置合理范围，避免无效值）
pbounds = {'n_estimators': (100, 1000),    # 树的数量：100-1000'learning_rate': (0.01, 0.2),   # 学习率：0.01-0.2（过小训练慢，过大易过拟合）'max_depth': (3, 10),           # 树的深度：3-10（过深易过拟合）'num_leaves': (15, 150),        # 叶子节点数：15-150（需满足num_leaves < 2^max_depth）'subsample': (0.6, 1.0),        # 样本抽样比例：0.6-1.0'colsample_bytree': (0.6, 1.0), # 特征抽样比例：0.6-1.0'min_child_samples': (5, 100)   # 叶子节点最小样本数：5-100（过小易过拟合）
}# 9.3 创建贝叶斯优化器（绑定目标函数和参数空间）
optimizer = BayesianOptimization(f=lgb_cv,               # 目标函数（最大化AUC）pbounds=pbounds,        # 参数搜索空间random_state=42,        # 随机种子（确保搜索过程可复现）
)# 9.4 执行优化（先随机搜索初始化，再迭代优化）
optimizer.maximize(init_points=10,  # 初始随机搜索点数量：10个（探索参数空间）n_iter=20,       # 贝叶斯优化迭代次数：20次（基于历史结果优化参数）
)

输出结果：

在这里插入图片描述

10. 提取最佳超参数并训练最终模型

该步骤从贝叶斯优化结果中提取最优超参数，转换为模型所需的整数类型后，训练最终的LightGBM模型，并在验证集上评估优化后的性能，验证参数调优效果。

# 10.1 输出最佳参数（从贝叶斯优化结果中提取AUC最高的参数组合）
best_params = optimizer.max['params']
print("\n最佳参数:")
for key, value in best_params.items():print(f"{key}: {value:.4f}")  # 保留4位小数打印参数值# 10.2 整数参数转换（部分超参数需为整数，如树数量、树深度，避免模型报错）
best_params['n_estimators'] = int(best_params['n_estimators'])  # 树的数量（整数）
best_params['max_depth'] = int(best_params['max_depth'])        # 树的深度（整数）
best_params['num_leaves'] = int(best_params['num_leaves'])      # 叶子节点数（整数）
best_params['min_child_samples'] = int(best_params['min_child_samples'])  # 叶子最小样本数（整数）# 10.3 使用最佳参数训练最终LightGBM模型（基于优化后的参数，提升模型性能）
best_lgb = lgb.LGBMClassifier(**best_params,  # 传入最佳超参数（解包字典）random_state=42,  # 固定随机种子，确保结果可复现verbose=-1,       # 关闭训练日志打印（减少输出干扰）n_jobs=-1         # 并行计算，使用所有CPU核心加速训练
)
best_lgb.fit(X_train_final, y_train)  # 用训练集完整数据训练最终模型# 10.4 验证集评估（评估优化后模型的性能，对比基础模型是否提升）
y_pred = best_lgb.predict_proba(X_val_final)[:, 1]  # 预测验证集“为好客户”的概率
auc = roc_auc_score(y_val, y_pred)  # 计算AUC值
print(f"\n优化后模型AUC: {auc:.4f}")  # 打印优化后的AUC，通常应高于基础模型

输出结果：

最佳参数:
n_estimators: 263.6425
learning_rate: 0.0448
max_depth: 5.1297
num_leaves: 85.8421
subsample: 0.7728
colsample_bytree: 0.7165
min_child_samples: 63.1260优化后模型AUC: 0.8681

11. 模型融合策略1：加权平均融合

该步骤训练XGBoost、LightGBM、CatBoost三大基础模型，根据各模型的性能（或经验）设置不同权重，通过加权平均组合各模型的预测概率，利用模型多样性提升最终预测稳定性（避免单一模型的偏差）。

# 11.1 训练多个基础模型（重新训练三大模型，确保均基于完整训练集，用于融合）
models = {"XGBoost": xgb.XGBClassifier(n_estimators=500, max_depth=6, learning_rate=0.05, random_state=42, n_jobs=-1),"LightGBM": lgb.LGBMClassifier(n_estimators=500, max_depth=6, learning_rate=0.05, random_state=42, verbose=-1, n_jobs=-1),"CatBoost": cb.CatBoostClassifier(iterations=500, depth=6, learning_rate=0.05, random_seed=42, verbose=0, thread_count=-1)
}# 11.2 存储各模型的验证集预测结果（key为模型名，value为预测概率）
predictions = {}
for name, model in models.items():print(f"Training {name} for ensemble...")  # 打印当前训练的模型model.fit(X_train_final, y_train)  # 训练模型# 预测验证集“为好客户”的概率（取第二列[:,1]），存入predictions字典predictions[name] = model.predict_proba(X_val_final)[:, 1]# 11.3 设置权重（根据基础模型性能调整：性能越好，权重越高；总权重和为1）
# 示例权重：XGBoost(0.4) + LightGBM(0.4) + CatBoost(0.2)（可根据实际AUC微调）
weights = {"XGBoost": 0.4,"LightGBM": 0.4,"CatBoost": 0.2
}# 11.4 计算加权平均预测概率（各模型预测值乘以对应权重后求和）
weighted_avg = np.zeros_like(predictions["XGBoost"])  # 初始化与预测值同形状的0数组
for model_name, weight in weights.items():weighted_avg += predictions[model_name] * weight  # 累加“模型预测值×权重”# 11.5 评估加权融合效果（计算融合后预测值的AUC，判断是否优于单一模型）
auc_weighted = roc_auc_score(y_val, weighted_avg)
print(f"\n加权平均融合AUC: {auc_weighted:.4f}")  # 打印融合后的AUC

输出结果：

Training XGBoost...
Training LightGBM...
Training CatBoost...加权平均融合AUC: 0.8678

12. 模型融合策略2：Stacking融合

该步骤采用“基模型+元模型”的Stacking架构：以三大集成模型为基模型，用基模型的预测结果作为新特征，训练逻辑回归作为元模型，通过两层模型的协作进一步挖掘预测信息，提升最终分类性能。

from sklearn.ensemble import StackingClassifier  # Stacking融合核心类
from sklearn.linear_model import LogisticRegression  # 元模型（逻辑回归，用于整合基模型结果）# 12.1 定义基模型列表（格式：(模型别名, 模型实例)，需指定基础模型及参数）
base_models = [('xgb', xgb.XGBClassifier(n_estimators=300, max_depth=5, learning_rate=0.05, random_state=42, n_jobs=-1)),('lgb', lgb.LGBMClassifier(n_estimators=300, max_depth=5, learning_rate=0.05, random_state=42, verbose=-1, n_jobs=-1)),('cat', cb.CatBoostClassifier(iterations=300, depth=5, learning_rate=0.05, random_seed=42, verbose=0, thread_count=-1))
]# 12.2 定义元模型（逻辑回归：简单高效，擅长整合多个基模型的预测结果，避免过拟合）
meta_model = LogisticRegression(C=0.1,  # 正则化强度（C越小，正则化越强，避免元模型过拟合）max_iter=1000,  # 最大迭代次数（确保逻辑回归收敛）random_state=42,n_jobs=-1
)# 12.3 创建Stacking分类器（配置基模型、元模型及交叉验证策略）
stacking_model = StackingClassifier(estimators=base_models,  # 基模型列表final_estimator=meta_model,  # 元模型cv=5,  # 交叉验证折数：5折（基模型训练时，用5折预测结果作为元模型的特征）n_jobs=12  # 并行计算：多核心同时训练基模型和交叉验证，加速融合过程
)# 12.4 训练Stacking模型（整体训练流程：先训练基模型，再用基模型的交叉验证预测结果训练元模型）
print("Training Stacking Model...")
start_time = time.time()  # 记录训练开始时间
stacking_model.fit(X_train_final, y_train)  # 训练完整Stacking模型
train_time = time.time() - start_time  # 计算训练总时间# 12.5 验证集评估（评估Stacking融合的性能，对比加权平均和单一模型）
y_pred_stacking = stacking_model.predict_proba(X_val_final)[:, 1]  # 预测验证集概率
auc_stacking = roc_auc_score(y_val, y_pred_stacking)  # 计算AUC# 打印Stacking融合结果
print(f"Stacking融合AUC: {auc_stacking:.4f}, Time: {train_time:.2f}s")

输出结果：

Training Stacking Model...    Stacking融合AUC: 0.8685, Time: 56.11s

13. 最终模型选择与测试集预测

该步骤对比所有模型（基础模型、优化后模型、加权融合、Stacking融合）的AUC和训练效率，选择综合性能最优的模型（通常为Stacking融合模型），对测试集进行最终预测，生成可提交的结果格式。

# 13.1 汇总所有模型性能（便于对比选择最优模型）
final_results = {"模型类型": ["XGBoost基础模型", "LightGBM基础模型", "CatBoost基础模型", "LightGBM优化后模型", "加权平均融合模型", "Stacking融合模型"],"AUC": [roc_auc_score(y_val, models["XGBoost"].predict_proba(X_val_final)[:,1]),roc_auc_score(y_val, models["LightGBM"].predict_proba(X_val_final)[:,1]),roc_auc_score(y_val, models["CatBoost"].predict_proba(X_val_final)[:,1]),auc,  # 优化后LightGBM的AUCauc_weighted,  # 加权融合的AUCauc_stacking   # Stacking融合的AUC]
}# 转换为DataFrame并按AUC降序排序
final_results_df = pd.DataFrame(final_results).sort_values("AUC", ascending=False)
print("\n所有模型性能汇总（按AUC降序）:")
print(final_results_df)# 13.2 选择最优模型（示例：选择AUC最高的Stacking融合模型）
best_model = stacking_model
print(f"\n选择的最优模型：Stacking融合模型（AUC: {auc_stacking:.4f}）")# 13.3 测试集预测（用最优模型对测试集进行预测，生成最终结果）
test_pred_proba = best_model.predict_proba(X_test_final)[:, 1]  # 预测测试集“为好客户”的概率# 13.4 生成提交文件（按常见竞赛格式：ID + 预测概率，保存为CSV）
submission = pd.DataFrame({"ID": test["ID"],  # 测试集原始ID（用于匹配结果）"Target": test_pred_proba  # 预测的“好客户”概率
})# 保存提交文件（index=False避免保存行号，便于提交）
submission.to_csv("credit_risk_submission.csv", index=False)
print("\n测试集预测结果已保存为：credit_risk_submission.csv")