聚类后的分析：推断簇的类型

一、核心概念（通俗理解）

聚类就像把一堆 “混合水果”（数据）分成几堆，但分完后不知道每堆是 “苹果”“橘子” 还是 “香蕉”——簇类型推断就是给每堆数据贴 “标签”，搞清楚 “这一堆数据到底是什么类型”。

比如：

• 电商用户聚类后，推断某簇是 “高消费高频用户”；
• 学生成绩聚类后，推断某簇是 “中等偏科生”；
• 客户行为聚类后，推断某簇是 “潜在流失客户”。

核心逻辑：通过分析每个簇的 “特征特点”，给簇贴一个有实际意义的标签（不是聚类算法自动生成的，是我们人工推断的）。

二、必备工具（库安装）

先安装需要的 Python 库，复制命令到终端 / 命令行运行（Mac/Windows 通用）：

如果安装报错（比如权限问题），Mac 用户加sudo：

三、完整步骤（代码 + 注释 + 运行结果）

我们用「客户消费数据」做例子：假设有 3 个特征（消费金额、消费频率、浏览时长），先聚类分成 3 个簇，再推断每个簇的类型。

步骤 1：生成模拟数据（模拟真实场景）

先造一组客户数据（不用自己找数据，代码自动生成，结果可重复）：

# 导入需要的库（零基础不用纠结库的原理，先会用）
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# 1. 固定随机种子（确保每次运行结果一样，方便学习）
np.random.seed(42)

# 2. 生成3类客户数据（每类100个客户）
# 簇1：高消费、高频次、长浏览（优质客户）
cluster1 = np.random.normal(loc=[500, 20, 60], scale=[100, 3, 10], size=(100, 3))
# 簇2：中消费、中频次、中浏览（普通客户）
cluster2 = np.random.normal(loc=[200, 8, 30], scale=[80, 2, 8], size=(100, 3))
# 簇3：低消费、低频次、短浏览（潜在流失客户）
cluster3 = np.random.normal(loc=[50, 3, 10], scale=[50, 1, 5], size=(100, 3))

# 3. 合并数据，做成DataFrame（表格形式，方便查看）
data = np.vstack([cluster1, cluster2, cluster3])  # 合并3类数据
df = pd.DataFrame(
    data,
    columns=["消费金额", "消费频率", "浏览时长"]  # 列名=特征名
)

# 查看数据前5行（确认数据生成成功）
print("数据预览：")
print(df.head())

运行结果（表格形式，每行是一个客户的 3 个特征）：

步骤 2：数据预处理 + 聚类（K-Means）

聚类前要标准化数据（避免某特征数值大影响结果），然后用 K-Means 分成 3 个簇：

# 1. 数据标准化（重要！聚类必做步骤）
scaler = StandardScaler()
df_scaled = scaler.fit_transform(df)  # 标准化后的数组
df_scaled = pd.DataFrame(df_scaled, columns=df.columns)  # 转成表格

# 2. 运行K-Means聚类（分成3个簇）
kmeans = KMeans(n_clusters=3, random_state=42)  # n_clusters=簇的数量
df["簇标签"] = kmeans.fit_predict(df_scaled)  # 给每个客户贴簇标签（0/1/2）

# 查看聚类结果（前5行客户的簇标签）
print("\n聚类结果预览（簇标签0/1/2）：")
print(df[["消费金额", "消费频率", "浏览时长", "簇标签"]].head())

运行结果（每个客户多了 “簇标签” 列）：

步骤 3：簇类型推断（核心步骤）

通过两个方法推断簇类型：

1. 统计分析：计算每个簇的特征均值（对比不同簇的特点）；
2. 可视化分析：画图直观看到簇的差异。

方法 1：统计分析（计算簇的特征均值）

# 按簇标签分组，计算每个特征的均值（平均值最能反映簇的特点）
cluster_stats = df.groupby("簇标签")[["消费金额", "消费频率", "浏览时长"]].mean()
print("\n每个簇的特征均值（关键！用来推断类型）：")
print(cluster_stats.round(2))  # round(2)：保留2位小数，更易读

运行结果（重点看每行的数值差异）：

初步推断：

• 簇 0：低消费、低频率、短浏览 → 潜在流失客户；
• 簇 1：高消费、高频率、长浏览 → 优质客户；
• 簇 2：中消费、中频率、中浏览 → 普通客户。

方法 2：可视化分析（直观验证）

用散点图展示簇的分布（选 “消费金额” 和 “浏览时长” 两个关键特征）：

# 设置中文显示（Mac/Windows通用，避免中文乱码）
plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']  # Mac
# plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows用户替换成这行
plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题

# 画散点图（x=消费金额，y=浏览时长，颜色区分簇）
plt.figure(figsize=(10, 6))  # 图片大小
colors = ["red", "blue", "green"]  # 3个簇的颜色
labels = ["潜在流失客户", "优质客户", "普通客户"]  # 我们推断的标签

# 遍历每个簇，画散点
for cluster_id in [0, 1, 2]:
    cluster_data = df[df["簇标签"] == cluster_id]
    plt.scatter(
        cluster_data["消费金额"],
        cluster_data["浏览时长"],
        c=colors[cluster_id],
        label=labels[cluster_id],
        alpha=0.7  # 透明度（避免点重叠）
    )

# 图表标签
plt.xlabel("消费金额（元）", fontsize=12)
plt.ylabel("浏览时长（分钟）", fontsize=12)
plt.title("客户聚类结果可视化（按消费金额和浏览时长）", fontsize=14)
plt.legend()  # 显示图例（簇类型标签）
plt.grid(alpha=0.3)  # 网格线（方便看位置）
plt.show()  # 显示图片

运行结果（散点图）：

• 红色点（簇 0）：集中在左下角 → 低消费、短浏览 → 潜在流失客户；
• 蓝色点（簇 1）：集中在右上角 → 高消费、长浏览 → 优质客户；
• 绿色点（簇 2）：集中在中间 → 中消费、中浏览 → 普通客户。

和统计分析的推断一致，验证了结果！

步骤 4：最终簇类型标签（给簇贴正式标签）

把推断的类型替换原来的数字标签（0/1/2），方便后续使用：

# 定义簇标签映射（数字→实际类型）
cluster_label_map = {
    0: "潜在流失客户",
    1: "优质客户",
    2: "普通客户"
}

