第十八天打卡-CSDN博客

本文链接：https://blog.csdn.net/nbbsn/article/details/147778352

@浙大疏锦行

常见的特征筛选算法

1. 方差筛选

2. 皮尔逊相关系数筛选

3. lasso筛选

4. 树模型重要性

5. shap重要性

6. 递归特征消除REF

方差筛选

一、方差筛选的步骤：

1. 计算每个特征的方差：对数据集中的每个特征列，计算其数值的方差
2. 设定阈值：根据经验或通过交叉验证确定一个方差阈值（如0.1）
3. 筛选特征：保留方差大于阈值的特征，剔除方差小的特征

二、Python代码示例（使用sklearn）：

from sklearn.feature_selection import VarianceThreshold

# 假设X是特征数据
selector = VarianceThreshold(threshold=0.1)  # 设置方差阈值
X_new = selector.fit_transform(X)  # 得到筛选后的特征

# 查看被保留的特征
print("保留的特征数:", X_new.shape[1])

三、输出结果：

1. 筛选后的特征矩阵（维度降低）
2. 被剔除的特征索引（可通过selector.get_support()获取）
3. 保留的特征数量
四、实际应用场景：

1. 文本分类中的词频特征（剔除低频词）
2. 图像处理中的像素特征（剔除不变区域）
3. 生物信息学中的基因表达数据（剔除不活跃基因）
五、注意事项：

1. 需要先对数据进行标准化（避免量纲影响）
2. 阈值选择很关键（太小没效果，太大会误删）
3. 常与其他特征选择方法结合使用
这种方法特别适合处理以下情况：

- 特征数量非常多（如>1000个）
- 计算资源有限
- 需要快速初步筛选特征

# 打印标题，表明这是方差筛选的部分
print("--- 方差筛选 (Variance Threshold) ---")

# 导入需要的工具库
from sklearn.feature_selection import VarianceThreshold  # 方差筛选工具，用于剔除方差小的特征
import time  # 用于记录代码运行时间，方便比较效率

# 记录开始时间，后面会计算整个过程耗时
start_time = time.time()

# 创建方差筛选器，设置方差阈值为0.01
# 阈值是指方差的最小值，低于这个值的特征会被删除（可以根据数据情况调整阈值）
selector = VarianceThreshold(threshold=0.01)

# 对训练数据进行方差筛选，fit_transform会计算每个特征的方差并剔除不满足阈值的特征
# X_train是原始训练数据，X_train_var是筛选后的训练数据
X_train_var = selector.fit_transform(X_train)

# 对测试数据应用同样的筛选规则，transform会直接用训练数据的筛选结果处理测试数据
# X_test是原始测试数据，X_test_var是筛选后的测试数据
X_test_var = selector.transform(X_test)

# 获取被保留下来的特征名称
# selector.get_support()返回一个布尔值列表，表示哪些特征被保留，这个是selector这个实例化的类的一个方法
# X_train.columns是特征的名称，结合布尔值列表可以提取保留特征的名字
selected_features_var = X_train.columns[selector.get_support()].tolist()

# 打印筛选后保留的特征数量和具体特征名称，方便查看结果
print(f"方差筛选后保留的特征数量: {len(selected_features_var)}")
print(f"保留的特征: {selected_features_var}")

# 创建一个随机森林分类模型，用于在筛选后的数据上进行训练和预测
# random_state=42是为了保证每次运行结果一致，方便教学和对比
rf_model_var = RandomForestClassifier(random_state=42)

# 在筛选后的训练数据上训练模型
# X_train_var是筛选后的特征数据，y_train是对应的目标标签
rf_model_var.fit(X_train_var, y_train)

# 使用训练好的模型对筛选后的测试数据进行预测
# X_test_var是筛选后的测试特征数据，rf_pred_var是预测结果
rf_pred_var = rf_model_var.predict(X_test_var)

# 记录结束时间，计算整个训练和预测过程的耗时
end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")

