保险理赔预测：堆叠学习的应用
1. 项目背景和目标
背景
在现代保险行业中，如何准确评估客户的风险并预测理赔概率，直接影响保险
公司的风险管理和定价策略。传统的保险定价模型，如基于统计学的回归分析
，通常依赖于简单的线性关系，但这些方法无法有效捕捉复杂的非线性模式和
特征交互关系，尤其是在面对 类别不平衡 的数据时尤为突出。保险理赔数
据通常具有 稀缺的少数类数据（理赔客户），而大多数客户并不会提出理赔
（非理赔客户）。这种类别不平衡问题会使得传统的分类算法在预测少数类时
表现不佳，从而影响预测准确度。
因此，在解决类别不平衡问题的同时，如何准确识别 高风险客户 成为一个
重要目标。这不仅有助于提高公司风险管理水平，还能有效优化保险定价，并
降低理赔成本。
问题的挑战
1. 类别不平衡：理赔事件通常在数据集中占据较小比例，传统的机器学习方
法往往偏向于预测非理赔客户，从而导致少数类（理赔客户）预测效果差
，模型的性能难以提升。
2. 复杂的非线性关系：保险数据的特征通常表现为复杂的非线性关系，且不
同特征之间可能存在高度的交互作用。线性模型，如逻辑回归，往往难以
捕捉这些非线性关系，造成预测效果的瓶颈。
3. 模型泛化能力：在保险理赔预测中，由于数据的多样性和复杂性，如何避
免模型在训练集上的过拟合，同时保证其在未见数据上的高准确率，仍然
是一个挑战。
目标
本项目旨在通过 堆叠模型（Stacking Model） 解决上述问题，提高理赔预
测的准确性与鲁棒性。堆叠模型作为一种集成学习方法，能够通过结合多个基
学习器的预测结果，达到提升最终预测精度的目的。具体目标包括：
1. 多基学习器集成：通过集成多个强基学习器的优势，提高模型对理赔客户
的预测能力，增强模型的稳定性与鲁棒性。
2. 处理类别不平衡问题：通过结合不同模型的优点，针对少数类（理赔客户
）的预测进行优化，从而改善类别不平衡带来的负面影响。
3. 提升模型的泛化能力：通过超参数优化，确保每个基学习器的最佳性能，
从而提升整个堆叠模型的泛化能力，避免过拟合。
本报告将详细介绍使用堆叠模型的整个过程，包括数据预处理、基学习器选择
与训练、堆叠模型的构建与评估、优化等环节。最终目标是通过该模型帮助保
险公司更准确地识别潜在的高风险客户，从而实现更加精准的定价策略和风险
管理。
主要任务
1. 数据预处理与特征工程：包括数据清洗、类别编码、特征选择及处理类别
不平衡问题。
2. 基学习器的选择与训练：采用多种分类模型（如 RandomForest、
XGBClassifier、LGBMClassifier 等），并通过交叉验证与超参数优化提
升基学习器性能。
3. 堆叠模型的构建与训练：通过堆叠不同模型的预测结果，使用元学习器进
行最终预测，进一步提升预测效果。
4. 模型评估与优化：通过 AUC（Area Under Curve） 等评价指标，全面评
估模型的表现，并根据评估结果进行优化，以确保模型具备更强的泛化能
力和准确性。
2. 数据预处理与特征工程
2.1 非数值型变量处理
在本项目中，针对数据集中的非数值型变量，我们进行了以下处理步骤，以确
保这些变量能够正确输入到机器学习模型中：
2.1.1 拆分
max_torque
和
max_power
max_torque 和 max_power 是表示汽车性能的特征，分别代表最大扭矩和最
大功率。这些特征的原始数据格式通常为字符串形式，例如 "200
Nm@3000rpm" 和 "150 bhp@6000rpm"。为了使这些特征能够用于模型训练，
我们将这些字符串拆分成两个部分：数值部分（最大扭矩和最大功率）和 转
速部分（最大扭矩转速和最大功率转速）。使用正则表达式，我们提取出数字
部分，并将其转换为浮动数值，从而将这些字符串特征转换为数值型特征。
 处理后的特征为：
 max_torque_value（最大扭矩值）
 max_torque_rpm（最大扭矩转速）
 max_power_value（最大功率值）
 max_power_rpm（最大功率转速）