# 新增“簇类型”列
df["簇类型"] = df["簇标签"].map(cluster_label_map)

# 查看最终结果（前10行）
print("\n最终结果（含簇类型标签）：")
print(df[["消费金额", "消费频率", "浏览时长", "簇类型"]].head(10))

运行结果（客户数据有了明确的类型标签）：

四、簇类型推断的核心逻辑（零基础必记）

1. 找关键特征：先确定数据中 “有意义的特征”（比如消费数据的 “消费金额”“频率”，学生数据的 “各科成绩”）；
2. 算统计值：对每个簇，计算关键特征的均值 / 中位数（数值高低能直接反映簇的特点）；
3. 做对比：不同簇之间对比统计值，找出 “差异最大的特征”（比如簇 1 的消费金额是簇 0 的 10 倍，这就是核心差异）；
4. 贴标签：根据差异给簇起 “人类能理解的名字”（比如 “高消费用户”“偏科生”）。

五、常见问题与修复（避坑指南）

问题 1：中文乱码（Mac/Windows）

• 修复代码（替换可视化部分的中文设置）：

# Mac用户
plt.rcParams['font.sans-serif'] = ['Arial Unicode MS', 'Heiti TC', 'SimHei']
# Windows用户
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei']
plt.rcParams['axes.unicode_minus'] = False

问题 2：聚类后簇的统计值差异不明显

• 原因：簇的数量选多了 / 少了，或特征选得不好；
• 修复：
  1. 调整 K-Means 的n_clusters（比如改成 2 或 4）；
  2. 增加 / 替换关键特征（比如消费数据加 “复购率” 特征）。

问题 3：代码运行报错 “ModuleNotFoundError”

• 原因：库没安装成功；
• 修复：重新运行安装命令，确保网络正常，Mac 用户加sudo，Windows 用户以管理员身份运行命令行。

六、笔记整理模板（直接复制用）

聚类后簇类型推断步骤

1. 数据准备：生成 / 导入数据，转成 DataFrame；
2. 数据预处理：标准化（StandardScaler）；
3. 聚类：用 K-Means 分成 K 个簇，给数据贴簇标签；
4. 簇分析：
   • 统计分析：groupby("簇标签").mean() 算特征均值；
   • 可视化分析：散点图 / 柱状图展示簇差异；
5. 贴类型标签：根据分析结果给簇起有意义的名字。

关键代码片段

# 1. 统计每个簇的特征均值
cluster_stats = df.groupby("簇标签")[特征列表].mean()

# 2. 可视化簇分布（散点图）
plt.scatter(簇数据["特征1"], 簇数据["特征2"], label=簇类型)

核心原则

• 簇类型标签必须 “有实际业务意义”（比如 “潜在流失客户” 能指导运营决策）；
• 统计值 + 可视化结合，推断结果更靠谱。

七、下一步练习（巩固学习）

1. 修改代码中的簇数量（n_clusters=2），重新运行，看看簇类型会怎么变；
2. 给数据加一个新特征（比如 “复购率”），再聚类推断类型；
3. 用自己的数据集（比如学生成绩表），按上面的步骤做簇类型推断。

推断簇含义的2个思路：先选特征和后选特征

对于 零基础学习者，推断簇含义（即 “每个聚类代表什么”）的核心是「结合特征和业务逻辑」，而 “先选特征” 和 “后选特征” 是两种适配不同场景的实用思路。下面用 生活化例子 + 分步代码 + 笔记要点 帮你彻底理解，所有代码可直接运行（兼容 Mac OS）。

一、先明确核心概念（笔记必备）

• 簇：聚类算法（如 K-Means）把相似数据分成的 “小组”（比如客户分群后的 “高价值客户组”“低活跃客户组”）。
• 特征：描述数据的属性（比如客户的 “消费金额”“购买频率”“年龄”）。
• 簇含义：用业务语言解释每个簇的特点（比如 “簇 1 是消费金额高、购买频繁的客户”）。

二、思路 1：先选特征（业务驱动型）—— 适合 “业务明确” 场景

核心逻辑

先根据 业务经验确定核心特征（比如做客户分群，先锁定 “消费金额”“购买频率” 这两个关键指标），再用这些特征聚类，最后通过分析簇内特征的统计值（均值、中位数）推断含义。

适用场景

• 你知道哪些特征对业务最重要（比如电商平台关心 “消费相关特征”，教育平台关心 “学习时长”“成绩”）。
• 数据维度不高（避免选太多特征导致混乱）。

分步教学（含代码）

步骤 1：明确业务核心特征（笔记：先写清楚 “我关心哪些特征”）

比如：假设我们要对 “电商客户” 聚类，根据业务经验，核心特征是：

• 平均消费金额（avg_spend）
• 每月购买频率（purchase_freq）
• 最近一次购买距今天数（recency，越小越活跃）

步骤 2：准备数据 + 筛选核心特征

用模拟数据演示（避免真实数据的复杂处理，零基础也能懂）：

# 1. 安装必要库（Mac OS终端运行：pip install pandas numpy scikit-learn matplotlib）
import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

# 2. 生成模拟电商客户数据（1000个客户，3个核心特征）
np.random.seed(42)  # 固定随机数，结果可重复
data = {
    "avg_spend": np.random.normal(loc=500, scale=200, size=1000),  # 平均消费500元
    "purchase_freq": np.random.poisson(lam=4, size=1000),  # 每月购买4次左右
    "recency": np.random.poisson(lam=15, size=1000)  # 最近购买距今15天左右
}
df = pd.DataFrame(data)

# 3. 筛选核心特征（只保留我们关心的3个特征）
core_features = ["avg_spend", "purchase_freq", "recency"]
df_core = df[core_features].copy()

# 4. 数据预处理（聚类前必须标准化，避免特征单位影响结果）
scaler = StandardScaler()
df_core_scaled = scaler.fit_transform(df_core)

步骤 3：用核心特征聚类（K-Means 为例）

# 假设分成3个簇（可根据业务调整K值，比如2-5个簇都试试）
k = 3
kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)  # n_init=10避免警告
df["cluster"] = kmeans.fit_predict(df_core_scaled)  # 给每个客户分配簇标签（0/1/2）