# 打印模型在测试集上的分类报告，展示模型的性能
# 分类报告包括精确率、召回率、F1分数等指标，帮助评估模型好坏
print("\n方差筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_var))

# 打印混淆矩阵，展示模型预测的详细结果
# 混淆矩阵显示了真实标签和预测标签的对应情况，比如多少样本被正确分类，多少被错分
print("方差筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_var))

--- 方差筛选 (Variance Threshold) ---
方差筛选后保留的特征数量: 21
保留的特征: ['Id', 'Home Ownership', 'Annual Income', 'Years in current job', 'Tax Liens', 'Number of Open Accounts', 'Years of Credit History', 'Maximum Open Credit', 'Number of Credit Problems', 'Months since last delinquent', 'Bankruptcies', 'Long Term', 'Current Loan Amount', 'Current Credit Balance', 'Monthly Debt', 'Credit Score', 'Purpose_business loan', 'Purpose_buy a car', 'Purpose_debt consolidation', 'Purpose_home improvements', 'Purpose_other']
训练与预测耗时: 3.1907 秒

方差筛选后随机森林在测试集上的分类报告：
              precision    recall  f1-score   support

           0       0.77      0.97      0.86      1059
           1       0.80      0.29      0.42       441

    accuracy                           0.77      1500
   macro avg       0.78      0.63      0.64      1500
weighted avg       0.78      0.77      0.73      1500

方差筛选后随机森林在测试集上的混淆矩阵：
[[1028   31]
 [ 315  126]]

皮尔逊相关系数筛选

一、核心原理：
皮尔逊系数（r值）衡量两个变量的线性相关性，范围从-1到1：

- r=1：完全正相关
- r=-1：完全负相关
- r=0：无线性相关
二、筛选步骤：

1. 数据准备：

- 如果是分类问题，先将目标变量编码为数值（如0/1）
- 连续型目标变量可直接使用
2. 计算相关系数：
对每个特征计算与目标变量的皮尔逊r值
3. 设定阈值：
根据需求选择r的绝对值阈值（如0.3）
4. 特征筛选：
保留|r|≥阈值的特征，剔除弱相关特征
三、Python代码示例（基于sklearn）：

from sklearn.feature_selection import SelectKBest
from scipy.stats import pearsonr

# 自定义评分函数
def pearson_selector(X, y):
    scores = [pearsonr(X[:,i], y)[0] for i in range(X.shape[1])]
    return np.array(scores)

# 选择与目标变量相关性最高的k个特征
selector = SelectKBest(score_func=pearson_selector, k=10)
X_new = selector.fit_transform(X, y)

四、输出结果：

1. 筛选后的特征矩阵（维度降低）
2. 各特征的相关系数得分（可通过selector.scores_查看）
3. 保留的特征索引/名称
五、典型应用场景：

1. 金融领域的风险预测（筛选与违约率相关的特征）
2. 医疗数据分析（选择与疾病指标相关的生物标记物）
3. 销售预测（识别与销量强相关的市场因素）
六、注意事项：

1. 只能检测线性关系（非线性关系需用其他方法）
2. 对异常值敏感（需先进行数据清洗）
3. 不考虑特征间的交互作用
4. 通常作为特征选择的初步筛选步骤
实际案例说明：
假设预测房屋价格，通过计算得到：

- "面积"的r=0.82（强正相关）
- "房龄"的r=-0.65（强负相关）
- "朝向"的r=0.12（弱相关）
设置阈值0.5后，会保留"面积"和"房龄"，剔除"朝向"特征。

print("--- 皮尔逊相关系数筛选 ---")
from sklearn.feature_selection import SelectKBest, f_classif
import time

start_time = time.time()

# 计算特征与目标变量的相关性，选择前k个特征（这里设为10个，可调整）
# 注意：皮尔逊相关系数通常用于回归问题（连续型目标变量），但如果目标是分类问题，可以用f_classif
k = 10
selector = SelectKBest(score_func=f_classif, k=k)
X_train_corr = selector.fit_transform(X_train, y_train)
X_test_corr = selector.transform(X_test)

# 获取筛选后的特征名
selected_features_corr = X_train.columns[selector.get_support()].tolist()
print(f"皮尔逊相关系数筛选后保留的特征数量: {len(selected_features_corr)}")
print(f"保留的特征: {selected_features_corr}")

# 训练随机森林模型
rf_model_corr = RandomForestClassifier(random_state=42)
rf_model_corr.fit(X_train_corr, y_train)
rf_pred_corr = rf_model_corr.predict(X_test_corr)

end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\n皮尔逊相关系数筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_corr))
print("皮尔逊相关系数筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_corr))

--- 皮尔逊相关系数筛选 ---
皮尔逊相关系数筛选后保留的特征数量: 10
保留的特征: ['Id', 'Home Ownership', 'Annual Income', 'Tax Liens', 'Number of Open Accounts', 'Long Term', 'Current Loan Amount', 'Credit Score', 'Purpose_business loan', 'Purpose_small business']
训练与预测耗时: 2.4820 秒

皮尔逊相关系数筛选后随机森林在测试集上的分类报告：
              precision    recall  f1-score   support

           0       0.77      0.94      0.84      1059
           1       0.67      0.31      0.42       441

    accuracy                           0.75      1500
   macro avg       0.72      0.62      0.63      1500
weighted avg       0.74      0.75      0.72      1500

皮尔逊相关系数筛选后随机森林在测试集上的混淆矩阵：
[[991  68]
 [304 137]]

lasso筛选（基于L1正则化）

一、核心原理：

1. 在普通线性回归基础上加入L1正则化项（惩罚项）
2. 通过调整惩罚力度（alpha参数），将不重要特征的系数压缩为0
3. 保留系数不为0的特征，实现自动特征选择
二、使用步骤：

1. 数据标准化（必须步骤，因为Lasso对特征尺度敏感）
2. 选择合适的alpha值（控制特征选择的严格程度）
3. 训练Lasso模型
4. 提取系数不为0的特征
三、Python代码示例（基于sklearn）：

from sklearn.linear_model import Lasso
from sklearn.preprocessing import StandardScaler

# 数据标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 创建Lasso模型（alpha值越小，保留的特征越多）
lasso = Lasso(alpha=0.01, random_state=42)
lasso.fit(X_train_scaled, y_train)

# 获取被保留的特征（系数不为0的特征）
selected_features = X_train.columns[lasso.coef_ != 0].tolist()

选择Lasso回归中的最佳alpha值确实非常关键，下面介绍几种常用的方法：

1. 网格搜索交叉验证（最常用方法）：

from sklearn.linear_model import LassoCV

# 自动尝试多个alpha值（默认100个对数间隔值）
lasso_cv = LassoCV(cv=5)  # cv=5表示5折交叉验证
lasso_cv.fit(X_train_scaled, y_train)

# 输出最佳alpha值
print(f"最佳alpha值: {lasso_cv.alpha_}")

2.可视化验证曲线（帮助理解alpha影响）：

import matplotlib.pyplot as plt
from sklearn.model_selection import validation_curve

alphas = np.logspace(-4, 0, 50)  # 生成50个候选alpha值
train_scores, test_scores = validation_curve(
    Lasso(), X_train_scaled, y_train,
    param_name="alpha", param_range=alphas, cv=5)

plt.semilogx(alphas, np.mean(train_scores, axis=1), label="训练集")
plt.semilogx(alphas, np.mean(test_scores, axis=1), label="验证集")
plt.legend()
plt.xlabel("alpha值")
plt.ylabel("模型得分")
plt.show()

3. 经验法则：
- 从较大的alpha开始（如1.0）
- 逐步减小（如0.1, 0.01, 0.001...）
- 观察保留特征数量和模型性能
- 选择使验证集性能最好的最小alpha
实际选择时建议：

1. 先用LassoCV自动搜索大致范围
2. 再用验证曲线精细调整
3. 最终选择时考虑：
- 模型复杂度（保留特征数）
- 验证集性能
- 业务需求（是否需要更稀疏的模型）
注意：alpha值越小，保留的特征越多，模型越复杂；alpha值越大，保留的特征越少，模型越简单。

print("--- Lasso筛选 (L1正则化) ---")
from sklearn.linear_model import Lasso
from sklearn.feature_selection import SelectFromModel
import time

start_time = time.time()

# 使用Lasso回归进行特征筛选
lasso = Lasso(alpha=0.01, random_state=42)  # alpha值可调整
selector = SelectFromModel(lasso)
selector.fit(X_train, y_train)
X_train_lasso = selector.transform(X_train)
X_test_lasso = selector.transform(X_test)

# 获取筛选后的特征名
selected_features_lasso = X_train.columns[selector.get_support()].tolist()
print(f"Lasso筛选后保留的特征数量: {len(selected_features_lasso)}")
print(f"保留的特征: {selected_features_lasso}")

# 训练随机森林模型
rf_model_lasso = RandomForestClassifier(random_state=42)
rf_model_lasso.fit(X_train_lasso, y_train)
rf_pred_lasso = rf_model_lasso.predict(X_test_lasso)

end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\nLasso筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_lasso))
print("Lasso筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_lasso))

--- Lasso筛选 (L1正则化) ---
Lasso筛选后保留的特征数量: 7
保留的特征: ['Home Ownership', 'Years in current job', 'Number of Open Accounts', 'Years of Credit History', 'Months since last delinquent', 'Long Term', 'Credit Score']
训练与预测耗时: 1.3993 秒

Lasso筛选后随机森林在测试集上的分类报告：
              precision    recall  f1-score   support

           0       0.77      0.94      0.85      1059
           1       0.70      0.34      0.45       441

    accuracy                           0.76      1500
   macro avg       0.74      0.64      0.65      1500
weighted avg       0.75      0.76      0.73      1500

Lasso筛选后随机森林在测试集上的混淆矩阵：
[[995  64]
 [293 148]]

树模型重要性

一、核心原理：

1. 决策树在分裂节点时会计算特征的重要性
2. 重要特征会被频繁用于分裂且带来较大信息增益
3. 通过统计所有树中的特征使用情况，得出重要性评分
二、使用步骤：

1. 训练树模型（随机森林/XGBoost等）
2. 获取特征重要性得分
3. 根据得分筛选重要特征
三、Python代码示例（基于随机森林）：

from sklearn.ensemble import RandomForestClassifier

# 训练随机森林模型
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# 获取特征重要性（值越大越重要）
importances = rf.feature_importances_

# 按重要性排序
feature_ranking = pd.DataFrame({
    '特征': X_train.columns,
    '重要性': importances
}).sort_values('重要性', ascending=False)

四、输出结果：

1. 各特征的重要性得分（0-1之间）
2. 特征重要性排序（表格形式）
3. 可视化重要性条形图（可选）
五、实际应用场景：

1. 金融风控（识别影响违约的关键因素）
2. 医疗诊断（找出与疾病最相关的指标）
3. 推荐系统（确定影响用户偏好的主要特征）
六、优势特点：

1. 考虑特征间的交互作用
2. 适用于非线性关系
3. 结果直观可解释
4. 不需要单独的特征选择步骤
七、注意事项：

1. 重要性是相对值，受模型参数影响
2. 高重要性≠因果关系
3. 需要足够多的树（n_estimators不宜太小）
4. 可能偏向高基数特征
实际案例说明：
预测信用卡审批时，可能发现：

- "年收入"重要性最高（0.45）
- "信用历史"次之（0.3）
- "职业类型"较低（0.05）
可保留前两个特征，剔除最后一个

print("--- 树模型自带的重要性筛选 ---")
from sklearn.feature_selection import SelectFromModel
import time

start_time = time.time()

# 使用随机森林的特征重要性进行筛选
rf_selector = RandomForestClassifier(random_state=42)
rf_selector.fit(X_train, y_train)
selector = SelectFromModel(rf_selector, threshold="mean")  # 阈值设为平均重要性，可调整
X_train_rf = selector.transform(X_train)
X_test_rf = selector.transform(X_test)

# 获取筛选后的特征名
selected_features_rf = X_train.columns[selector.get_support()].tolist()
print(f"树模型重要性筛选后保留的特征数量: {len(selected_features_rf)}")
print(f"保留的特征: {selected_features_rf}")

# 训练随机森林模型
rf_model_rf = RandomForestClassifier(random_state=42)
rf_model_rf.fit(X_train_rf, y_train)
rf_pred_rf = rf_model_rf.predict(X_test_rf)

end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\n树模型重要性筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_rf))
print("树模型重要性筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_rf))

--- 树模型自带的重要性筛选 ---
树模型重要性筛选后保留的特征数量: 11
保留的特征: ['Id', 'Annual Income', 'Years in current job', 'Number of Open Accounts', 'Years of Credit History', 'Maximum Open Credit', 'Months since last delinquent', 'Current Loan Amount', 'Current Credit Balance', 'Monthly Debt', 'Credit Score']
训练与预测耗时: 7.4004 秒

树模型重要性筛选后随机森林在测试集上的分类报告：
              precision    recall  f1-score   support

           0       0.76      0.97      0.85      1059
           1       0.79      0.27      0.40       441

    accuracy                           0.76      1500
   macro avg       0.78      0.62      0.63      1500
weighted avg       0.77      0.76      0.72      1500

树模型重要性筛选后随机森林在测试集上的混淆矩阵：
[[1027   32]
 [ 321  120]]

SHAP重要性筛选

一、核心原理：

1. 计算每个特征对模型预测的贡献值（SHAP值）
2. 通过多次样本分析，得出特征的平均绝对贡献
3. 贡献值越大表示特征越重要
二、使用步骤：

1. 训练一个机器学习模型（如随机森林）
2. 计算SHAP值（需要额外安装shap库）
3. 分析特征重要性排序
4. 筛选重要特征
三、Python代码示例：

import shap
from sklearn.ensemble import RandomForestClassifier

# 训练模型
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

# 创建SHAP解释器
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_train)

