穿透黑盒模型的神秘面纱，掌握可解释AI的核心技术与实战方法

---

环境声明

• Python版本：Python 3.12+
• 核心依赖库：
  • shap >= 0.45.0
  • lime >= 0.2.0
  • interpret >= 0.6.0
  • scikit-learn >= 1.5.0
  • matplotlib >= 3.8
  • seaborn >= 0.13
• 开发工具：PyCharm / VS Code / Jupyter Notebook
• 操作系统：Windows / macOS / Linux（通用）

---

学习目标

完成本章学习后，你将能够：

1. 理解模型可解释性的重要性及不同应用场景的需求差异
2. 掌握模型内置可解释性方法（系数分析、特征重要性、注意力权重）
3. 深入理解LIME的局部近似原理与实现细节
4. 完整掌握SHAP值的博弈论基础、计算方法与可视化技巧
5. 运用置换重要性、PDP、ICE曲线进行全局特征分析
6. 理解因果推断的核心概念（do-calculus、因果图、工具变量）
7. 了解2024-2025年XAI领域的前沿进展（CAV、Integrated Gradients等）
8. 使用SHAP和LIME对复杂模型进行完整的解释分析

---

1. 可解释性重要性

1.1 为什么需要XAI

可解释人工智能（Explainable AI，XAI）旨在让AI模型的决策过程变得透明和易于理解。随着深度学习模型在医疗诊断、金融风控、自动驾驶等高风险领域的广泛应用，"黑盒"模型的不可解释性已成为制约其落地的关键瓶颈。

需要XAI的核心场景：

应用场景	解释需求	风险等级
医疗诊断	医生需要理解AI为何做出某诊断	极高
信贷审批	申请人有权知道被拒原因	高
司法判决辅助	法官需要可审计的决策依据	极高
自动驾驶	事故责任认定需要追溯决策链	极高
推荐系统	用户需要理解推荐逻辑	中
广告投放	优化师需要理解特征影响	中

补充：欧盟《通用数据保护条例》（GDPR）第22条规定，数据主体有权获得人工干预，并对自动化决策提出质疑，这被称为"解释权"。

1.2 可解释性vs性能权衡

传统观念认为，模型复杂度与可解释性存在此消彼长的关系：

可解释性 ↑                    性能 ↑
   │                            │
   │    线性回归                  │    深度神经网络
   │    决策树                    │    集成模型
   │    逻辑回归                  │    梯度提升树
   │                            │
   └────────────────────────────┘
              复杂度 →

2024-2025年研究进展表明：

• 可解释性技术（如SHAP、LIME）可以在不牺牲性能的情况下提供事后解释
• 可解释性本身可以提升模型鲁棒性，帮助发现数据泄露和伪相关
• 部分领域开始探索"可解释性优先"的模型设计范式

1.3 XAI的分类体系

根据解释时机和范围，XAI方法可分为：

分类维度	类型	说明	代表方法
解释时机	内在可解释性	模型结构本身可解释	线性模型、决策树
	事后解释性	对训练好的模型进行解释	SHAP、LIME
解释范围	全局解释	解释模型整体行为	特征重要性、PDP
	局部解释	解释单个预测	LIME、SHAP
解释对象	模型无关	适用于任何模型	SHAP、LIME
	模型特定	针对特定模型设计	注意力可视化

---

2. 模型内置可解释性

2.1 线性模型系数

线性模型是最具可解释性的机器学习模型之一。对于线性回归：

ŷ = β₀ + β₁x₁ + β₂x₂ + ... + βₙxₙ

系数解读：

• β₀：截距，所有特征为0时的预测值
• βᵢ：在其他特征不变的情况下，xᵢ每增加1单位，ŷ的变化量

标准化后的系数比较：

from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
import numpy as np

# 标准化特征后训练
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
model = LinearRegression()
model.fit(X_scaled, y)

# 标准化系数的绝对值反映特征重要性
feature_importance = np.abs(model.coef_)

2.2 决策树特征重要性

决策树提供两种特征重要性度量：

重要性类型	计算方式	特点
Gini重要性	基于节点不纯度减少	倾向于选择高基数特征
置换重要性	随机打乱特征值后性能下降	更可靠，计算成本高

from sklearn.tree import DecisionTreeClassifier

# 训练决策树
model = DecisionTreeClassifier(max_depth=5, random_state=42)
model.fit(X_train, y_train)

# 获取特征重要性
importances = model.feature_importances_

# 可视化决策树结构
from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

plt.figure(figsize=(20, 10))
plot_tree(model, feature_names=feature_names, filled=True, rounded=True)
plt.show()

2.3 注意力权重可视化