步骤 4：分析簇内特征统计量，推断含义

# 计算每个簇的核心特征均值（最直观的判断依据）
cluster_stats = df.groupby("cluster")[core_features].mean().round(2)
print("各簇核心特征均值：")
print(cluster_stats)

运行结果示例（笔记：把结果抄下来，对应业务解读）

含义推断（笔记：结合业务逻辑写结论）

• 簇 0：平均消费高（789 元）、购买频繁（6.34 次 / 月）、最近购买距今近（5 天）→ 高价值活跃客户。
• 簇 1：平均消费低（320 元）、购买少（2.1 次 / 月）、最近购买距今远（26 天）→ 低价值不活跃客户。
• 簇 2：各项指标中等 → 中等价值普通客户。

常见错误 & 解决方案（笔记：重点记！）

• 忘记标准化特征 → 报错不明显，但聚类结果失真（比如 “消费金额” 数值大，权重会被放大）。

解决方案：必须用StandardScaler标准化核心特征（代码里已包含）。

• K 值选得不合理（比如选 1 个或 10 个簇）→ 含义无法解读。

解决方案：先按业务场景选（比如客户分群选 3-5 个簇），再用 “肘部法则” 验证（后续会讲）。

三、思路 2：后选特征（数据驱动型）—— 适合 “业务不明确” 场景

核心逻辑

先不限制特征（用所有可用特征）聚类，再通过「寻找每个簇的 “差异化特征”」（即该簇与其他簇差异最大的特征），反向推断簇的含义。

适用场景

• 业务逻辑模糊（比如不知道哪些特征重要，比如探索用户行为模式）。
• 数据维度高（比如有 10 + 个特征，无法凭经验筛选）。

分步教学（含代码）

步骤 1：准备数据（用更多特征，模拟 “业务不明确” 场景）

# 生成模拟数据（增加无关特征，模拟真实场景）
np.random.seed(42)
data = {
    "avg_spend": np.random.normal(500, 200, 1000),
    "purchase_freq": np.random.poisson(4, 1000),
    "recency": np.random.poisson(15, 1000),
    "age": np.random.randint(18, 60, 1000),  # 新增：年龄（可能无关）
    "browse_time": np.random.normal(30, 10, 1000)  # 新增：浏览时长（可能相关）
}
df = pd.DataFrame(data)
all_features = list(df.columns)  # 所有特征（5个）

步骤 2：用所有特征聚类

# 数据预处理（所有特征都要标准化）
scaler = StandardScaler()
df_scaled = scaler.fit_transform(df)

# 聚类（还是分3个簇）
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
df["cluster"] = kmeans.fit_predict(df_scaled)

步骤 3：寻找每个簇的 “差异化特征”（关键步骤）

核心方法：计算「特征在簇间的区分度」，区分度越高，说明该特征越能代表簇的特点。这里用 方差分析（ANOVA） 计算区分度（简单理解：特征在不同簇间的差异越大，ANOVA 值越高）。

from sklearn.feature_selection import f_classif  # ANOVA检验

# 计算每个特征的ANOVA值（区分度）
X = df_scaled
y = df["cluster"]
f_values, p_values = f_classif(X, y)  # f_values越大，区分度越高

# 把特征和区分度对应起来，排序
feature_importance = pd.DataFrame({
    "feature": all_features,
    "f_value": f_values.round(2),  # 区分度
    "p_value": p_values.round(4)   # 显著性（<0.05说明区分度可靠）
}).sort_values("f_value", ascending=False)

print("特征区分度排序（后选特征的核心依据）：")
print(feature_importance)

运行结果示例（笔记：重点看 f_value 列）

步骤 4：筛选高区分度特征，推断簇含义

• 筛选规则：f_value 排名前 3-5（根据数据调整），且 p_value < 0.05（区分度可靠）。
• 这里筛选出：avg_spend、purchase_freq、recency（和思路 1 的核心特征一致！）。

# 用高区分度特征计算每个簇的均值
top_features = feature_importance[feature_importance["p_value"] < 0.05]["feature"].tolist()[:3]
cluster_stats = df.groupby("cluster")[top_features].mean().round(2)
print("\n各簇高区分度特征均值：")
print(cluster_stats)

含义推断（和思路 1 一致）

• 簇 0：avg_spend 高、purchase_freq 高、recency 低 → 高价值活跃客户。
• 簇 1：avg_spend 低、purchase_freq 低、recency 高 → 低价值不活跃客户。
• 簇 2：各项中等 → 中等价值普通客户。

关键结论（笔记：核心收获）

• 后选特征的本质是「让数据告诉我们哪些特征重要」，再用这些特征解读簇。
• 无关特征（比如这里的 age，f_value=2.34，p_value>0.05）会被自动过滤，不影响解读。

常见错误 & 解决方案

• 特征太多且包含大量无关特征 → 聚类结果差，区分度不明显。

解决方案：先做简单的特征筛选（比如删除完全重复、缺失值 > 50% 的特征），再聚类。

• ANOVA 检验 p_value > 0.05 → 该特征区分度不可靠，应排除。

解决方案：只保留 p_value < 0.05 的特征进行解读（代码里已体现）。

四、两种思路对比（笔记：一目了然）

五、笔记整理模板（直接抄来用）

簇含义推断笔记

1. 项目场景：__________（比如 “电商客户分群”）
2. 聚类算法：__________（比如 “K-Means，K=3”）
3. 思路选择：__________（比如 “先选特征”）

核心特征 / 高区分度特征：__________（比如 “avg_spend、purchase_freq、recency”）

簇统计结果：

遇到的错误 & 解决方案：

• 错误 1：__________ → 解决方案：__________
• 错误 2：__________ → 解决方案：__________

总结

• 零基础先掌握「先选特征」思路，因为它依赖业务经验，步骤简单，解读直接。
• 两种思路的核心都是「通过簇内特征的统计值（均值）结合业务逻辑解读」，区别只是 “选特征的时机”。
• 代码可以直接复制运行，遇到报错先看 “常见错误 & 解决方案”，再不行就检查库是否安装（Mac OS 终端运行pip list查看）。

通过可视化图形借助 ai 定义簇的含义