# 计算特征重要性（取绝对值后求平均）
shap_importance = np.abs(shap_values).mean(axis=0)[0]  # 分类问题取第一个类别
feature_ranking = pd.DataFrame({
    '特征': X_train.columns,
    'SHAP重要性': shap_importance
}).sort_values('SHAP重要性', ascending=False)

四、输出结果：

1. 各特征的SHAP重要性得分
2. 特征重要性排序（表格形式）
3. 可视化SHAP摘要图（可选）
五、实际应用场景：

1. 金融风控（解释为什么拒绝贷款申请）
2. 医疗诊断（解释疾病预测依据）
3. 推荐系统（解释推荐理由）
六、优势特点：

1. 考虑特征间的交互作用
2. 提供全局和局部解释
3. 适用于任何机器学习模型
4. 结果直观可解释
七、注意事项：

1. 计算成本较高（大数据集较慢）
2. 需要安装shap库（pip install shap）
3. 解释的是模型行为而非因果关系
实际案例说明：
预测信用卡欺诈时，SHAP可能显示：

- "交易金额"SHAP值最高（对欺诈判断影响最大）
- "交易地点"次之
- "交易时间"影响较小
这种方法的独特价值在于：

1. 能解释单个预测（而不仅是整体特征重要性）
2. 能显示特征影响的方向（正/负影响）
3. 比传统重要性方法更精确可靠