Transformer架构的自注意力机制天然具有可解释性：

Attention(Q, K, V) = softmax(QK^T / √dₖ) V

注意力权重矩阵A = softmax(QK^T / √dₖ) 表示每个token对其他token的关注程度。

可视化方法：

• 热力图展示token间的注意力分布
• 分析不同注意力头的专业化分工
• 追踪特定预测的关键注意力路径

---

3. LIME局部可解释模型

3.1 LIME核心思想

LIME（Local Interpretable Model-agnostic Explanations）由Ribeiro等人于2016年提出，其核心思想是：在待解释样本的邻域内，用一个简单的可解释模型（如线性模型）来近似复杂模型的行为。

比喻理解：
将复杂模型比作一座崎岖的山脉，LIME不是在全局范围内描述山脉形状，而是在你当前站立的位置（待解释样本）附近，用一个平面（简单模型）来近似描述地形。

3.2 LIME算法流程

LIME的工作流程可分为四个步骤：

1. 扰动采样：在待解释样本周围生成扰动样本
2. 模型预测：用黑盒模型对扰动样本进行预测
3. 加权拟合：根据扰动样本与原样本的距离赋予权重，拟合简单模型
4. 解释提取：从简单模型中提取特征重要性作为解释

数学表达：

ξ(x) = argmin_{g ∈ G} L(f, g, πₓ) + Ω(g)

其中：

• G：可解释模型集合（如线性模型）
• L：损失函数，衡量g对f的近似程度
• πₓ：局部性核函数，定义邻域范围
• Ω(g)：模型复杂度惩罚项

3.3 LIME实现示例

import lime
import lime.lime_tabular
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
import numpy as np

# 加载数据
data = load_breast_cancer()
X, y = data.data, data.target
feature_names = data.feature_names

# 训练黑盒模型
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X, y)

# 创建LIME解释器
explainer = lime.lime_tabular.LimeTabularExplainer(
    X,
    feature_names=feature_names,
    class_names=['恶性', '良性'],
    discretize_continuous=True,
    mode='classification'
)

# 解释单个预测
idx = 0  # 选择第一个样本
exp = explainer.explain_instance(
    X[idx], 
    model.predict_proba, 
    num_features=10
)

# 显示解释结果
exp.show_in_notebook(show_table=True)

# 获取特征重要性列表
feature_weights = exp.as_list()
print("Top 10 重要特征:")
for feature, weight in feature_weights:
    print(f"  {feature}: {weight:.4f}")

3.4 LIME的局限性

局限性	说明	应对策略
局部性假设	简单模型仅在局部有效	多次采样，综合多次解释
邻域定义敏感	核函数参数影响结果	交叉验证选择参数
解释不稳定	随机采样导致结果波动	设置随机种子，多次运行取平均
特征相关性	相关特征的解释可能分散	使用分组LIME

---

4. SHAP值原理与应用

4.1 Shapley值与博弈论基础

SHAP（SHapley Additive exPlanations）基于博弈论中的Shapley值概念，由Lundberg和Lee于2017年提出。

博弈论背景：

• 假设有N个玩家合作完成一项任务，获得总收益v(N)
• Shapley值回答：如何公平地分配收益给每个玩家？

映射到机器学习：

• 玩家 = 特征
• 联盟 = 特征子集
• 收益函数 = 模型预测
• Shapley值 = 每个特征对预测的贡献

4.2 Shapley值计算公式

φᵢ(f) = Σ_{S ⊆ N\{i}} [|S|!(|N|-|S|-1)! / |N|!] × [f(S∪{i}) - f(S)]

其中：

• S：不包含特征i的特征子集
• f(S)：仅使用S中特征的模型预测
• f(S∪{i}) - f(S)：特征i的边际贡献
• 权重系数：该子集在所有排列中出现的概率

SHAP值的优良性质：

性质	说明
效率性	所有特征的SHAP值之和等于预测值与基准值之差
对称性	相同的特征具有相同的SHAP值
虚拟性	不影响预测的特征SHAP值为0
可加性	对于模型组合，SHAP值也可相加

4.3 SHAP计算算法

由于精确计算Shapley值的复杂度为O(2^N)，实际应用中采用近似算法：

算法	适用模型	时间复杂度	特点
TreeSHAP	树模型	O(TLD²)	精确计算，高效
DeepSHAP	深度学习	O(N)	基于DeepLIFT近似
KernelSHAP	任意模型	O(NM)	模型无关，采样近似
LinearSHAP	线性模型	O(N)	精确计算，闭式解

4.4 SHAP可视化

import shap
import xgboost as xgb
from sklearn.datasets import load_boston
import matplotlib.pyplot as plt