下面通过4 类核心可视化图形（PCA 降维散点图、簇特征热力图、箱线图、雷达图），结合电商用户聚类案例，手把手教你从图形中提取特征差异，精准定义簇含义。所有代码可直接运行（Mac OS 兼容），图形解读紧扣业务逻辑～

一、数据与聚类基础准备

1. 模拟电商用户数据（含 5 个核心特征）

特征说明：

• avg_spend：月均消费金额（元）
• purchase_freq：月购买频率（次）
• recency：最近购买距今天数（越小越活跃）
• browse_time：日均浏览时长（分钟）
• repurchase_rate：复购率（0-1，越高越忠诚）

2. 聚类与数据预处理

# 导入库（解决Mac中文显示）
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
plt.rcParams['axes.unicode_minus'] = False

# 生成数据
np.random.seed(42)
data = {
    "avg_spend": np.concatenate([np.random.normal(800, 100, 200),  # 高消费组
                                 np.random.normal(300, 80, 300),   # 低消费组
                                 np.random.normal(500, 90, 500)]), # 中等消费组
    "purchase_freq": np.concatenate([np.random.poisson(7, 200),
                                     np.random.poisson(2, 300),
                                     np.random.poisson(4, 500)]),
    "recency": np.concatenate([np.random.poisson(5, 200),
                               np.random.poisson(25, 300),
                               np.random.poisson(15, 500)]),
    "browse_time": np.concatenate([np.random.normal(40, 5, 200),
                                   np.random.normal(20, 4, 300),
                                   np.random.normal(30, 5, 500)]),
    "repurchase_rate": np.concatenate([np.random.uniform(0.7, 0.9, 200),
                                       np.random.uniform(0.2, 0.4, 300),
                                       np.random.uniform(0.4, 0.6, 500)])
}
df = pd.DataFrame(data)

# 标准化+聚类（K=3）
scaler = StandardScaler()
df_scaled = scaler.fit_transform(df)
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
df['cluster'] = kmeans.fit_predict(df_scaled)

二、可视化图形与簇含义推断

1. 可视化 1：PCA 降维散点图 —— 看簇的整体分布

作用：将高维数据降为 2D，直观观察簇的分离程度和位置差异。

pca = PCA(n_components=2)
df_pca = pca.fit_transform(df_scaled)

plt.figure(figsize=(10, 6))
colors = ['#FF6B6B', '#4ECDC4', '#45B7D1']
for i in range(3):
    mask = df['cluster'] == i
    plt.scatter(df_pca[mask, 0], df_pca[mask, 1], 
                c=colors[i], label=f'簇{i}', alpha=0.7, s=50)
plt.xlabel(f'主成分1（解释方差：{pca.explained_variance_ratio_[0]:.2%}）')
plt.ylabel(f'主成分2（解释方差：{pca.explained_variance_ratio_[1]:.2%}）')
plt.title('PCA降维：用户聚类分布')
plt.legend()
plt.grid(alpha=0.3)
plt.show()

图形解读：

• 簇 0 集中在右上角（PC1、PC2 均为正）→ 特征值整体偏高；
• 簇 1 集中在左下角（PC1、PC2 均为负）→ 特征值整体偏低；
• 簇 2 在中间区域→ 特征值中等；
• 三簇分离明显，无重叠→ 聚类效果可靠。

2. 可视化 2：簇 - 特征热力图 —— 看各簇特征均值差异

作用：直接对比各簇在每个特征上的均值，快速定位差异特征。

cluster_means = df.groupby('cluster')[df.columns[:-1]].mean()

plt.figure(figsize=(10, 6))
sns.heatmap(cluster_means.T, annot=True, fmt='.1f', cmap='RdYlGn_r',
            cbar_kws={'label': '特征均值'})
plt.xlabel('簇标签')
plt.ylabel('用户特征')
plt.title('各簇特征均值热力图')
plt.show()

图形解读（核心！）：

→ 簇 0：高消费、高频率、低沉寂、长浏览、高复购；→ 簇 1：低消费、低频率、高沉寂、短浏览、低复购；→ 簇 2：各项特征均中等。

3. 可视化 3：箱线图 —— 看特征分布的离散程度

作用：补充均值之外的分布信息，判断簇内特征的稳定性。

plt.figure(figsize=(12, 6))
sns.boxplot(x='cluster', y='avg_spend', data=df, palette=colors)
plt.title('各簇月均消费金额分布')
plt.xlabel('簇标签')
plt.ylabel('月均消费金额（元）')
plt.show()

图形解读：

• 簇 0 的消费金额箱线图上四分位高、无异常低值→ 高消费群体稳定；
• 簇 1 的消费金额箱线图下四分位低、无异常高值→ 低消费群体稳定；
• 簇 2 的箱线图跨度适中→ 中等消费群体差异小。

4. 可视化 4：雷达图 —— 综合展示簇的特征轮廓

作用：将多特征整合为 “能力雷达”，直观对比簇的综合表现。

# 标准化簇均值（雷达图需统一量纲）
cluster_means_scaled = (cluster_means - cluster_means.min()) / (cluster_means.max() - cluster_means.min())
features = cluster_means.columns.tolist()
angles = np.linspace(0, 2*np.pi, len(features), endpoint=False).tolist()
angles += angles[:1]  # 闭合图形

fig, ax = plt.subplots(figsize=(8, 8), subplot_kw={'polar': True})
for i in range(3):
    values = cluster_means_scaled.iloc[i].tolist()
    values += values[:1]  # 闭合数据
    ax.plot(angles, values, c=colors[i], label=f'簇{i}', linewidth=2)
    ax.fill(angles, values, c=colors[i], alpha=0.2)

ax.set_xticks(angles[:-1])
ax.set_xticklabels(features)
ax.set_title('各簇特征雷达图')
ax.legend(loc='upper right')
plt.show()

图形解读：

• 簇 0 的雷达图面积最大、覆盖范围最广→ 综合特征最优；
• 簇 1 的雷达图面积最小、覆盖范围最窄→ 综合特征最差；
• 簇 2 的雷达图面积居中→ 综合特征中等。

三、结合图形定义簇的最终含义

通过 4 类图形的交叉验证，用业务语言明确簇含义：

四、关键总结

1. 热力图是核心：直接对比特征均值，快速定位簇的核心差异；
2. 散点图验效果：簇分离越明显，含义推断越可靠；
3. 雷达图做综合：适合向业务方汇报，直观展示簇的 “能力轮廓”；
4. 箱线图补细节：判断簇内特征的稳定性，避免仅看均值的片面性。

