- 方差筛选
- 皮尔逊相关系数筛选
- lasso筛选
- 树模型重要性
- shap重要性
- 递归特征消除REF
作业：对心脏病数据集完成特征筛选，对比精度
输入：
## 预处理流程回顾
#1. 导入库
import pandas as pd
import pandas as pd #用于数据处理和分析，可处理表格数据。
import numpy as np #用于数值计算，提供了高效的数组操作。
import matplotlib.pyplot as plt #用于绘制各种类型的图表
import seaborn as sns #基于matplotlib的高级绘图库，能绘制更美观的统计图形。
# 设置中文字体（解决中文显示问题）
plt.rcParams['font.sans-serif'] = ['SimHei'] # 设置字体为黑体
plt.rcParams['axes.unicode_minus'] = False # 正常显示负号
#2. 读取数据查看数据信息--理解数据
data = pd.read_csv(r'heart.csv') #读取数据
print("数据基本信息：")
data.info()
print("\n数据前5行预览：")
print(data.head())
#3. 缺失值处理
# 先筛选字符串变量
discrete_features = data.select_dtypes(include=['object']).columns.tolist()
print("\n离散变量：")
print(discrete_features)
# 依次查看内容
for feature in discrete_features:
print(f"\n{feature}的唯一值：")
print(data[feature].value_counts())
#本数据集中不纯在离散变量
# thal 标签编码
thal_mapping = {
1: 1,
2: 2,
3: 3,
}
data['thal'] = data['thal'].map(thal_mapping)
# slope的独热编码，记得需要将bool类型转换为数值
data = pd.get_dummies(data, columns=['slope'])
data2 = pd.read_csv(r"heart.csv") # 重新读取数据，用来做列名对比
list_final = [] # 新建一个空列表，用于存放独热编码后新增的特征名
for i in data.columns:
if i not in data2.columns:
list_final.append(i) # 这里打印出来的就是独热编码后的特征名
for i in list_final:
data[i] = data[i].astype(int) # 这里的i就是独热编码后的特征名
print(list_final) # 打印出来的就是独热编码后的特征名
# 布尔矩阵显示缺失值，这个方法返回一个布尔矩阵
print(data.isnull())
print(data.isnull().sum()) # 统计每一列缺失值的数量
#填补缺失值
continuous_features = data.select_dtypes(include=['int64', 'float64']).columns.tolist() #把筛选出来的列名转换成列表
print("\n连续变量：")
print(continuous_features)
for feature in continuous_features:
mode_value = data[feature].mode()[0] #获取该列的众数。
data[feature] = data[feature].fillna(mode_value) #用众数填充该列的缺失值，inplace=True表示直接在原数据上修改。
print(data.isnull().sum()) # 统计每一列缺失值的数量
# 4. 异常值处理
#异常值一般不处理，或者结合对照试验处理和不处理都尝试下，但是论文中要写这个，作为个工作量
data.info() #查看数据基本信息
#此数据集无缺失值
#划分数据集
from sklearn.model_selection import train_test_split
X = data.drop('target', axis=1) # 特征
y = data['target'] # 目标变量
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # 划分训练集和测试集，test_size表示测试集占比，random_state表示随机种子，保证每次划分结果一致。
from sklearn.ensemble import RandomForestClassifier #随机森林分类器
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score # 用于评估分类器性能的指标
from sklearn.metrics import classification_report, confusion_matrix #用于生成分类报告和混淆矩阵
import warnings #用于忽略警告信息
warnings.filterwarnings("ignore") # 忽略所有警告信息
# --- 1. 默认参数的随机森林 ---
import time
print("--- 默认参数的随机森林 ---")
rf_model = RandomForestClassifier(random_state=42) # 创建随机森林分类器实例，random_state=42确保结果可重复。
start_time = time.time() # 记录开始时间，用于计算训练和预测的耗时。
rf_model.fit(X_train, y_train) # 在训练集上训练模型。
rf_pred = rf_model.predict(X_test) # 在测试集上进行预测。
end_time = time.time() # 记录结束时间。
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒") # 打印训练和预测的耗时。
print("\n默认参数随机森林在测试集上的分类报告：") # 打印分类报告，包括准确率、精确率、召回率和F1分数。
print(classification_report(y_test, rf_pred)) # 打印分类报告。
print("默认参数随机森林在测试集上的混淆矩阵：") # 打印混淆矩阵，显示模型的预测结果。
print(confusion_matrix(y_test, rf_pred)) # 打印混淆矩阵。
# 打印标题，表明这是方差筛选的部分
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))
print("--- 皮尔逊相关系数筛选 ---")
from sklearn.feature_selection import SelectKBest, f_classif
import time
# 记录开始时间，后面会计算整个过程耗时
start_time = time.time()
# 使用SelectKBest选择k个最佳特征，这里选择10个
selector = SelectKBest(f_classif, k=10) # 使用f_classif作为评分函数
X_train_pearson = selector.fit_transform(X_train, y_train) # 对训练数据进行特征选择
X_test_pearson = selector.transform(X_test) # 对测试数据进行特征选择
# 获取选择的特征索引
selected_features_pearson = selector.get_support(indices=True) # 获取选择的特征索引
# 打印选择的特征索引和对应的特征名称
print("选择的特征索引：", selected_features_pearson) # 打印选择的特征索引
print("选择的特征名称：", X_train.columns[selected_features_pearson]) # 打印选择的特征名称
# 创建一个随机森林分类模型，用于在筛选后的数据上进行训练和预测
# random_state=42是为了保证每次运行结果一致，方便教学和对比
rf_model_pearson = RandomForestClassifier(random_state=42)
# 在筛选后的训练数据上训练模型
# X_train_pearson是筛选后的特征数据，y_train是对应的目标标签
rf_model_pearson.fit(X_train_pearson, y_train)
# 使用训练好的模型对筛选后的测试数据进行预测
# X_test_pearson是筛选后的测试特征数据，rf_pred_pearson是预测结果
rf_pred_pearson = rf_model_pearson.predict(X_test_pearson)
# 记录结束时间，计算整个训练和预测过程的耗时
end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
# 打印模型在测试集上的分类报告，展示模型的性能
# 分类报告包括精确率、召回率、F1分数等指标，帮助评估模型好坏
print("\n皮尔逊相关系数筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_pearson))
# 打印混淆矩阵，展示模型预测的详细结果
# 混淆矩阵显示了真实标签和预测标签的对应情况，比如多少样本被正确分类，多少被错分
print("皮尔逊相关系数筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_pearson))
print("--- Lasso筛选 (L1正则化) ---")
from sklearn.linear_model import LassoCV # LassoCV是Lasso回归的交叉验证版本，用于选择最佳的正则化参数
import time
# 记录开始时间，后面会计算整个过程耗时
start_time = time.time()
# 创建LassoCV模型，cv=5表示使用5折交叉验证
lasso_cv = LassoCV(cv=5, random_state=42) # 创建LassoCV模型，cv=5表示使用5折交叉验证，random_state=42确保结果可重复
lasso_cv.fit(X_train, y_train) # 在训练数据上训练模型
# 获取选择的特征索引，coef_非零的特征被认为是重要的
selected_features_lasso = np.where(lasso_cv.coef_ != 0)[0] # 获取选择的特征索引，coef_非零的特征被认为是重要的
# 打印选择的特征索引和对应的特征名称
print("选择的特征索引：", selected_features_lasso) # 打印选择的特征索引
print("选择的特征名称：", X_train.columns[selected_features_lasso]) # 打印选择的特征名称
# 创建一个随机森林分类模型，用于在筛选后的数据上进行训练和预测
# random_state=42是为了保证每次运行结果一致，方便教学和对比
rf_model_lasso = RandomForestClassifier(random_state=42)
# 在筛选后的训练数据上训练模型
# X_train_lasso是筛选后的特征数据，y_train是对应的目标标签
rf_model_lasso.fit(X_train.iloc[:, selected_features_lasso], y_train) # 在筛选后的训练数据上训练模型
# 使用训练好的模型对筛选后的测试数据进行预测
# X_test_lasso是筛选后的测试特征数据，rf_pred_lasso是预测结果
rf_pred_lasso = rf_model_lasso.predict(X_test.iloc[:, selected_features_lasso]) # 使用训练好的模型对筛选后的测试数据进行预测
# 记录结束时间，计算整个训练和预测过程的耗时
end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
# 打印模型在测试集上的分类报告，展示模型的性能
# 分类报告包括精确率、召回率、F1分数等指标，帮助评估模型好坏
print("\nLasso筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_lasso))
# 打印混淆矩阵，展示模型预测的详细结果
# 混淆矩阵显示了真实标签和预测标签的对应情况，比如多少样本被正确分类，多少被错分
print("Lasso筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_lasso))
print("--- 随机森林自带的重要性筛选 ---")
from sklearn.feature_selection import SelectFromModel
import time
# 记录开始时间，后面会计算整个过程耗时
start_time = time.time()
# 创建随机森林模型
rf_selector = RandomForestClassifier(random_state=42)
# 使用SelectFromModel选择特征，threshold='mean'表示选择特征的重要性平均值以上的特征
selector = SelectFromModel(rf_selector, threshold='mean') # 使用SelectFromModel选择特征，threshold='mean'表示选择特征的重要性平均值以上的特征
selector.fit(X_train, y_train) # 在训练数据上训练模型
# 获取选择的特征索引，get_support()返回一个布尔值列表，表示哪些特征被选择
selected_features_rf = selector.get_support(indices=True) # 获取选择的特征索引，get_support()返回一个布尔值列表，表示哪些特征被选择
# 打印选择的特征索引和对应的特征名称
print("选择的特征索引：", selected_features_rf) # 打印选择的特征索引
print("选择的特征名称：", X_train.columns[selected_features_rf]) # 打印选择的特征名称
# 创建一个随机森林分类模型，用于在筛选后的数据上进行训练和预测
# random_state=42是为了保证每次运行结果一致，方便教学和对比
rf_model_rf = RandomForestClassifier(random_state=42)
# 在筛选后的训练数据上训练模型
# X_train_rf是筛选后的特征数据，y_train是对应的目标标签
rf_model_rf.fit(X_train.iloc[:, selected_features_rf], y_train) # 在筛选后的训练数据上训练模型
# 使用训练好的模型对筛选后的测试数据进行预测
# X_test_rf是筛选后的测试特征数据，rf_pred_rf是预测结果
rf_pred_rf = rf_model_rf.predict(X_test.iloc[:, selected_features_rf]) # 使用训练好的模型对筛选后的测试数据进行预测
# 记录结束时间，计算整个训练和预测过程的耗时
end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
# 打印模型在测试集上的分类报告，展示模型的性能
# 分类报告包括精确率、召回率、F1分数等指标，帮助评估模型好坏
print("\n随机森林自带的重要性筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_rf))
# 打印混淆矩阵，展示模型预测的详细结果
# 混淆矩阵显示了真实标签和预测标签的对应情况，比如多少样本被正确分类，多少被错分
print("随机森林自带的重要性筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_rf))
print("--- SHAP重要性筛选 ---")
import shap # SHAP是一种解释机器学习模型预测的方法，用于解释模型的输出
import time
# 记录开始时间，后面会计算整个过程耗时
start_time = time.time()
# 创建一个随机森林分类模型，用于解释
rf_model_shap = RandomForestClassifier(random_state=42) # 创建一个随机森林分类模型，用于解释
rf_model_shap.fit(X_train, y_train) # 在训练数据上训练模型
# 使用SHAP解释器解释模型
explainer = shap.TreeExplainer(rf_model_shap) # 使用SHAP解释器解释模型
shap_values = explainer.shap_values(X_train) # 计算SHAP值
# 处理 shap_values 为列表的情况（分类问题）
if isinstance(shap_values, list):
# 对于二分类问题，通常取类别 1 的 SHAP 值
if len(shap_values) == 2:
shap_values = shap_values[1]
else:
# 多分类问题取平均值
shap_values = np.mean(shap_values, axis=0)
# 确保 shap_values 是二维数组
if shap_values.ndim == 3:
shap_values = shap_values.mean(axis=0)
# 计算每个特征的SHAP值绝对值的平均值作为重要性
feature_importance = np.abs(shap_values).mean(axis=0) # 计算每个特征的SHAP值绝对值的平均值作为重要性
# 获取选择的特征索引，确保为一维数组
selected_features_shap = np.argsort(feature_importance)[::-1][:10] # 获取选择的特征索引，选择前10个特征
# 打印选择的特征索引和对应的特征名称
print("选择的特征索引：", selected_features_shap) # 打印选择的特征索引
print("选择的特征名称：", X_train.columns[selected_features_shap]) # 打印选择的特征名称
# 创建一个随机森林分类模型，用于在筛选后的数据上进行训练和预测
# random_state=42是为了保证每次运行结果一致，方便教学和对比
rf_model_shap = RandomForestClassifier(random_state=42)
# 在筛选后的训练数据上训练模型
# X_train_shap是筛选后的特征数据，y_train是对应的目标标签
rf_model_shap.fit(X_train.iloc[:, selected_features_shap], y_train) # 在筛选后的训练数据上训练模型
# 使用训练好的模型对筛选后的测试数据进行预测
# X_test_shap是筛选后的测试特征数据，rf_pred_shap是预测结果
rf_pred_shap = rf_model_shap.predict(X_test.iloc[:, selected_features_shap]) # 使用训练好的模型对筛选后的测试数据进行预测
# 记录结束时间，计算整个训练和预测过程的耗时
end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
# 打印模型在测试集上的分类报告，展示模型的性能
# 分类报告包括精确率、召回率、F1分数等指标，帮助评估模型好坏
print("\nSHAP重要性筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_shap))
# 打印混淆矩阵，展示模型预测的详细结果
# 混淆矩阵显示了真实标签和预测标签的对应情况，比如多少样本被正确分类，多少被错分
print("SHAP重要性筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_shap))
print("--- 递归特征消除 (RFE) ---")
from sklearn.feature_selection import RFE # RFE是一种递归特征消除方法，用于选择特征
import time
# 记录开始时间，后面会计算整个过程耗时
start_time = time.time()
# 创建一个随机森林分类模型，用于解释
rf_selector = RandomForestClassifier(random_state=42) # 创建一个随机森林分类模型，用于解释
# 使用RFE选择特征，n_features_to_select=10表示选择10个特征
rfe = RFE(rf_selector, n_features_to_select=10) # 使用RFE选择特征，n_features_to_select=10表示选择10个特征
rfe.fit(X_train, y_train) # 在训练数据上训练模型
# 获取选择的特征索引，get_support()返回一个布尔值列表，表示哪些特征被选择
selected_features_rfe = rfe.get_support(indices=True) # 获取选择的特征索引，get_support()返回一个布尔值列表，表示哪些特征被选择
# 打印选择的特征索引和对应的特征名称
print("选择的特征索引：", selected_features_rfe) # 打印选择的特征索引
print("选择的特征名称：", X_train.columns[selected_features_rfe]) # 打印选择的特征名称
# 创建一个随机森林分类模型，用于在筛选后的数据上进行训练和预测
# random_state=42是为了保证每次运行结果一致，方便教学和对比
rf_model_rfe = RandomForestClassifier(random_state=42)
# 在筛选后的训练数据上训练模型
# X_train_rfe是筛选后的特征数据，y_train是对应的目标标签
rf_model_rfe.fit(X_train.iloc[:, selected_features_rfe], y_train) # 在筛选后的训练数据上训练模型
# 使用训练好的模型对筛选后的测试数据进行预测
# X_test_rfe是筛选后的测试特征数据，rf_pred_rfe是预测结果
rf_pred_rfe = rf_model_rfe.predict(X_test.iloc[:, selected_features_rfe]) # 使用训练好的模型对筛选后的测试数据进行预测
# 记录结束时间，计算整个训练和预测过程的耗时
end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
# 打印模型在测试集上的分类报告，展示模型的性能
# 分类报告包括精确率、召回率、F1分数等指标，帮助评估模型好坏
print("\nRFE筛选后随机森林在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_rfe))
# 打印混淆矩阵，展示模型预测的详细结果
# 混淆矩阵显示了真实标签和预测标签的对应情况，比如多少样本被正确分类，多少被错分
print("RFE筛选后随机森林在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_rfe))
输出节选：
--- 默认参数的随机森林 ---
训练与预测耗时: 0.1399 秒
默认参数随机森林在测试集上的分类报告：
precision recall f1-score support
0 0.89 0.83 0.86 29
1 0.85 0.91 0.88 32
accuracy 0.87 61
macro avg 0.87 0.87 0.87 61
weighted avg 0.87 0.87 0.87 61
默认参数随机森林在测试集上的混淆矩阵：
[[24 5]
[ 3 29]]
--- 方差筛选 (Variance Threshold) ---
方差筛选后保留的特征数量: 15
保留的特征: ['age', 'sex', 'cp', 'trestbps', 'chol', 'fbs', 'restecg', 'thalach', 'exang', 'oldpeak', 'ca', 'thal', 'slope_0', 'slope_1', 'slope_2']
训练与预测耗时: 0.1251 秒
方差筛选后随机森林在测试集上的分类报告：
precision recall f1-score support
0 0.89 0.83 0.86 29
1 0.85 0.91 0.88 32
accuracy 0.87 61
macro avg 0.87 0.87 0.87 61
weighted avg 0.87 0.87 0.87 61
方差筛选后随机森林在测试集上的混淆矩阵：
[[24 5]
[ 3 29]]
--- 皮尔逊相关系数筛选 ---
选择的特征索引： [ 0 1 2 7 8 9 10 11 13 14]
选择的特征名称： Index(['age', 'sex', 'cp', 'thalach', 'exang', 'oldpeak', 'ca', 'thal',
'slope_1', 'slope_2'],
dtype='object')
训练与预测耗时: 0.1700 秒
皮尔逊相关系数筛选后随机森林在测试集上的分类报告：
precision recall f1-score support
0 0.83 0.83 0.83 29
1 0.84 0.84 0.84 32
accuracy 0.84 61
macro avg 0.84 0.84 0.84 61
weighted avg 0.84 0.84 0.84 61
皮尔逊相关系数筛选后随机森林在测试集上的混淆矩阵：
[[24 5]
[ 5 27]]
--- Lasso筛选 (L1正则化) ---
选择的特征索引： [ 0 1 2 3 4 6 7 8 9 10 11 13 14]
选择的特征名称： Index(['age', 'sex', 'cp', 'trestbps', 'chol', 'restecg', 'thalach', 'exang',
'oldpeak', 'ca', 'thal', 'slope_1', 'slope_2'],
dtype='object')
训练与预测耗时: 0.2422 秒
Lasso筛选后随机森林在测试集上的分类报告：
precision recall f1-score support
0 0.89 0.83 0.86 29
1 0.85 0.91 0.88 32
accuracy 0.87 61
macro avg 0.87 0.87 0.87 61
weighted avg 0.87 0.87 0.87 61
Lasso筛选后随机森林在测试集上的混淆矩阵：
[[24 5]
[ 3 29]]
--- 随机森林自带的重要性筛选 ---
选择的特征索引： [ 0 2 3 4 7 8 9 10 11]
选择的特征名称： Index(['age', 'cp', 'trestbps', 'chol', 'thalach', 'exang', 'oldpeak', 'ca',
'thal'],
dtype='object')
训练与预测耗时: 0.3874 秒
随机森林自带的重要性筛选后随机森林在测试集上的分类报告：
precision recall f1-score support
0 0.86 0.83 0.84 29
1 0.85 0.88 0.86 32
accuracy 0.85 61
macro avg 0.85 0.85 0.85 61
weighted avg 0.85 0.85 0.85 61
随机森林自带的重要性筛选后随机森林在测试集上的混淆矩阵：
[[24 5]
[ 4 28]]
--- SHAP重要性筛选 ---
选择的特征索引： [1 0]
选择的特征名称： Index(['sex', 'age'], dtype='object')
训练与预测耗时: 0.2908 秒
SHAP重要性筛选后随机森林在测试集上的分类报告：
precision recall f1-score support
0 0.61 0.66 0.63 29
1 0.67 0.62 0.65 32
accuracy 0.64 61
macro avg 0.64 0.64 0.64 61
weighted avg 0.64 0.64 0.64 61
SHAP重要性筛选后随机森林在测试集上的混淆矩阵：
[[19 10]
[12 20]]
--- 递归特征消除 (RFE) ---
选择的特征索引： [ 0 2 3 4 7 8 9 10 11 14]
选择的特征名称： Index(['age', 'cp', 'trestbps', 'chol', 'thalach', 'exang', 'oldpeak', 'ca',
'thal', 'slope_2'],
dtype='object')
训练与预测耗时: 0.5865 秒
RFE筛选后随机森林在测试集上的分类报告：
precision recall f1-score support
0 0.83 0.83 0.83 29
1 0.84 0.84 0.84 32
accuracy 0.84 61
macro avg 0.84 0.84 0.84 61
weighted avg 0.84 0.84 0.84 61
RFE筛选后随机森林在测试集上的混淆矩阵：
[[24 5]
[ 5 27]]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