这些特征转换后的数值将直接输入到模型中进行训练，避免了处理字符串时可
能带来的麻烦。
2.1.2

is_xx
特征处理
is_xx 特征是一些二元特征，用于表示某种条件是否满足。我们将这些特
征转换为 0 和 1 的二进制表示，其中 1 表示条件满足，0 表示条件不
满足。这样，模型可以更方便地理解这些特征，并将其纳入最终的预测模
型中。
2.1.3 类别型特征处理
对于类别型特征（如 transmission_type（变速箱类型）、steering_type（
转向方式）和 segment（车型细分市场）等），我们采用 独热编码（OneHot Encoding）。这种编码方式将每个类别值转化为一个新的二进制特征。例
如，transmission_type 可能有两种取值（如手动和自动），通过独热编码我
们将其转换为两个新的特征：
transmission_type_automatic 和 transmission_type_manual。每个新特征
的值为 0 或 1，表示该类别是否出现。
 使用独热编码时，我们设置了 drop_first=True，避免了生成完全相关的
虚拟变量（虚拟变量陷阱），从而提高模型的稳定性。
2.1.4 标签编码
对于一些类别特征（如 model（车型）、fuel_type（燃料类型）
和 region_code（地区代码）），我们使用 标签编码（Label Encoding）。
这种方法将每个类别值映射为一个唯一的整数，例如，将 model 特征中的不
同车型（如 "轿车" 和 "SUV"）转换为 0 和 1，使得模型能够处理这些类别特
征。
 标签编码适用于类别之间没有明显顺序关系或者顺序不重要的情况。
#数据预处理
#1.非数值型变量处理
#1.1 拆分 max_torque&max_power
df_train_copy[['max_torque_value', 'max_torque_rpm']] =
df_train_copy['max_torque'].str.extract(r'(\d+)\s*Nm@(\d+)rpm')
#
拆分 max_torque 列，提取最大扭矩和最大转速
df_train_copy['max_torque_value'] =
pd.to_numeric(df_train_copy['max_torque_value'], errors='coerce')
#
将最大扭矩值转换为数值型
df_train_copy['max_torque_rpm'] =
pd.to_numeric(df_train_copy['max_torque_rpm'], errors='coerce')
#
将最大扭矩转速转换为数值型
df_train_copy[['max_power_value', 'max_power_rpm']] =
df_train_copy['max_power'].str.extract(r'(\d+)\s*bhp@(\d+)rpm')
#
拆分 max_power 列，提取最大功率和最大功率转速
df_train_copy['max_power_value'] =
pd.to_numeric(df_train_copy['max_power_value'], errors='coerce')
#
将最大功率值转换为数值型
df_train_copy['max_power_rpm'] =
pd.to_numeric(df_train_copy['max_power_rpm'], errors='coerce')
# 将
最大功率转速转换为数值型
df_train_copy.drop(['max_torque', 'max_power'], axis=1,
inplace=True)#删除 'max_torque' 和 'max_power' 列
#1.2is_xx 处理
columns_to_convert = [
'is_esc', 'is_adjustable_steering', 'is_tpms', 'is_parking_sensors',
'is_parking_camera', 'is_front_fog_lights', 'is_rear_window_wiper',
'is_rear_window_washer', 'is_rear_window_defogger', 'is_brake_assist',
'is_power_door_locks', 'is_central_locking', 'is_power_steering',
'is_driver_seat_height_adjustable', 'is_day_night_rear_view_mirror',
'is_ecw', 'is_speed_alert'
]# 定义需要转换的列
df_train_copy[columns_to_convert] = df_train_copy[columns_to_convert].replace({'Yes': 1, 'No': 0})# 使用 replace() 方法将 'Yes' 转换为 1，'No' 转换为 0
#1.3 把'transmission_type', 'steering_type', 'segment'转换为独热编码
df_train_copy = pd.get_dummies(df_train_copy, columns=['transmission_type', 'steering_type', 'segment','rear_brakes_type'], drop_first=True)
#1.4 把'model''fuel_type''region_code'进行标签编码
label_encoder = LabelEncoder()# 创建标签编码器
df_train_copy['model'] = label_encoder.fit_transform(df_train_copy['model'])
df_train_copy['fuel_type'] = label_encoder.fit_transform(df_train_copy['fuel_type'])
df_train_copy['region_code'] = label_encoder.fit_transform(df_train_copy['region_code'])
df_train_copy['engine_type'] = label_encoder.fit_transform(df_train_copy['engine_type'])
# 2.2 处理冗余特征
#画出相关性矩阵的热图
correlation_matrix_before = df_train_copy.corr()# 计算相关性矩阵
correlation_matrix_before.to_csv("correlation_matrix(1).csv", index=True)#保存相关性举证
# 2.2 删除相关性超过 0.95 的冗余特征
threshold = 0.95
# 选择相关性超过 0.95 的列对，并删除其中一个特征
upper_triangle = correlation_matrix_before.where(np.triu(np.ones(correlation_matrix_before.shape), k=1).astype(bool)) # 提取上三角矩阵
to_drop = [column for column in upper_triangle.columns if any(upper_triangle[column] > threshold)]
print("删除的冗余特征：", to_drop)# 打印删除的冗余特征名称
df_train_copy = df_train_copy.drop(columns=to_drop)# 删除冗余特征
correlation_matrix_after = df_train_copy.corr()# 重新计算相关性矩阵
3. 模型训练前准备
3.1 数据加载与准备
首先，我们加载了经过预处理的数据集 df_train_copy_processed.csv，并使用 pandas 的 read_csv 函数读取数据。接着，通过 dtypes 查看了数据集中每一列的类型，确保数据的类型与预期
一致。
3.2 特征与目标变量分离
在数据集加载后，我们将特征和目标变量分开：