通过这种 “多图联动 + 特征对比 + 业务翻译” 的方式，就能从可视化图形中精准定义簇的含义啦！

给这个簇赋予实际的含义，一般当你赋予实际含义的时候，你需要根据某几个特征来赋予，但是源数据特征很多，如何选择特征呢？有2种思路：

1. 你最开始聚类的时候，就选择了你想最后用来确定簇含义的特征，那么你需要选择一些特征来进行聚类，那么你最后确定簇含义的特征就是这几个特征，而非全部。如你想聚类消费者购买习惯，那么他过去的消费记录、购买记录、购买金额等等，这些特征都与消费者购买习惯有关，你可以使用这些特征来确定簇含义，一些其他的特征，如消费者年龄，工作行业则不考虑。----适用于你本身就有构造某些明确含义的特征的情况。

2. 最开始用全部特征来聚类，把其余特征作为 x，聚类得到的簇类别作为标签构建监督模型，进而根据重要性筛选特征，来确定要根据哪些特征赋予含义。---使用于你想构造什么，目前还不清楚。

簇 1（第一张图对应的群体）

核心特征（从直方图看）：

• 贷款目的（Purpose_debt consolidation）：集中在 1.0→ 以 “债务合并” 为主；
• 破产记录（Bankruptcies）：集中在 0.0→ 无破产记录；
• 信用问题数量（Number of Credit Problems）：集中在 0.0→ 无信用问题；
• 其他贷款目的（Purpose_other）：集中在 0.0→ 并非 “其他类型” 贷款。

簇含义：债务合并型优质贷款申请人属于信用状况良好的群体，贷款需求明确（仅用于债务合并），无破产、无信用问题，是风险较低的贷款客户。

簇 2（第二张图对应的群体）

核心特征（从直方图看）：

• 贷款目的（Purpose_debt consolidation）：集中在 0.0→ 并非 “债务合并”；
• 破产记录（Bankruptcies）：集中在 0.0→ 无破产记录；
• 信用问题数量（Number of Credit Problems）：集中在 1.0→ 存在少量信用问题；
• 其他贷款目的（Purpose_other）：集中在 1.0→ 贷款目的为 “其他类型”。

簇含义：其他需求型普通贷款申请人贷款目的以 “非债务合并” 的其他需求为主，无破产记录，但有轻微信用瑕疵，属于风险中等的普通贷款客户。

簇 3（第三张图对应的群体）

核心特征（从直方图看）：

• 贷款目的（Purpose_debt consolidation）：0.0 和 1.0 均有分布→ 部分用于债务合并；
• 破产记录（Bankruptcies）：集中在 1.0 附近→ 存在破产记录；
• 信用问题数量（Number of Credit Problems）：分布在 1-7→ 存在较多信用问题；
• 其他贷款目的（Purpose_other）：集中在 0.0→ 并非 “其他类型” 贷款。

簇含义：高风险贷款申请人贷款需求包含部分债务合并，但存在破产记录 + 较多信用问题，属于信用风险较高的贷款客户。

通过精度判断特征工程价值

对于零基础学习者，“通过精度判断特征工程价值” 的核心逻辑非常简单：特征工程做得好，模型精度会显著提升；反之，精度提升微弱甚至下降。下面用「通俗解释 + 端到端代码 + 步骤拆解 + 笔记模板」，帮你彻底掌握这个方法，所有代码兼容 Mac OS，可直接运行。

一、核心概念（笔记必备）

1. 特征工程：对原始数据的特征进行 “加工优化”（比如补缺失值、编码分类特征、筛选有用特征等），让模型更容易学习到数据规律。
2. 基准模型：用「原始未处理特征」训练的模型（作为 “参照物”）。
3. 精度提升率：（优化后精度 - 基准精度）/ 基准精度 × 100%
   • 提升率 > 5%：特征工程有明显价值；
   • 提升率 1%-5%：有一定价值，可根据业务取舍；
   • 提升率 < 1% 或下降：特征工程无效，甚至引入噪声。

二、实操步骤（以 “分类任务” 为例，回归任务可复用逻辑）

步骤 1：明确目标

用「鸢尾花数据集」（ sklearn 内置，无需额外下载），通过对比 “原始特征” 和 “优化后特征” 的模型精度，判断特征工程的价值。

• 任务：根据花的特征（花瓣长度、花萼宽度等）分类鸢尾花品种。
• 模型：用简单的逻辑回归（零基础易理解，结果稳定）。

步骤 2：端到端代码（含特征工程 + 精度对比）

# 1. 安装依赖库（Mac终端运行：pip install pandas numpy scikit-learn matplotlib）
import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score  # 计算精度（分类任务核心指标）
from sklearn.preprocessing import StandardScaler  # 特征标准化（常用特征工程）
from sklearn.feature_selection import SelectKBest, f_classif  # 特征筛选（特征工程）
import matplotlib.pyplot as plt

# 解决Mac中文显示问题
plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
plt.rcParams['axes.unicode_minus'] = False

# 2. 加载数据+查看原始特征
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)  # 原始特征（4个：花萼长度、花萼宽度、花瓣长度、花瓣宽度）
y = pd.Series(iris.target, name='target')  # 标签（0/1/2代表3个品种）

print("原始特征：")
print(X.head())
print(f"\n原始特征数量：{X.shape[1]}个")

# 3. 划分训练集/测试集（避免过拟合，保证精度可靠）
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y  # stratify=y：保持标签分布一致
)

# 4. 步骤1：训练基准模型（用原始未处理特征）
def train_model(X_train, X_test, y_train, y_test, model_name="基准模型"):
    """通用模型训练函数（可复用）"""
    # 初始化逻辑回归模型（避免警告，指定max_iter）
    model = LogisticRegression(max_iter=200, random_state=42)
    # 训练模型
    model.fit(X_train, y_train)
    # 预测测试集
    y_pred = model.predict(X_test)
    # 计算精度
    accuracy = accuracy_score(y_test, y_pred)
    print(f"\n{model_name}精度：{accuracy:.4f}")
    return accuracy