# 加载数据（使用替代数据集）
from sklearn.datasets import fetch_california_housing
housing = fetch_california_housing()
X, y = housing.data, housing.target
feature_names = housing.feature_names

# 训练XGBoost模型
model = xgb.XGBRegressor(n_estimators=100, max_depth=4, random_state=42)
model.fit(X, y)

# 创建SHAP解释器
explainer = shap.Explainer(model)
shap_values = explainer(X)

# 1. 瀑布图：单个预测的解释
plt.figure(figsize=(10, 6))
shap.plots.waterfall(shap_values[0], max_display=10, show=False)
plt.title("单个样本的SHAP解释")
plt.tight_layout()
plt.show()

# 2. 力图：展示特征推动预测的方向
plt.figure(figsize=(12, 4))
shap.plots.force(shap_values[0], matplotlib=True, show=False)
plt.title("SHAP力图")
plt.tight_layout()
plt.show()

# 3. 摘要图：全局特征重要性
plt.figure(figsize=(10, 8))
shap.summary_plot(shap_values, X, feature_names=feature_names, show=False)
plt.title("全局特征重要性")
plt.tight_layout()
plt.show()

# 4. 依赖图：特征值与SHAP值的关系
plt.figure(figsize=(10, 6))
shap.dependence_plot(0, shap_values.values, X, feature_names=feature_names, show=False)
plt.title("特征依赖图")
plt.tight_layout()
plt.show()

# 5. 蜂群图：所有样本的SHAP值分布
plt.figure(figsize=(10, 8))
shap.plots.beeswarm(shap_values, max_display=10, show=False)
plt.title("SHAP蜂群图")
plt.tight_layout()
plt.show()

4.5 SHAP值解读指南

瀑布图解读：

• 基准值（Base Value）：训练集预测的平均值
• 红色箭头：推动预测值升高的特征
• 蓝色箭头：推动预测值降低的特征
• 最终值：该样本的模型预测值

摘要图解读：

• 颜色：特征值高低（红高蓝低）
• 位置：SHAP值正负（右正左负）
• 分布宽度：该特征对预测影响的变异性

---

5. 特征重要性分析

5.1 置换重要性

置换重要性（Permutation Importance）通过随机打乱某一特征的值来评估其重要性：

from sklearn.inspection import permutation_importance
import matplotlib.pyplot as plt

# 计算置换重要性
result = permutation_importance(
    model, X_test, y_test, 
    n_repeats=10, 
    random_state=42,
    scoring='neg_mean_squared_error'
)

# 获取重要性排序
importance_df = pd.DataFrame({
    'feature': feature_names,
    'importance_mean': result.importances_mean,
    'importance_std': result.importances_std
}).sort_values('importance_mean', ascending=False)

# 可视化
plt.figure(figsize=(10, 6))
plt.barh(importance_df['feature'], importance_df['importance_mean'])
plt.xlabel('置换重要性')
plt.title('特征置换重要性')
plt.gca().invert_yaxis()
plt.tight_layout()
plt.show()

置换重要性的优势：

• 模型无关，适用于任何模型
• 反映特征对模型性能的真实贡献
• 自动考虑特征间的交互作用

5.2 Partial Dependence Plot

PDP展示特征对模型预测的平均边际效应：

from sklearn.inspection import partial_dependence, PartialDependenceDisplay

# 计算并绘制PDP
features = [0, 1, (0, 1)]  # 单特征和双特征交互
display = PartialDependenceDisplay.from_estimator(
    model, X_train, features, 
    feature_names=feature_names,
    kind='average'
)
display.figure_.suptitle('Partial Dependence Plots')
plt.tight_layout()
plt.show()

PDP的解读：

• 单调递增：特征与预测正相关
• 单调递减：特征与预测负相关
• 非单调：存在复杂的非线性关系
• 平坦：特征对预测影响很小

5.3 ICE曲线

ICE（Individual Conditional Expectation）曲线展示单个样本的特征影响：

# 绘制ICE曲线
display = PartialDependenceDisplay.from_estimator(
    model, X_train, [0], 
    feature_names=feature_names,
    kind='individual'  # ICE曲线
)
plt.title('ICE曲线')
plt.tight_layout()
plt.show()

# ICE与PDP结合
display = PartialDependenceDisplay.from_estimator(
    model, X_train, [0], 
    feature_names=feature_names,
    kind='both'  # 同时显示ICE和PDP
)
plt.title('ICE与PDP')
plt.tight_layout()
plt.show()

ICE vs PDP：

特性	PDP	ICE
展示内容	平均效应	单个样本效应
计算方式	所有样本平均	逐样本计算
异质性检测	弱	强
计算成本	低	高

---