print("--- SHAP重要性筛选 ---")
import shap
from sklearn.feature_selection import SelectKBest
import time

start_time = time.time()

# 使用随机森林模型计算SHAP值
rf_shap = RandomForestClassifier(random_state=42)
rf_shap.fit(X_train, y_train)
explainer = shap.TreeExplainer(rf_shap)
shap_values = explainer.shap_values(X_train)

# 计算每个特征的平均SHAP值（取绝对值的平均）
mean_shap = np.abs(shap_values[1]).mean(axis=0)  # shap_values[1]对应正类
k = 10  # 选择前10个特征，可调整
top_k_indices = np.argsort(mean_shap)[-k:]
X_train_shap = X_train.iloc[:, top_k_indices]
X_test_shap = X_test.iloc[:, top_k_indices]

# 获取筛选后的特征名
selected_features_shap = X_train.columns[top_k_indices].tolist()
print(f"SHAP重要性筛选后保留的特征数量: {len(selected_features_shap)}")
print(f"保留的特征: {selected_features_shap}")

# 训练随机森林模型
rf_model_shap = RandomForestClassifier(random_state=42)
rf_model_shap.fit(X_train_shap, y_train)
rf_pred_shap = rf_model_shap.predict(X_test_shap)

end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\nSHAP重要性筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_shap))
print("SHAP重要性筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_shap))

--- SHAP重要性筛选 ---
SHAP重要性筛选后保留的特征数量: 10
保留的特征: ['Id', 'Number of Open Accounts', 'Current Credit Balance', 'Years of Credit History', 'Monthly Debt', 'Maximum Open Credit', 'Long Term', 'Annual Income', 'Current Loan Amount', 'Credit Score']
训练与预测耗时: 459.6634 秒

SHAP重要性筛选后随机森林在测试集上的分类报告：
              precision    recall  f1-score   support

           0       0.77      0.95      0.85      1059
           1       0.74      0.31      0.44       441

    accuracy                           0.76      1500
   macro avg       0.75      0.63      0.64      1500
weighted avg       0.76      0.76      0.73      1500

SHAP重要性筛选后随机森林在测试集上的混淆矩阵：
[[1010   49]
 [ 304  137]]

递归特征消除RFE

递归特征消除(RFE)是一种通过逐步剔除不重要特征来选择最优特征子集的方法，下面用通俗易懂的方式解释：

一、工作原理（剥洋葱式筛选）：

1. 先训练一个完整模型（包含所有特征）
2. 评估每个特征的重要性得分
3. 剔除得分最低的特征（像剥掉洋葱最外层）
4. 重复上述过程，直到剩下指定数量的特征
二、使用步骤（以Python为例）：

1. 选择基础模型（需能评估特征重要性）
2. 设定要保留的特征数量
3. 创建RFE选择器并训练
4. 获取最终筛选结果
三、代码实现（基于sklearn）：

from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

# 创建RFE选择器（保留10个特征）
estimator = LogisticRegression(max_iter=1000)
selector = RFE(estimator, n_features_to_select=10)

# 执行特征选择
X_train_rfe = selector.fit_transform(X_train, y_train)
X_test_rfe = selector.transform(X_test)

# 获取筛选结果
selected_features = X_train.columns[selector.support_]

四、输出结果：

1. selector.support_ ：布尔数组，标记被保留的特征
2. selector.ranking_ ：特征排名（1表示被保留）
3. selector.estimator_ ：最终使用的模型
五、典型应用场景：

1. 医疗诊断：从数百项体检指标中筛选关键指标
2. 金融风控：从用户100+行为特征中找出核心风险特征
3. 基因分析：从上万基因中识别致病基因
六、优势特点：

1. 考虑特征组合效应（优于单变量筛选）
2. 结果稳定可靠
3. 适用于各种模型（线性/树模型等）
七、注意事项：

1. 计算成本较高（需反复训练模型）
2. 建议先做初步特征筛选（如方差筛选）
3. 重要参数：
- n_features_to_select ：最终保留特征数
- step ：每次迭代剔除的特征数（默认为1）
实际案例说明：
预测房价时，RFE可能：

1. 第一轮剔除"附近学校数量"（影响最小）
2. 第二轮剔除"窗户材质"
3. ...
4. 最终保留"面积"、"地段"等5个核心特征

print("--- 递归特征消除 (RFE) ---")
from sklearn.feature_selection import RFE
import time

start_time = time.time()

# 使用随机森林作为基础模型进行RFE
base_model = RandomForestClassifier(random_state=42)
rfe = RFE(base_model, n_features_to_select=10)  # 选择10个特征，可调整
rfe.fit(X_train, y_train)
X_train_rfe = rfe.transform(X_train)
X_test_rfe = rfe.transform(X_test)

# 获取筛选后的特征名
selected_features_rfe = X_train.columns[rfe.support_].tolist()
print(f"RFE筛选后保留的特征数量: {len(selected_features_rfe)}")
print(f"保留的特征: {selected_features_rfe}")

# 训练随机森林模型
rf_model_rfe = RandomForestClassifier(random_state=42)
rf_model_rfe.fit(X_train_rfe, y_train)
rf_pred_rfe = rf_model_rfe.predict(X_test_rfe)

end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\nRFE筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_rfe))
print("RFE筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_rfe))

--- 递归特征消除 (RFE) ---
RFE筛选后保留的特征数量: 10
保留的特征: ['Id', 'Annual Income', 'Number of Open Accounts', 'Years of Credit History', 'Maximum Open Credit', 'Months since last delinquent', 'Current Loan Amount', 'Current Credit Balance', 'Monthly Debt', 'Credit Score']
训练与预测耗时: 72.7936 秒

RFE筛选后随机森林在测试集上的分类报告：
              precision    recall  f1-score   support

           0       0.76      0.97      0.85      1059
           1       0.80      0.27      0.40       441

    accuracy                           0.76      1500
   macro avg       0.78      0.62      0.63      1500
weighted avg       0.77      0.76      0.72      1500

RFE筛选后随机森林在测试集上的混淆矩阵：
[[1030   29]
 [ 324  117]]