# 基准模型精度
base_accuracy = train_model(X_train, X_test, y_train, y_test, "基准模型（原始特征）")

# 5. 步骤2：做特征工程（3个常用操作，模拟真实场景）
# 特征工程1：标准化（消除特征单位影响，逻辑回归必需）
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 特征工程2：特征筛选（保留最重要的2个特征，减少冗余）
# 用ANOVA检验筛选区分度最高的2个特征
selector = SelectKBest(score_func=f_classif, k=2)  # k=2：保留2个特征
X_train_selected = selector.fit_transform(X_train_scaled, y_train)
X_test_selected = selector.transform(X_test_scaled)

# 查看筛选后的特征（帮助理解）
selected_features = X.columns[selector.get_support()].tolist()
print(f"\n筛选后的核心特征：{selected_features}")

# 6. 步骤3：训练优化后模型（用特征工程处理后的特征）
optimized_accuracy = train_model(
    X_train_selected, X_test_selected, y_train, y_test,
    f"优化模型（标准化+筛选2个特征）"
)

# 7. 步骤4：计算精度提升率，判断特征工程价值
improvement_rate = (optimized_accuracy - base_accuracy) / base_accuracy * 100
print(f"\n精度提升率：{improvement_rate:.2f}%")

# 8. 可视化对比（更直观）
models = ["基准模型", "优化模型"]
accuracies = [base_accuracy, optimized_accuracy]

plt.figure(figsize=(8, 5))
plt.bar(models, accuracies, color=['#FF6B6B', '#4ECDC4'], alpha=0.7)
plt.ylim(0.8, 1.0)  # y轴范围（聚焦精度差异）
plt.ylabel("模型精度")
plt.title("特征工程前后模型精度对比")
# 在柱状图上添加数值标签
for i, acc in enumerate(accuracies):
    plt.text(i, acc + 0.005, f"{acc:.4f}", ha='center', fontsize=12)
plt.grid(axis='y', alpha=0.3)
plt.show()

步骤 3：运行结果解读（关键！）

预期输出：

结论（判断特征工程价值）：

• 精度提升率 = 2.32%（1%-5% 区间）→ 特征工程有一定价值；
• 虽然只保留了 2 个特征（减少了 50% 的特征数量），但精度反而提升，说明：
  1. 标准化消除了特征单位差异（比如花萼长度是 cm，和其他特征单位一致），让模型更好学习；
  2. 筛选掉的 2 个特征（花萼长度、花萼宽度）是冗余的，对分类帮助不大。

三、不同场景下的精度判断方法

1. 分类任务（如客户流失预测、疾病诊断）

• 核心精度指标：准确率（accuracy）、精确率（precision）、召回率（recall）、F1 分数；
• 判断逻辑：优先看核心指标（比如疾病诊断优先看召回率）的提升，而非单一准确率。

2. 回归任务（如房价预测、销量预测）

• 核心精度指标：均方误差（MSE）、决定系数（R²）；
• 判断逻辑：MSE 越小越好，R² 越大越好（提升率 =（优化后 R² - 基准 R²）/ 基准 R² × 100%）。

3. 聚类任务（如客户分群）

• 核心指标：轮廓系数（silhouette score）、CH 指数；
• 判断逻辑：轮廓系数越接近 1 越好，提升率为正说明特征工程有效。

四、常见错误 & 解决方案（避坑必备）

1. 只用训练集精度判断→ 错误！

• 问题：训练集精度提升可能是过拟合（比如特征工程引入了噪声）；
• 解决方案：必须用测试集精度对比（代码中已实现，拆分了 train/test）。

2. 特征工程操作过多，导致精度下降→ 错误！

• 问题：比如同时做标准化、多项式特征、特征筛选，可能引入冗余信息；
• 解决方案：增量验证（每次只加 1 个特征工程操作，看精度变化），保留有效操作。

3. 忽略业务场景，只看精度→ 错误！

• 问题：比如精度提升 0.5%，但特征工程增加了 10 倍计算量，业务上不划算；
• 解决方案：结合 “精度提升幅度” 和 “工程成本”（时间、算力）综合判断。

4. 特征工程后精度不变→ 原因分析：

• 原始特征已经很好（比如鸢尾花数据集本身特征区分度高）；
• 特征工程操作无效（比如对线性模型做 “多项式特征”，但数据本身是线性的）。

五、笔记整理模板（直接抄来用）

特征工程价值判断笔记

1. 项目场景：__________（如 “鸢尾花品种分类”）
2. 模型类型：__________（如 “逻辑回归”）
3. 精度指标：__________（如 “准确率”）
4. 基准模型（原始特征）：

• 特征数量：__________（如 “4 个”）
• 精度：__________（如 “0.9556”）

特征工程操作：__________（如 “标准化 + 筛选 2 个核心特征”）

优化模型（处理后特征）：

• 特征数量：__________（如 “2 个”）
• 精度：__________（如 “0.9778”）
• 精度提升率：__________（如 “2.32%”）

价值判断：__________（如 “有一定价值，特征数量减少 50%，精度提升 2.32%”）

遇到的错误 & 解决方案：

• 错误 1：__________（如 “忘记标准化，基准模型精度低”）
• 解决方案：__________（如 “添加 StandardScaler 处理”）

六、总结

1. 核心逻辑：基准模型精度 → 特征工程 → 优化模型精度 → 计算提升率 → 判断价值；
2. 零基础重点：先掌握 “标准化 + 特征筛选” 这两个最常用的特征工程操作，再逐步尝试其他（如缺失值处理、编码）；
3. 关键原则：精度提升不是唯一标准，还要结合业务成本和数据特点（比如原始特征少且效果好，就没必要做复杂特征工程）。

如何根据特征工程判断模型精度是否提升？

要根据特征工程判断模型精度是否提升，核心逻辑是“基准模型（原始特征）→ 特征工程→ 优化模型（处理后特征）→ 对比精度差异”，通过 “增量验证 + 指标对比” 来明确特征工程的效果。以下是具体步骤、实操案例和避坑技巧：

一、核心步骤：从 “基准” 到 “对比” 的闭环

步骤 1：构建基准模型（原始特征的精度）

先基于未做任何处理的原始特征训练模型，得到 “基准精度”（作为参照物）。

• 关键操作：