6. 因果推断基础

6.1 相关性vs因果性

经典误区：

• 冰淇淋销量与溺水事件高度相关
• 但禁止冰淇淋不会减少溺水
• 真正的原因是：高温天气同时导致两者增加

因果推断的核心问题：

问题类型	符号表示	含义
关联	P(Y|X)	观察到X时Y的概率
干预	P(Y|do(X))	主动设置X后Y的概率
反事实	P(Yₓ|X=x’, Y=y’)	如果X不同，Y会怎样

6.2 因果图与d-分离

因果图（Causal Graph）用有向无环图（DAG）表示变量间的因果关系：

X → Y 表示X是Y的原因

三种基本结构：

结构	图示	说明
链式	X → Z → Y	Z是中介变量
分叉	X ← Z → Y	Z是混杂因子
对撞	X → Z ← Y	Z是对撞变量

d-分离规则：

• 链式结构中，控制Z阻断X与Y的关联
• 分叉结构中，控制Z阻断X与Y的虚假关联
• 对撞结构中，控制Z会打开X与Y的虚假路径

6.3 Do-Calculus

Judea Pearl提出的do-calculus是从观察数据推断因果效应的数学框架：

三条基本规则：

1. 插入/删除观测：

   P(y|do(x), z, w) = P(y|do(x), w) 如果 Y ⊥ Z | X, W 在 G_X中
   

2. 交换干预与观测：

   P(y|do(x), do(z), w) = P(y|do(x), z, w) 如果 Y ⊥ Z | X, W 在 G_{X,Z}中
   

3. 删除干预：

   P(y|do(x), do(z), w) = P(y|do(x), w) 如果 Y ⊥ Z | X, W 在 G_{X,Z(W)}中
   

6.4 工具变量法

当存在未观测的混杂因子时，工具变量（IV）方法可以识别因果效应：

工具变量的条件：

1. 相关性：Z与X相关
2. 排他性：Z只通过X影响Y
3. 独立性：Z与未观测混杂因子无关

# 使用linearmodels进行工具变量估计
from linearmodels.iv import IV2SLS
import pandas as pd

# 假设数据结构
# y: 结果变量
# x: 处理变量（内生）
# z: 工具变量
# w: 控制变量

data = pd.DataFrame({
    'y': y,
    'x': x,
    'z': z,
    'w': w
})

# 2SLS估计
model = IV2SLS.from_formula('y ~ 1 + w + [x ~ z]', data)
result = model.fit()
print(result.summary)

---

7. 前沿方法简介

7.1 概念激活向量CAV

概念激活向量（Concept Activation Vectors，CAV）由Google研究团队提出，用于测试模型是否学习到了人类可理解的高级概念。

核心思想：

• 收集代表某概念的正样本和负样本
• 在模型中间层提取激活值
• 训练线性分类器区分正负样本
• 分类器的权重向量即为CAV

TCAV（Testing with CAV）：

• 量化概念对模型预测的影响程度
• 支持敏感性测试：“条纹概念对预测斑马有多重要？”

# TCAV概念性实现
import numpy as np
from sklearn.linear_model import SGDClassifier

def compute_cav(model, layer_name, concept_examples, random_examples):
    """
    计算概念激活向量
    
    参数:
        model: 目标神经网络
        layer_name: 目标层名称
        concept_examples: 概念正样本
        random_examples: 随机负样本
    """
    # 提取中间层激活
    concept_acts = get_activations(model, layer_name, concept_examples)
    random_acts = get_activations(model, layer_name, random_examples)
    
    # 训练线性分类器
    X = np.vstack([concept_acts, random_acts])
    y = np.array([1]*len(concept_acts) + [0]*len(random_acts))
    
    classifier = SGDClassifier()
    classifier.fit(X, y)
    
    # CAV是分类器的权重向量
    cav = classifier.coef_[0]
    return cav

def tcav_score(model, layer_name, cav, test_examples, class_idx):
    """
    计算TCAV分数
    """
    acts = get_activations(model, layer_name, test_examples)
    gradients = get_gradients(model, layer_name, test_examples, class_idx)
    
    # 计算梯度与CAV的方向一致性
    directional_derivatives = np.dot(gradients, cav)
    tcav = np.mean(directional_derivatives > 0)
    return tcav

7.2 Integrated Gradients

Integrated Gradients（IG）由Sundararajan等人提出，满足两个重要公理：

1. 敏感性： 如果网络输出对某输入特征变化敏感，则该特征应获得非零归因
2. 实现不变性： 功能等效的网络应产生相同的归因

计算公式：