特征变量（X）：去除了目标变量 claim_status 后的其他列。

目标变量（y）：即 claim_status 列，表示每个保险客户是否提出了索赔请求（1 为已索赔，0 为未索赔）。
3.3 处理二值特征
为了提高模型的训练效率，我们检查了数据中的二值特征（即值为 0 或 1 的特征），并将这些特征转换为布尔类型（True 和 False）。这种转换有助于模型更好地理解数据。
3.4 数据划分
接下来，我们使用 train_test_split 函数将数据集分为训练集和测试集：

训练集（X_train, y_train）：占 80%，用于模型的训练。

测试集（X_test, y_test）：占 20%，用于模型的评估和验证。
3.5 数据标准化
由于许多机器学习算法对特征的尺度较为敏感，因此我们对数值特征进行了标准化：

使用 StandardScaler 对训练集和测试集中的数值特征进行标准化，使得每个数值特征的均值为 0，标准差为 1。

在标准化过程中，我们只对数值特征进行了处理，排除了布尔类型的特征。
标准化后，我们将数值特征与原始的布尔特征合并，形成最终的训练集和测试集数据。
3.6 查看标准化后的数据
最终，我们查看了标准化后的训练集和测试集的前几行数据，并确认数据的正确性。打印了训练集的大小，确保数据划分合理，并输出了训练集和测试集的形状，确保其符合预期。
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
# 加载数据
df = pd.read_csv(r"D:\04 course\who claim\df_train_copy_processed.csv")
# 查看数据类型
print("数据集的列数据类型：")
print(df.dtypes)
# 分离特征和目标变量
X = df.drop(columns=["claim_status"]) # 特征
y = df["claim_status"] # 目标变量
# 找到二值数据（0 和 1）并将它们转换为布尔类型
binary_columns = X.select_dtypes(include=['int', 'float']).columns
for col in binary_columns:
if X[col].nunique() == 2: # 判断是否是二值特征
X[col] = X[col].astype(bool) # 转换为布尔类型
# 查看转换后的数据类型
print("\n 转换后的特征数据列数据类型：")
print(X.dtypes)
# 检查转换后的前几行数据
print("\n 转换后的前几行数据：")
print(X.head())
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 初始化 StandardScaler 对象
scaler = StandardScaler()
# 只对数值特征进行标准化
# 选择数值特征（排除布尔类型）
numeric_columns = X_train.select_dtypes(include=['int64', 'float64']).columns
# 标准化数值特征
X_train_scaled = scaler.fit_transform(X_train[numeric_columns])
X_test_scaled = scaler.transform(X_test[numeric_columns])
# 将标准化后的数值特征转换回 DataFrame
X_train_scaled = pd.DataFrame(X_train_scaled, columns=numeric_columns)
X_test_scaled = pd.DataFrame(X_test_scaled, columns=numeric_columns)
# 合并布尔特征和标准化后的数值特征
X_train_final = pd.concat([X_train[numeric_columns].reset_index(drop=True), X_train_scaled], axis=1)
X_test_final = pd.concat([X_test[numeric_columns].reset_index(drop=True), X_test_scaled], axis=1)
5. 模型训练与优化
5.1 模型选择
在本项目中，我们使用了多个强基学习器进行训练与优化，基学习器包括：