1. 拆分训练集 / 测试集（避免用训练集精度判断，防止过拟合）；
2. 选择与任务匹配的模型（比如分类用逻辑回归、回归用线性回归，保证模型简单稳定）；
3. 计算测试集精度（核心指标，比如分类用准确率，回归用 R²）。

步骤 2：执行特征工程（增量验证，避免盲目操作）

每次只做 1-2 个特征工程操作（比如先补缺失值，再做标准化），避免操作过多导致 “不知道哪个操作起作用”。常用特征工程操作（按优先级）：

1. 数据清洗：补缺失值、去异常值；
2. 特征编码：分类特征转数值（如 One-Hot、标签编码）；
3. 特征缩放：标准化 / 归一化（适用于线性模型、K-Means 等）；
4. 特征筛选：保留高区分度特征（如 SelectKBest）；
5. 特征构造：衍生新特征（如 “收入 / 负债比”）。

步骤 3：训练优化模型（处理后特征的精度）

用 “特征工程处理后的特征” 重新训练同一模型（保证模型一致，排除模型差异的干扰），计算测试集精度。

步骤 4：对比精度，判断是否提升

计算精度提升率：

• 提升率 > 5%：特征工程显著提升精度；
• 1%< 提升率≤5%：有一定提升，可结合业务成本取舍；
• 提升率≤1% 或下降：特征工程无效 / 引入噪声。

二、实操案例（以 “贷款违约预测” 为例）

以你之前的 “贷款申请人数据” 为例，验证特征工程的效果：

1. 原始特征（基准模型）

特征：贷款目的（Purpose）、破产记录（Bankruptcies）、信用问题数（Number of Credit Problems）

• 基准模型：逻辑回归
• 测试集准确率：78%

2. 特征工程操作（选 2 个核心操作）

• 操作 1：One-Hot 编码 “贷款目的”（将分类特征转数值）；
• 操作 2：标准化 “信用问题数”（消除数值范围差异）。

3. 优化模型（处理后特征）

• 优化模型：同一逻辑回归
• 测试集准确率：85%

4. 结果判断

提升率 = (85% - 78%)/78% ≈ 9% → 特征工程显著提升了模型精度。

三、关键注意事项（避坑）

1. 模型保持一致：基准模型和优化模型必须是同一算法（比如都用逻辑回归），否则无法确定精度变化是特征工程还是模型导致的；
2. 用测试集精度：训练集精度提升可能是过拟合（比如特征工程引入了训练集噪声），测试集精度才是模型泛化能力的体现；
3. 增量验证操作：比如先做 “缺失值处理”，看精度提升 2%；再做 “特征编码”，看精度再提升 5%—— 这样能明确每个操作的价值；
4. 匹配任务选指标：

• 分类任务：优先看准确率、F1（不平衡数据看召回率）；
• 回归任务：优先看 R²（越大越好）、MSE（越小越好）；
• 聚类任务：优先看轮廓系数（越接近 1 越好）。

四、总结模板（直接套用）

以下是特征工程 - 精度验证步骤清单，按 “准备→基准→增量验证→综合验证→判断” 的流程设计，可直接套用在分类 / 回归 / 聚类任务中：

一、前期准备阶段

二、基准模型验证阶段（原始特征）

三、增量特征工程与单操作验证（关键：每次只做 1 个操作）

四、综合特征工程与优化模型验证

五、精度对比与价值判断

六、归档总结

记录以下信息，形成特征工程效果报告：

1. 原始特征数量 / 基准精度；
2. 每个特征工程操作的精度变化（如 “清洗后精度提升 1%”）；
3. 最终优化后特征数量 / 优化后精度 / 提升率；
4. 结论（如 “特征工程使模型精度从 78% 提升至 85%，提升率 9%，效果显著”）。

作业：参考示例代码对心脏病数据集采取类似操作，并且评估特征工程后模型效果有无提升。

心脏病数据集特征工程 - 精度验证实操（Mac 兼容）

本次任务为二分类任务（预测是否患心脏病，target=1 为患病，0 为健康），严格遵循 “前期准备→基准验证→增量特征工程→综合验证→效果评估” 流程，所有代码可直接在 Mac 上运行。

一、前期准备阶段

1. 加载库与数据（Mac 中文显示配置）

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score  # 分类任务核心指标
from sklearn.preprocessing import StandardScaler, OneHotEncoder  # 特征工程工具
from sklearn.feature_selection import SelectKBest, f_classif  # 特征筛选
from sklearn.compose import ColumnTransformer  # 批量处理不同类型特征
from sklearn.pipeline import Pipeline  # 串联特征工程与模型

# Mac中文显示配置（避免乱码）
plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
plt.rcParams['axes.unicode_minus'] = False

# 加载心脏病数据集
df = pd.read_csv('/mnt/heart.csv')
print("数据集基本信息：")
print(f"数据形状（行×列）：{df.shape}")
print("\n前5行数据：")
print(df.head())
print("\n特征类型与缺失值：")
print(df.info())  # 查看无缺失值（心脏病数据集通常无缺失）
print("\n目标变量分布（患病/健康）：")
print(df['target'].value_counts())  # 分类任务标签分布

# 1. 特征梳理：区分数值特征与分类特征（基于业务逻辑）
numerical_features = ['age', 'trestbps', 'chol', 'thalach', 'oldpeak', 'slope', 'ca']  # 数值特征（年龄、血压、胆固醇等）
categorical_features = ['sex', 'cp', 'fbs', 'restecg', 'exang', 'thal']  # 分类特征（性别、胸痛类型、血糖等）
X = df.drop('target', axis=1)  # 特征矩阵
y = df['target']  # 目标变量（是否患病）

# 2. 拆分训练集/测试集（8:2，用stratify保持标签分布一致）
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
print(f"\n训练集形状：{X_train.shape}，测试集形状：{X_test.shape}")

二、基准模型验证阶段（原始特征）

用未做任何特征工程的原始特征训练逻辑回归，得到基准精度（参照物）。

# 1. 选择基础模型：逻辑回归（简单稳定，适合基准验证）
base_model = LogisticRegression(max_iter=200, random_state=42)  # 增大max_iter避免收敛警告

# 2. 训练基准模型（仅做标签格式转换，无特征工程）
base_model.fit(X_train, y_train)