IGᵢ(x) = (xᵢ - x'ᵢ) × ∫₀¹ [∂F(x' + α(x - x')) / ∂xᵢ] dα

其中x’是基线输入（通常为零或全黑图像）。

import torch
import torch.nn.functional as F

def integrated_gradients(model, input_tensor, baseline=None, steps=50):
    """
    计算Integrated Gradients
    
    参数:
        model: PyTorch模型
        input_tensor: 输入张量
        baseline: 基线输入，默认为零张量
        steps: 积分步数
    """
    if baseline is None:
        baseline = torch.zeros_like(input_tensor)
    
    # 生成插值路径
    scaled_inputs = [baseline + (float(i) / steps) * (input_tensor - baseline) 
                     for i in range(steps + 1)]
    
    # 计算梯度
    gradients = []
    for inp in scaled_inputs:
        inp.requires_grad_(True)
        output = model(inp)
        model.zero_grad()
        output.backward()
        gradients.append(inp.grad.detach())
    
    # 近似积分
    avg_gradients = torch.stack(gradients).mean(dim=0)
    integrated_grads = (input_tensor - baseline) * avg_gradients
    
    return integrated_grads

7.3 2024-2025年XAI进展

1. 大语言模型可解释性突破：

• Mechanistic Interpretability：通过逆向工程理解Transformer的内部计算
• Representation Engineering：直接操控模型的内部表示
• Sparse Autoencoders：提取可解释的特征方向

2. 因果可解释性：

• CausalSHAP：结合因果推断的SHAP变体
• Counterfactual Explanations：生成"如果…会怎样"的反事实解释
• Causal Mediation Analysis：分解直接效应和间接效应

3. 多模态可解释性：

• Vision-Language Explainability：解释CLIP等多模态模型的对齐机制
• Cross-modal Attribution：追踪跨模态的信息流动

4. 可解释性评估标准：

评估维度	指标	说明
保真度	解释与模型行为的一致性	高保真度表示解释准确
稳定性	相似输入产生相似解释	低方差表示解释可靠
可理解性	人类对解释的理解程度	主观评估为主
完整性	解释覆盖所有相关因素	避免遗漏重要信息

---

8. 实战案例：使用SHAP和LIME解释机器学习模型

8.1 案例背景

本案例使用UCI机器学习库中的心脏病数据集，构建一个预测心脏病风险的分类模型，并使用SHAP和LIME进行解释分析。

8.2 完整代码实现

"""
模型可解释性实战案例：心脏病风险预测
使用SHAP和LIME解释随机森林模型
"""

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score
import shap
import lime
import lime.lime_tabular
import warnings
warnings.filterwarnings('ignore')

# 设置中文显示
plt.rcParams['font.sans-serif'] = ['SimHei', 'DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False

# ============================================
# 1. 数据加载与预处理
# ============================================

# 加载心脏病数据集（使用UCI Heart Disease数据集）
# 特征说明：
# age: 年龄
# sex: 性别 (1=男, 0=女)
# cp: 胸痛类型 (0-3)
# trestbps: 静息血压
# chol: 血清胆固醇
# fbs: 空腹血糖 > 120 mg/dl (1=是, 0=否)
# restecg: 静息心电图结果 (0-2)
# thalach: 最大心率
# exang: 运动诱发心绞痛 (1=是, 0=否)
# oldpeak: ST段压低
# slope: 峰值运动ST段斜率 (0-2)
# ca: 主要血管数量 (0-3)
# thal: 地中海贫血 (0-3)
# target: 心脏病诊断 (1=患病, 0=健康)

# 从UCI下载数据
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/heart-disease/processed.cleveland.data"
column_names = ['age', 'sex', 'cp', 'trestbps', 'chol', 'fbs', 
                'restecg', 'thalach', 'exang', 'oldpeak', 
                'slope', 'ca', 'thal', 'target']

# 如果网络不可用，使用模拟数据
try:
    df = pd.read_csv(url, names=column_names)
    # 处理缺失值
    df = df.replace('?', np.nan)
    df = df.dropna()
    df['target'] = (df['target'] > 0).astype(int)  # 二分类
    print("成功加载在线数据")
except:
    print("使用模拟数据")
    np.random.seed(42)
    n_samples = 300
    df = pd.DataFrame({
        'age': np.random.normal(54, 9, n_samples),
        'sex': np.random.binomial(1, 0.68, n_samples),
        'cp': np.random.randint(0, 4, n_samples),
        'trestbps': np.random.normal(131, 17, n_samples),
        'chol': np.random.normal(246, 51, n_samples),
        'fbs': np.random.binomial(1, 0.15, n_samples),
        'restecg': np.random.randint(0, 3, n_samples),
        'thalach': np.random.normal(149, 23, n_samples),
        'exang': np.random.binomial(1, 0.33, n_samples),
        'oldpeak': np.random.exponential(1.5, n_samples),
        'slope': np.random.randint(0, 3, n_samples),
        'ca': np.random.randint(0, 4, n_samples),
        'thal': np.random.randint(0, 4, n_samples),
    })
    # 生成目标变量（基于特征的逻辑组合）
    risk_score = (
        (df['age'] - 50) / 10 * 0.3 +
        df['sex'] * 0.5 +
        (3 - df['cp']) * 0.4 +
        (df['chol'] - 200) / 50 * 0.3 +
        (220 - df['thalach']) / 50 * 0.5 +
        df['exang'] * 0.6 +
        df['oldpeak'] * 0.4 +
        df['ca'] * 0.5
    )
    df['target'] = (risk_score > risk_score.median()).astype(int)

print(f"数据集形状: {df.shape}")
print(f"\n目标变量分布:\n{df['target'].value_counts()}")

# ============================================
# 2. 特征工程与数据分割
# ============================================

# 分离特征和目标
X = df.drop('target', axis=1)
y = df['target']

# 特征名称
feature_names = X.columns.tolist()
print(f"\n特征列表: {feature_names}")

# 数据分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

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

print(f"\n训练集大小: {X_train.shape}")
print(f"测试集大小: {X_test.shape}")

# ============================================
# 3. 模型训练
# ============================================

# 训练随机森林模型
model = RandomForestClassifier(
    n_estimators=200,
    max_depth=10,
    min_samples_split=5,
    min_samples_leaf=2,
    random_state=42,
    n_jobs=-1
)
model.fit(X_train_scaled, y_train)

# 模型评估
y_pred = model.predict(X_test_scaled)
y_pred_proba = model.predict_proba(X_test_scaled)[:, 1]

print("\n" + "="*50)
print("模型性能评估")
print("="*50)
print(f"\nAUC-ROC: {roc_auc_score(y_test, y_pred_proba):.4f}")
print(f"\n分类报告:\n{classification_report(y_test, y_pred, target_names=['健康', '患病'])}")

# ============================================
# 4. 内置特征重要性分析
# ============================================

print("\n" + "="*50)
print("内置特征重要性（Gini重要性）")
print("="*50)

importance_df = pd.DataFrame({
    'feature': feature_names,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

print(importance_df.to_string(index=False))

# 可视化
plt.figure(figsize=(10, 6))
sns.barplot(data=importance_df, x='importance', y='feature', palette='viridis')
plt.title('随机森林特征重要性', fontsize=14)
plt.xlabel('重要性分数')
plt.ylabel('特征')
plt.tight_layout()
plt.savefig('feature_importance.png', dpi=150)
plt.show()

# ============================================
# 5. LIME解释
# ============================================

print("\n" + "="*50)
print("LIME局部解释")
print("="*50)

# 创建LIME解释器
lime_explainer = lime.lime_tabular.LimeTabularExplainer(
    X_train_scaled,
    feature_names=feature_names,
    class_names=['健康', '患病'],
    discretize_continuous=True,
    mode='classification',
    random_state=42
)

# 选择几个测试样本进行解释
sample_indices = [0, 5, 10]

for idx in sample_indices:
    print(f"\n--- 测试样本 {idx} 的LIME解释 ---")
    print(f"真实标签: {'患病' if y_test.iloc[idx] == 1 else '健康'}")
    print(f"预测概率: 患病={model.predict_proba(X_test_scaled[idx:idx+1])[0][1]:.4f}")
    
    # 生成解释
    exp = lime_explainer.explain_instance(
        X_test_scaled[idx],
        model.predict_proba,
        num_features=8,
        top_labels=1
    )
    
    # 显示解释
    print("\nTop 8 重要特征:")
    for feature, weight in exp.as_list(label=1):
        direction = "增加患病风险" if weight > 0 else "降低患病风险"
        print(f"  {feature}: {weight:+.4f} ({direction})")
    
    # 保存可视化
    if idx == sample_indices[0]:
        fig = exp.as_pyplot_figure(label=1)
        plt.title(f'LIME解释 - 样本 {idx}')
        plt.tight_layout()
        plt.savefig('lime_explanation.png', dpi=150)
        plt.show()

# ============================================
# 6. SHAP解释
# ============================================

print("\n" + "="*50)
print("SHAP解释分析")
print("="*50)

# 创建SHAP解释器
shap_explainer = shap.TreeExplainer(model)
shap_values = shap_explainer.shap_values(X_test_scaled)

# 对于二分类，shap_values是列表 [负类SHAP值, 正类SHAP值]
# 我们关注正类（患病）的解释
shap_values_positive = shap_values[1] if isinstance(shap_values, list) else shap_values

# 6.1 全局特征重要性（摘要图）
print("\n生成SHAP摘要图...")
plt.figure(figsize=(10, 8))
shap.summary_plot(
    shap_values_positive, 
    X_test_scaled, 
    feature_names=feature_names,
    show=False
)
plt.title('SHAP特征重要性摘要', fontsize=14)
plt.tight_layout()
plt.savefig('shap_summary.png', dpi=150)
plt.show()

# 6.2 条形图形式的重要性
plt.figure(figsize=(10, 6))
shap.summary_plot(
    shap_values_positive, 
    X_test_scaled, 
    feature_names=feature_names,
    plot_type='bar',
    show=False
)
plt.title('SHAP平均绝对重要性', fontsize=14)
plt.tight_layout()
plt.savefig('shap_bar.png', dpi=150)
plt.show()

# 6.3 单个样本的瀑布图解释
print("\n生成瀑布图解释...")
sample_idx = 0
plt.figure(figsize=(12, 8))
shap.waterfall_plot(
    shap.Explanation(
        values=shap_values_positive[sample_idx],
        base_values=shap_explainer.expected_value[1] if isinstance(shap_explainer.expected_value, list) else shap_explainer.expected_value,
        data=X_test_scaled[sample_idx],
        feature_names=feature_names
    ),
    max_display=10,
    show=False
)
plt.title(f'SHAP瀑布图 - 测试样本 {sample_idx}', fontsize=14)
plt.tight_layout()
plt.savefig('shap_waterfall.png', dpi=150)
plt.show()

# 6.4 依赖图
print("\n生成依赖图...")
top_feature = importance_df.iloc[0]['feature']
top_feature_idx = feature_names.index(top_feature)

plt.figure(figsize=(10, 6))
shap.dependence_plot(
    top_feature_idx,
    shap_values_positive,
    X_test_scaled,
    feature_names=feature_names,
    show=False
)
plt.title(f'SHAP依赖图 - {top_feature}', fontsize=14)
plt.tight_layout()
plt.savefig('shap_dependence.png', dpi=150)
plt.show()

# 6.5 力图（Force Plot）
print("\n生成力图...")
plt.figure(figsize=(20, 4))
shap.force_plot(
    shap_explainer.expected_value[1] if isinstance(shap_explainer.expected_value, list) else shap_explainer.expected_value,
    shap_values_positive[sample_idx],
    X_test_scaled[sample_idx],
    feature_names=feature_names,
    matplotlib=True,
    show=False
)
plt.title(f'SHAP力图 - 测试样本 {sample_idx}', fontsize=14)
plt.tight_layout()
plt.savefig('shap_force.png', dpi=150)
plt.show()

# ============================================
# 7. 对比分析：LIME vs SHAP
# ============================================

print("\n" + "="*50)
print("LIME vs SHAP 对比分析")
print("="*50)

# 对同一样本，比较两种方法的解释
comparison_idx = 0

# LIME解释
lime_exp = lime_explainer.explain_instance(
    X_test_scaled[comparison_idx],
    model.predict_proba,
    num_features=5
)
lime_features = {f.split()[0]: w for f, w in lime_exp.as_list(label=1)}

# SHAP解释（取绝对值最大的5个）
shap_vals = shap_values_positive[comparison_idx]
shap_indices = np.argsort(np.abs(shap_vals))[-5:]
shap_features = {feature_names[i]: shap_vals[i] for i in shap_indices}

print(f"\n样本 {comparison_idx} 的解释对比:")
print(f"预测概率: 患病={model.predict_proba(X_test_scaled[comparison_idx:comparison_idx+1])[0][1]:.4f}")
print(f"真实标签: {'患病' if y_test.iloc[comparison_idx] == 1 else '健康'}")

print("\nTop 5 特征对比:")
print(f"{'特征':<15} {'LIME权重':<15} {'SHAP值':<15}")
print("-" * 45)
all_features = set(lime_features.keys()) | set(shap_features.keys())
for feat in all_features:
    lime_w = lime_features.get(feat, 0)
    shap_v = shap_features.get(feat, 0)
    print(f"{feat:<15} {lime_w:<15.4f} {shap_v:<15.4f}")

# ============================================
# 8. 特征交互分析
# ============================================

print("\n" + "="*50)
print("特征交互分析")
print("="*50)

# 使用SHAP交互值
print("\n计算SHAP交互值（这可能需要一些时间）...")
try:
    shap_interaction_values = shap_explainer.shap_interaction_values(X_test_scaled[:50])
    if isinstance(shap_interaction_values, list):
        shap_interaction_values = shap_interaction_values[1]
    
    # 交互摘要图
    plt.figure(figsize=(12, 10))
    shap.summary_plot(
        shap_interaction_values, 
        X_test_scaled[:50], 
        feature_names=feature_names,
        show=False
    )
    plt.title('SHAP特征交互摘要', fontsize=14)
    plt.tight_layout()
    plt.savefig('shap_interaction.png', dpi=150)
    plt.show()
    print("交互分析完成")
except Exception as e:
    print(f"交互值计算跳过: {e}")

# ============================================
# 9. 结果总结
# ============================================

print("\n" + "="*50)
print("解释分析总结")
print("="*50)

print("""
关键发现：

1. 最重要的预测特征：
   - 根据SHAP和内置重要性，排名靠前的特征包括：
   - 这些特征与医学常识一致（如年龄、胸痛类型、最大心率等）

2. LIME与SHAP的一致性：
   - 两种方法在局部解释上大体一致
   - SHAP提供全局视角，LIME专注于局部近似
   - SHAP值具有理论基础（Shapley值），更加稳定

3. 模型行为洞察：
   - 年龄越大，患病风险越高
   - 最大心率越低，患病风险越高
   - 男性比女性风险更高
   - 运动诱发心绞痛是强风险指标

4. 临床可解释性：
   - 模型的预测逻辑符合医学知识
   - 可以为医生提供可理解的决策支持
   - 有助于识别需要进一步检查的患者
""")

print("\n可视化文件已保存:")
print("  - feature_importance.png: 内置特征重要性")
print("  - lime_explanation.png: LIME局部解释")
print("  - shap_summary.png: SHAP摘要图")
print("  - shap_bar.png: SHAP条形图")
print("  - shap_waterfall.png: SHAP瀑布图")
print("  - shap_dependence.png: SHAP依赖图")
print("  - shap_force.png: SHAP力图")
print("  - shap_interaction.png: SHAP交互图")

print("\n案例完成！")

8.3 案例运行结果解读

运行上述代码后，你将获得以下关键洞察：

特征重要性排序（典型结果）：

排名	特征	医学意义
1	ca (主要血管数)	血管狭窄程度
2	thalach (最大心率)	心脏功能指标
3	oldpeak (ST段压低)	心肌缺血标志
4	cp (胸痛类型)	症状严重程度
5	age (年龄)	风险随年龄增长

解释一致性验证：

• LIME和SHAP对同一样本的解释方向一致
• 重要特征的排序大致相同
• 验证了模型学习的合理性

---

9. 避坑小贴士

常见误区与解决方案

误区	问题描述	正确做法
盲目相信特征重要性	内置重要性可能误导	结合置换重要性、SHAP等多种方法验证
忽视特征相关性	相关特征的SHAP值会分散	使用SHAP的交互值或分组分析
局部解释泛化	将LIME的局部解释推广到全局	明确区分局部与全局解释
忽略基线选择	SHAP和IG的基线影响结果	选择有意义的基线（如数据集均值）
过度解释	对噪声赋予意义	进行统计显著性检验
忽视模型错误	解释错误的预测	分别分析正确和错误预测的解释

SHAP使用注意事项

1. TreeSHAP假设特征独立，对于高度相关的特征，解释可能不准确
2. 样本量影响：小样本时SHAP值可能不稳定
3. 计算成本：精确计算Shapley值复杂度高，注意选择合适的近似算法

LIME使用注意事项

1. 核函数宽度是关键超参数，需要通过交叉验证选择
2. 简单模型的选择影响解释质量，通常使用岭回归
3. 离散化连续特征可能丢失重要信息

---

10. 本章小结

本章系统介绍了机器学习模型可解释性的核心技术与方法：

核心知识点回顾：

主题	关键内容
XAI概述	可解释性的重要性、分类体系、与性能的权衡
内置可解释性	线性系数、树特征重要性、注意力权重
LIME	局部近似原理、扰动采样、实现与局限
SHAP	Shapley值理论、计算算法、多种可视化
全局分析	置换重要性、PDP、ICE曲线
因果推断	相关性vs因果性、do-calculus、工具变量
前沿方法	CAV、Integrated Gradients、2024-2025进展

一句话总结： 模型可解释性不是锦上添花，而是高风险AI应用的必备能力——它让我们不仅能预测"是什么"，更能理解"为什么"。

进一步学习资源：

• 《The Book of Why》- Judea Pearl（因果推断经典）
• SHAP官方文档：https://shap.readthedocs.io/
• InterpretML：https://interpret.ml/
• Papers With Code - XAI：https://paperswithcode.com/area/xai

---

本教程持续更新中，如有疑问欢迎在评论区留言讨论。