RandomForestClassifier（随机森林）

XGBClassifier（XGBoost）

LGBMClassifier（LightGBM）

AdaBoostClassifier（AdaBoost）

DecisionTreeClassifier（决策树）
为了提升模型的性能，特别是处理类别不平衡问题，我们对模型进行了贝叶斯优化，并通过 Stacking 方法进行集成学习。
5.2 基学习器的训练与优化
我们使用了 贝叶斯优化（Bayesian Optimization）来对基学习器进行超参数优化，优化的参数包括每个基学习器的关键超参数，如树的深度、学习率、迭代次数等。贝叶斯优化的优势在于
能够在较少的迭代次数内找到性能较优的超参数。
AdaBoost 和 DecisionTree 基学习器的优化

使用 AdaBoost 与 DecisionTree 作为弱分类器，通过贝叶斯优化搜索最优的超参数，如 n_estimators（迭代次数）、learning_rate（学习率）、max_depth（树的深度）等。
XGBoost 基学习器的优化

XGBoost 模型是通过贝叶斯优化调整了 n_estimators、learning_rate、max_depth 等参数，并加入了 早停机制，使模型能够在训练过程中自动停止，以避免过拟合。
LightGBM 和 RandomForest 基学习器的优化

对于 LightGBM 和 RandomForest，我们也采用了类似的方法，通过贝叶斯优化优化了每个基学习器的超参数，确保其在训练数据上表现最佳。
5.3 类别不平衡处理
在训练过程中，类别不平衡问题可能导致模型偏向预测多数类（即非理赔客户）。为了缓解这一问题，我们采取了以下措施：

SMOTE（合成少数类过采样技术）：通过生成新的少数类样本，来平衡数据集中的类别比例。

随机欠采样：减少多数类样本的数量，使得训练数据更加均衡，避免模型偏向多数类。
5.4 堆叠模型的构建
为进一步提升预测准确性，我们采用了 堆叠模型（Stacking Model）。堆叠模型的构建过程如下：
1.
基学习器预测：首先，我们训练了多个基学习器并在训练集上做预测。每个基学习器（如 AdaBoost、XGBoost、LightGBM 等）都产生了一个概率预测。
2.
堆叠特征生成：将所有基学习器的预测结果作为新的特征，输入到元学习器（LogisticRegression）中。
3.
训练元学习器：使用这些新的特征训练元学习器（逻辑回归），并通过它来做最终的预测。
4.
堆叠模型评估：在测试集上使用堆叠模型进行预测，并计算 AUC（Area Under the Curve） 指标，以评估模型的性能。
5.5 模型保存与结果
所有训练完成的基学习器和堆叠模型都使用 joblib 保存，以便在未来进行加载和推理。

模型保存：通过 joblib.dump() 将训练好的模型保存到磁盘，确保模型可以在后续使用中进行加载。

AUC 评估：计算并记录堆叠模型的 AUC 值，该指标反映了模型的分类性能，值越高表示模型越擅长区分正负类别。
5.6 训练日志
在整个模型训练过程中，我们使用了 日志记录，以追踪每个步骤的执行状态和训练过程中的关键信息，包括：