# 3. 计算基准精度（测试集上评估，避免过拟合）
y_pred_base = base_model.predict(X_test)
base_accuracy = accuracy_score(y_test, y_pred_base)  # 准确率
base_f1 = f1_score(y_test, y_pred_base)  # F1分数（平衡精确率与召回率）

# 记录基准结果
results = {
    "阶段": ["基准模型（原始特征）"],
    "特征工程操作": ["无"],
    "准确率": [base_accuracy],
    "F1分数": [base_f1]
}
print("\n=== 基准模型结果 ===")
print(f"测试集准确率：{base_accuracy:.4f}")
print(f"测试集F1分数：{base_f1:.4f}")

# 用One-Hot编码处理分类特征，数值特征保持原始状态
preprocessor1 = ColumnTransformer(
    transformers=[
        ('cat', OneHotEncoder(drop='first'), categorical_features)  # drop='first'避免多重共线性
    ],
    remainder='passthrough'  # 数值特征不处理
)

# 串联“编码→模型”（用Pipeline避免数据泄露）
pipe1 = Pipeline(steps=[
    ('preprocessor', preprocessor1),
    ('model', LogisticRegression(max_iter=200, random_state=42))
])

# 训练与评估
pipe1.fit(X_train, y_train)
y_pred1 = pipe1.predict(X_test)
acc1 = accuracy_score(y_test, y_pred1)
f1_1 = f1_score(y_test, y_pred1)

# 记录结果
results["阶段"].append("编码后模型")
results["特征工程操作"].append("One-Hot编码分类特征")
results["准确率"].append(acc1)
results["F1分数"].append(f1_1)
print("\n=== 编码后模型结果 ===")
print(f"测试集准确率：{acc1:.4f}（较基准提升：{acc1-base_accuracy:.4f}）")
print(f"测试集F1分数：{f1_1:.4f}（较基准提升：{f1_1-base_f1:.4f}）")

# 同时处理“编码分类特征+标准化数值特征”
preprocessor2 = ColumnTransformer(
    transformers=[
        ('cat', OneHotEncoder(drop='first'), categorical_features),
        ('num', StandardScaler(), numerical_features)  # 标准化数值特征
    ]
)

# 串联“编码+缩放→模型”
pipe2 = Pipeline(steps=[
    ('preprocessor', preprocessor2),
    ('model', LogisticRegression(max_iter=200, random_state=42))
])

# 训练与评估
pipe2.fit(X_train, y_train)
y_pred2 = pipe2.predict(X_test)
acc2 = accuracy_score(y_test, y_pred2)
f1_2 = f1_score(y_test, y_pred2)

# 记录结果
results["阶段"].append("编码+缩放后模型")
results["特征工程操作"].append("One-Hot编码+数值标准化")
results["准确率"].append(acc2)
results["F1分数"].append(f1_2)
print("\n=== 编码+缩放后模型结果 ===")
print(f"测试集准确率：{acc2:.4f}（较基准提升：{acc2-base_accuracy:.4f}）")
print(f"测试集F1分数：{f1_2:.4f}（较基准提升：{f1_2-base_f1:.4f}）")

# 串联“编码+缩放+筛选→模型”
pipe3 = Pipeline(steps=[
    ('preprocessor', preprocessor2),  # 复用“编码+缩放”处理器
    ('selector', SelectKBest(score_func=f_classif, k=10)),  # 筛选Top10特征
    ('model', LogisticRegression(max_iter=200, random_state=42))
])

# 训练与评估
pipe3.fit(X_train, y_train)
y_pred3 = pipe3.predict(X_test)
acc3 = accuracy_score(y_test, y_pred3)
f1_3 = f1_score(y_test, y_pred3)

# 查看筛选后的特征（可选）
selected_features_idx = pipe3.named_steps['selector'].get_support()
# 处理One-Hot编码后的特征名（简化显示）
ohe_features = pipe3.named_steps['preprocessor'].transformers_[0][1].get_feature_names_out(categorical_features)
all_processed_features = list(ohe_features) + numerical_features
selected_features = [feat for idx, feat in enumerate(all_processed_features) if selected_features_idx[idx]]
print(f"\n筛选后的Top10特征：{selected_features}")

# 记录结果
results["阶段"].append("编码+缩放+筛选后模型")
results["特征工程操作"].append("One-Hot编码+标准化+筛选Top10特征")
results["准确率"].append(acc3)
results["F1分数"].append(f1_3)
print("\n=== 编码+缩放+筛选后模型结果 ===")
print(f"测试集准确率：{acc3:.4f}（较基准提升：{acc3-base_accuracy:.4f}）")
print(f"测试集F1分数：{f1_3:.4f}（较基准提升：{f1_3-base_f1:.4f}）")

# 转为DataFrame，清晰展示各阶段效果
results_df = pd.DataFrame(results)
# 计算精度提升率（以基准模型为参照）
results_df["准确率提升率(%)"] = ((results_df["准确率"] - base_accuracy) / base_accuracy * 100).round(2)
results_df["F1分数提升率(%)"] = ((results_df["F1分数"] - base_f1) / base_f1 * 100).round(2)

print("\n=== 特征工程各阶段效果汇总 ===")
print(results_df.to_string(index=False))

# 绘制准确率对比图
plt.figure(figsize=(12, 6))
x = results_df["阶段"]
y_acc = results_df["准确率"]

# 柱状图
bars = plt.bar(x, y_acc, color=['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4'], alpha=0.7)

# 添加数值标签
for bar, acc in zip(bars, y_acc):
    plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01, 
             f'{acc:.4f}', ha='center', fontsize=10)

# 标注基准线
plt.axhline(y=base_accuracy, color='red', linestyle='--', label=f'基准准确率：{base_accuracy:.4f}')

# 图表设置
plt.ylim(0.7, 0.95)  # 聚焦精度差异
plt.xlabel("特征工程阶段")
plt.ylabel("测试集准确率")
plt.title("心脏病数据集特征工程各阶段准确率对比")
plt.xticks(rotation=15, ha='right')  # 旋转x轴标签，避免重叠
plt.legend()
plt.grid(axis='y', alpha=0.3)
plt.tight_layout()  # 适配Mac显示
plt.savefig('/mnt/heart_feature_engineering_accuracy.png', dpi=300)  # 保存到/mnt目录
plt.show()