05-可解释人工智能（XAI）¶

import torch
import torch.nn.functional as F
from torchvision import models, transforms
from PIL import Image
import numpy as np

def compute_saliency_map(model, image_tensor, target_class):
    """计算显著性图"""
    model.eval()  # eval()开启评估模式（关闭Dropout等）
    image_tensor.requires_grad_(True)

    output = model(image_tensor.unsqueeze(0))  # unsqueeze增加一个维度
    score = output[0, target_class]
    score.backward()  # 反向传播计算梯度

    saliency = image_tensor.grad.abs().max(dim=0)[0]  # 取RGB通道最大值
    return saliency.detach().cpu().numpy()  # detach()分离计算图，cpu()确保在CPU上

def compute_integrated_gradients(model, image_tensor, target_class,
                                  baseline=None, steps=50):
    """计算积分梯度"""
    if baseline is None:
        baseline = torch.zeros_like(image_tensor)

    # 生成插值路径
    scaled_inputs = [baseline + (float(i) / steps) * (image_tensor - baseline)
                     for i in range(steps + 1)]

    grads = []
    model.eval()
    for scaled_input in scaled_inputs:
        scaled_input = scaled_input.unsqueeze(0).requires_grad_(True)
        output = model(scaled_input)
        score = output[0, target_class]
        score.backward()
        grads.append(scaled_input.grad.squeeze(0).clone())  # squeeze去除大小为1的维度

    # 梯形积分
    avg_grads = torch.stack(grads).mean(dim=0)
    ig = (image_tensor - baseline) * avg_grads

    return ig.abs().max(dim=0)[0].detach().cpu().numpy()

# 使用示例
model = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

# img = Image.open("cat.jpg")
# image_tensor = transform(img)
# saliency = compute_saliency_map(model, image_tensor, target_class=281)

class GradCAM:
    def __init__(self, model, target_layer):  # __init__构造方法，创建对象时自动调用
        self.model = model
        self.model.eval()
        self.gradients = None
        self.activations = None

        # 注册钩子
        target_layer.register_forward_hook(self._save_activation)
        target_layer.register_full_backward_hook(self._save_gradient)

    def _save_activation(self, module, input, output):
        self.activations = output.detach()

    def _save_gradient(self, module, grad_input, grad_output):
        self.gradients = grad_output[0].detach()

    def generate(self, input_tensor, target_class=None):
        output = self.model(input_tensor)

        if target_class is None:
            target_class = output.argmax(dim=1).item()  # .item()将单元素张量转为Python数值

        self.model.zero_grad()  # 清零梯度，防止梯度累积
        one_hot = torch.zeros_like(output)
        one_hot[0, target_class] = 1
        output.backward(gradient=one_hot)

        # 计算权重：全局平均池化梯度
        weights = self.gradients.mean(dim=[2, 3], keepdim=True)  # [1, C, 1, 1]

        # 加权求和
        cam = (weights * self.activations).sum(dim=1, keepdim=True)
        cam = F.relu(cam)

        # 上采样到输入尺寸
        cam = F.interpolate(cam, size=input_tensor.shape[2:],
                           mode='bilinear', align_corners=False)
        cam = cam.squeeze()
        cam = (cam - cam.min()) / (cam.max() - cam.min() + 1e-8)
        return cam.numpy()

# 使用
# model = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)
# grad_cam = GradCAM(model, model.layer4[-1])
# cam = grad_cam.generate(image_tensor.unsqueeze(0))

# pip install lime
from lime import lime_image
from skimage.segmentation import quickshift

def predict_fn(images):
    """LIME需要的批量预测函数"""
    batch = torch.stack([transform(Image.fromarray(img)) for img in images])  # 列表推导式，简洁创建列表
    with torch.no_grad():  # 禁用梯度计算，节省内存
        outputs = model(batch)
    return F.softmax(outputs, dim=1).numpy()

# explainer = lime_image.LimeImageExplainer()
# explanation = explainer.explain_instance(
#     np.array(img),
#     predict_fn,
#     top_labels=3,
#     num_samples=1000,
#     segmentation_fn=quickshift
# )
# temp, mask = explanation.get_image_and_mask(
#     explanation.top_labels[0], positive_only=True, num_features=5
# )

# pip install shap
import shap

# 对图像分类模型
# masker = shap.maskers.Image("inpaint_telea", image_tensor.shape[1:])
# explainer = shap.Explainer(predict_fn, masker)
# shap_values = explainer(images[:5], max_evals=500)
# shap.image_plot(shap_values)

import torch
from torchvision import models

def visualize_vit_attention(model, image_tensor):
    """ViT的注意力可视化"""
    model.eval()
    # 获取所有层的注意力（需要模型支持输出attention）
    with torch.no_grad():
        # 假设模型返回注意力权重
        output = model(image_tensor.unsqueeze(0))

    # Attention Rollout
    # attn_weights: list of [1, heads, tokens, tokens]
    # rollout = compute_rollout(attn_weights)
    # 可视化CLS token对所有patch的注意力
    pass

def compute_rollout(attn_list):
    """计算Attention Rollout"""
    result = torch.eye(attn_list[0].size(-1))
    for attn in attn_list:
        attn_mean = attn.mean(dim=1).squeeze(0)  # 多头平均
        attn_with_residual = 0.5 * attn_mean + 0.5 * torch.eye(attn_mean.size(-1))
        # 行归一化
        attn_with_residual = attn_with_residual / attn_with_residual.sum(dim=-1, keepdim=True)
        result = attn_with_residual @ result
    return result

"""完整的模型解释流程"""
import torch
from torchvision import models

def explain_prediction(model, image_tensor, class_idx):
    """对一个预测进行多角度解释"""
    results = {}

    # 1. 显著性图
    image_tensor.requires_grad_(True)
    output = model(image_tensor.unsqueeze(0))
    output[0, class_idx].backward()
    results['saliency'] = image_tensor.grad.abs().max(dim=0)[0]

    # 2. Grad-CAM
    grad_cam = GradCAM(model, model.layer4[-1])  # [-1]负索引取最后一个元素
    results['grad_cam'] = grad_cam.generate(
        image_tensor.unsqueeze(0), class_idx
    )

    # 3. 预测置信度
    with torch.no_grad():
        probs = torch.softmax(model(image_tensor.unsqueeze(0)), dim=1)
        results['confidence'] = probs[0, class_idx].item()

    return results

# 最佳实践：结合多种方法交叉验证解释的一致性