各基学习器的最佳超参数。

每个基学习器的 AUC 值。

堆叠模型的最终 AUC 值。
所有日志信息都会被保存在 model_training.log 文件中，方便后期检查与调试。
5.7 模型输出
最终，训练好的 堆叠模型 被保存为 stacking_model_with_meta_learner.pkl，并可以在新的数据上进行预测。
# 初始化 K 折交叉验证
kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
# 定义基学习器
rf_model = RandomForestClassifier(random_state=42, class_weight='balanced')
adaboost_model = AdaBoostClassifier(base_estimator=DecisionTreeClassifier(max_depth=3), n_estimators=50, random_state=42)
xgb_model = XGBClassifier(eval_metric='logloss', random_state=42, scale_pos_weight=1)
lgbm_model = LGBMClassifier(random_state=42, class_weight='balanced')
# 定义超参数搜索空间
param_space_rf = {
'n_estimators': (50, 500),
'max_depth': (3, 10),
'min_samples_split': (2, 20)
}
param_space_adaboost = {
'n_estimators': (50, 200),
'learning_rate': (0.01, 1.0, 'uniform')
}
param_space_xgb = {
'learning_rate': (0.01, 0.3, 'uniform'),
'n_estimators': (50, 500),
'max_depth': (3, 10),
}
param_space_lgbm = {
'n_estimators': (50, 500),
'learning_rate': (0.01, 0.3, 'uniform'),
'max_depth': (3, 10),
}
# 超参数搜索与训练基学习器
models = [
('rf', rf_model, param_space_rf),
('adaboost', adaboost_model, param_space_adaboost),
('xgb', xgb_model, param_space_xgb),
('lgbm', lgbm_model, param_space_lgbm)
]
# 保存训练好的基学习器
for name, model, param_space in models:
logging.info(f"开始训练 {name} 模型")
# 使用 SMOTE 进行过采样（增加少数类别样本）
smote = SMOTE(random_state=42)
X_train_resampled, y_train_resampled = smote.fit_resample(X_train, y_train)
# 使用贝叶斯优化
opt = BayesSearchCV(model, param_space, n_iter=30, cv=kf, n_jobs=-1, scoring='roc_auc', verbose=3)
# 训练模型，使用重采样后的数据
opt.fit(X_train_resampled, y_train_resampled)
# 保存最优模型
joblib.dump(opt.best_estimator_, f"{name}_model.pkl")
logging.info(f"{name} 最优模型已保存！")
# 基学习器的预测（在训练集上）
adaboost_pred_train = adaboost_model.predict_proba(X_train)[:, 1]
dt_pred_train = dt_model.predict_proba(X_train)[:, 1]
rf_pred_train = rf_model.predict_proba(X_train)[:, 1]
xgb_pred_train = xgb_model.predict_proba(X_train)[:, 1]
lgbm_pred_train = lgbm_model.predict_proba(X_train)[:, 1]
# 将基学习器的预测结果作为特征输入
stacking_output_train = np.column_stack((adaboost_pred_train, dt_pred_train, rf_pred_train, xgb_pred_train, lgbm_pred_train))
# 定义元学习器（Logistic Regression）
meta_learner = LogisticRegression()
# 训练元学习器
meta_learner.fit(stacking_output_train, y_train)
# 基学习器的预测（在测试集上）
adaboost_pred_test = adaboost_model.predict_proba(X_test)[:, 1]
dt_pred_test = dt_model.predict_proba(X_test)[:, 1]
rf_pred_test = rf_model.predict_proba(X_test)[:, 1]
xgb_pred_test = xgb_model.predict_proba(X_test)[:, 1]
lgbm_pred_test = lgbm_model.predict_proba(X_test)[:, 1]
# 将基学习器的预测结果作为测试集输入特征
stacking_output_test = np.column_stack((adaboost_pred_test, dt_pred_test, rf_pred_test, xgb_pred_test, lgbm_pred_test))
# 使用元学习器进行预测
y_pred = meta_learner.predict_proba(stacking_output_test)[:, 1]
# 保存堆叠模型
joblib.dump(meta_learner, 'stacking_model_with_meta_learner.pkl')
# 设置日志格式
import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
# 加载已训练的基学习器（RandomForest, XGBoost, LGBM, AdaBoost, DecisionTree）
rf_model = joblib.load('rf_model.pkl') # 已训练好的 RandomForestClassifier
xgb_model = joblib.load('xgb_model.pkl') # 已训练好的 XGBClassifier
lgbm_model = joblib.load('lgbm_model.pkl') # 已训练好的 LGBMClassifier
adaboost_model = joblib.load('adaboost_model_optimized.pkl') # 已训练好的 AdaBoostClassifier
dt_model = joblib.load('dt_model_optimized.pkl') # 已训练好的 DecisionTreeClassifier
meta_learner = joblib.load('stacking_model_with_meta_learner.pkl') # 已训练好的堆叠模型（元学习器）
# 基学习器的预测（在测试集上）
rf_pred_test = rf_model.predict_proba(X_test)[:, 1]
xgb_pred_test = xgb_model.predict_proba(X_test)[:, 1]
lgbm_pred_test = lgbm_model.predict_proba(X_test)[:, 1]
adaboost_pred_test = adaboost_model.predict_proba(X_test)[:, 1]
dt_pred_test = dt_model.predict_proba(X_test)[:, 1] # DecisionTree 的预测
# 计算基学习器的 AUC 值
rf_auc = roc_auc_score(y_test, rf_pred_test)
xgb_auc = roc_auc_score(y_test, xgb_pred_test)
lgbm_auc = roc_auc_score(y_test, lgbm_pred_test)
adaboost_auc = roc_auc_score(y_test, adaboost_pred_test)
dt_auc = roc_auc_score(y_test, dt_pred_test)
# 打印基学习器 AUC
print(f"Random Forest AUC: {rf_auc:.4f}")
print(f"XGBoost AUC: {xgb_auc:.4f}")
print(f"LightGBM AUC: {lgbm_auc:.4f}")
print(f"AdaBoost AUC: {adaboost_auc:.4f}")
print(f"Decision Tree AUC: {dt_auc:.4f}")
# 基学习器预测结果（元学习器输入）
stacking_output_test = np.column_stack((rf_pred_test, xgb_pred_test, lgbm_pred_test, adaboost_pred_test, dt_pred_test))
# 使用元学习器进行预测
y_pred = meta_learner.predict_proba(stacking_output_test)[:, 1]
# 加载已训练的基学习器（RandomForest, XGBoost, LGBM, AdaBoost, DecisionTree）
rf_model = joblib.load('rf_model.pkl') # 已训练好的 RandomForestClassifier
xgb_model = joblib.load('xgb_model.pkl') # 已训练好的 XGBClassifier
lgbm_model = joblib.load('lgbm_model.pkl') # 已训练好的 LGBMClassifier
adaboost_model = joblib.load('adaboost_model_optimized.pkl') # 已训练好的 AdaBoostClassifier
dt_model = joblib.load('dt_model_optimized.pkl') # 已训练好的 DecisionTreeClassifier
meta_learner = joblib.load('stacking_model_with_meta_learner.pkl') # 已训练好的堆叠模型（元学习器）
# 基学习器的预测（在测试集上）
rf_pred_test = rf_model.predict_proba(X_test)[:, 1]
xgb_pred_test = xgb_model.predict_proba(X_test)[:, 1]
lgbm_pred_test = lgbm_model.predict_proba(X_test)[:, 1]
adaboost_pred_test = adaboost_model.predict_proba(X_test)[:, 1]
dt_pred_test = dt_model.predict_proba(X_test)[:, 1] # DecisionTree 的预测
# 计算基学习器的 AUC 值
rf_auc = roc_auc_score(y_test, rf_pred_test)
xgb_auc = roc_auc_score(y_test, xgb_pred_test)
lgbm_auc = roc_auc_score(y_test, lgbm_pred_test)
adaboost_auc = roc_auc_score(y_test, adaboost_pred_test)
dt_auc = roc_auc_score(y_test, dt_pred_test)
# 打印基学习器 AUC
print(f"Random Forest AUC: {rf_auc:.4f}")
print(f"XGBoost AUC: {xgb_auc:.4f}")
print(f"LightGBM AUC: {lgbm_auc:.4f}")
print(f"AdaBoost AUC: {adaboost_auc:.4f}")
print(f"Decision Tree AUC: {dt_auc:.4f}")
# 基学习器预测结果（元学习器输入）
stacking_output_test = np.column_stack((rf_pred_test, xgb_pred_test, lgbm_pred_test, adaboost_pred_test, dt_pred_test))
# 使用元学习器进行预测
y_pred = meta_learner.predict_proba(stacking_output_test)[:, 1]
# 计算元学习器的 AUC 值
stacking_auc = roc_auc_score(y_test, y_pred)
print(f"堆叠模型（元学习器）的 AUC: {stacking_auc:.4f}")
# 绘制 ROC 曲线
fpr_rf, tpr_rf, _ = roc_curve(y_test, rf_pred_test)
fpr_xgb, tpr_xgb, _ = roc_curve(y_test, xgb_pred_test)
fpr_lgbm, tpr_lgbm, _ = roc_curve(y_test, lgbm_pred_test)
fpr_adaboost, tpr_adaboost, _ = roc_curve(y_test, adaboost_pred_test)
fpr_dt, tpr_dt, _ = roc_curve(y_test, dt_pred_test)
fpr_stacking, tpr_stacking, _ = roc_curve(y_test, y_pred)
plt.figure(figsize=(10, 8))
# 绘制每个基学习器的 ROC 曲线
plt.plot(fpr_rf, tpr_rf, label=f'Random Forest (AUC = {rf_auc:.4f})', linestyle='-', linewidth=2)
plt.plot(fpr_xgb, tpr_xgb, label=f'XGBoost (AUC = {xgb_auc:.4f})', linestyle='--', linewidth=2)
plt.plot(fpr_lgbm, tpr_lgbm, label=f'LightGBM (AUC = {lgbm_auc:.4f})', linestyle='-.', linewidth=2)
plt.plot(fpr_adaboost, tpr_adaboost, label=f'AdaBoost (AUC = {adaboost_auc:.4f})', linestyle=':', linewidth=2)
plt.plot(fpr_dt, tpr_dt, label=f'Decision Tree (AUC = {dt_auc:.4f})', linestyle='-', linewidth=2, color='green')
# 绘制堆叠模型的 ROC 曲线
plt.plot(fpr_stacking, tpr_stacking, label=f'Stacking Model (AUC = {stacking_auc:.4f})', linestyle='-', linewidth=3, color='black')
Random Forest AUC: 0.6449
XGBoost AUC: 0.6022
LightGBM AUC: 0.6075
AdaBoost AUC: 0.5433
Decision Tree AUC: 0.6435
堆叠模型（元学习器）的 AUC: 0.6467
模型总结
通过对多个基学习器（RandomForest、XGBoost、LightGBM、AdaBoost、DecisionTree）和
堆叠模型（元学习器）的评估，我们发现模型在预测理赔客户和非理赔客户的过程中表现较为
平庸。各个模型的 AUC 值 都低于理想水平，堆叠模型（元学习器）也仅略微提高了性能。
总结：

AUC 值较低：尽管堆叠模型稍微提高了性能，但整体的 AUC 值仍低于 0.65，表示模型在
区分理赔与非理赔客户方面的能力有限。

类别不平衡问题：模型的表现可能受到了 类别不平衡 的影响，少数类（理赔客户）的预
测能力较弱。

模型优化空间：基学习器和堆叠模型的参数调优和特征工程仍有较大的提升空间，可能是
导致低 AUC 的原因之一。
改进建议：

通过 特征工程、数据处理 和 超参数调优 来优化模型表现。

采用 SMOTE 或其他类别不平衡处理方法，提升模型对少数类的预测能力。

尝试更强的集成方法或神经网络等先进模型，进一步提高准确性。