【python深度学习】Day 42 Grad-CAM与Hook函数

知识点回顾

作业：理解下今天的代码即可

一、回调函数

回调函数是作为参数传递给其他函数的函数，其目的是在某个特定事件发生时被调用执行。这种机制允许代码在运行时动态指定需要执行的逻辑，实现了代码的灵活性和可扩展性。

回调函数的核心价值在于：

1. 解耦逻辑：将通用逻辑与特定处理逻辑分离，使代码更模块化。

2. 事件驱动编程：在异步操作、事件监听（如点击按钮、网络请求完成）等场景中广泛应用。

3. 延迟执行：允许在未来某个时间点执行特定代码，而不必立即执行。

其中回调函数作为参数传入，所以在定义的时候一般用callback来命名，在 PyTorch 的 Hook API 中，回调参数通常命名为 hook

二、lambda函数

在hook中常常用到lambda函数，它是一种匿名函数（没有正式名称的函数），最大特点是用完即弃，无需提前命名和定义。它的语法形式非常简约，仅需一行即可完成定义，格式如下：

lambda 参数列表: 表达式

– 参数列表：可以是单个参数、多个参数或无参数。

– 表达式：函数的返回值（无需 return 语句，表达式结果直接返回）。

三、hook函数

Hook 函数是一种回调函数，它可以在不干扰模型正常计算流程的情况下，插入到模型的特定位置，以便获取或修改中间层的输出或梯度。PyTorch 提供了两种主要的 hook：

1. Module Hooks：用于监听整个模块的输入和输出

2. Tensor Hooks：用于监听张量的梯度

四、Grad-CAM

Grad-CAM (Gradient-weighted Class Activation Mapping) 算法是一种强大的可视化技术，用于解释卷积神经网络 (CNN) 的决策过程。它通过计算特征图的梯度来生成类激活映射（Class Activation Mapping，简称 CAM ），直观地显示图像中哪些区域对模型的特定预测贡献最大。

Grad-CAM 的核心思想是：通过反向传播得到的梯度信息，来衡量每个特征图对目标类别的重要性。

1. 梯度信息：通过计算目标类别对特征图的梯度，得到每个特征图的重要性权重。

2. 特征加权：用这些权重对特征图进行加权求和，得到类激活映射。

3. 可视化：将激活映射叠加到原始图像上，高亮显示对预测最关键的区域。

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

# 设置随机种子确保结果可复现
# 在深度学习中，随机种子可以让每次运行代码时，模型初始化参数、数据打乱等随机操作保持一致，方便调试和对比实验结果
torch.manual_seed(42)
np.random.seed(42)

# 加载CIFAR-10数据集
# 定义数据预处理步骤，先将图像转换为张量，再进行归一化操作
# 归一化的均值和标准差是(0.5, 0.5, 0.5)，这里的均值和标准差是对CIFAR-10数据集的经验值，使得数据分布更有利于模型训练
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 加载测试集，指定数据集根目录为'./data'，设置为测试集（train=False），如果数据不存在则下载（download=True），并应用上述定义的预处理
testset = torchvision.datasets.CIFAR10(
root='./data',
train=False,
download=True,
transform=transform
)

# 定义类别名称，CIFAR-10数据集包含这10个类别
classes = ('飞机', '汽车', '鸟', '猫', '鹿', '狗', '青蛙', '马', '船', '卡车')

# 定义一个简单的CNN模型
class SimpleCNN(nn.Module):
def __init__(self):
super(SimpleCNN, self).__init__()
# 第一个卷积层，输入通道为3（彩色图像），输出通道为32，卷积核大小为3×3，填充为1以保持图像尺寸不变
self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
# 第二个卷积层，输入通道为32，输出通道为64，卷积核大小为3×3，填充为1
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
# 第三个卷积层，输入通道为64，输出通道为128，卷积核大小为3×3，填充为1
self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
# 最大池化层，池化核大小为2×2，步长为2，用于下采样，减少数据量并提取主要特征
self.pool = nn.MaxPool2d(2, 2)
# 第一个全连接层，输入特征数为128 * 4 * 4（经过前面卷积和池化后的特征维度），输出为512
self.fc1 = nn.Linear(128 * 4 * 4, 512)
# 第二个全连接层，输入为512，输出为10（对应CIFAR-10的10个类别）
self.fc2 = nn.Linear(512, 10)

def forward(self, x):
# 第一个卷积层后接ReLU激活函数和最大池化操作，经过池化后图像尺寸变为原来的一半，这里输出尺寸变为16×16
x = self.pool(F.relu(self.conv1(x)))
# 第二个卷积层后接ReLU激活函数和最大池化操作，输出尺寸变为8×8
x = self.pool(F.relu(self.conv2(x)))
# 第三个卷积层后接ReLU激活函数和最大池化操作，输出尺寸变为4×4
x = self.pool(F.relu(self.conv3(x)))
# 将特征图展平为一维向量，以便输入到全连接层
x = x.view(-1, 128 * 4 * 4)
# 第一个全连接层后接ReLU激活函数
x = F.relu(self.fc1(x))
# 第二个全连接层输出分类结果
x = self.fc2(x)
return x

# 初始化模型
model = SimpleCNN()
print("模型已创建")

# 如果有GPU则使用GPU，将模型转移到对应的设备上
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# 训练模型（简化版，实际应用中应该进行完整训练）
def train_model(model, epochs=1):
# 加载训练集，指定数据集根目录为'./data'，设置为训练集（train=True），如果数据不存在则下载（download=True），并应用前面定义的预处理
trainset = torchvision.datasets.CIFAR10(
root='./data',
train=True,
download=True,
transform=transform
)
# 创建数据加载器，设置批量大小为64，打乱数据顺序（shuffle=True），使用2个线程加载数据
trainloader = torch.utils.data.DataLoader(
trainset,
batch_size=64,
shuffle=True,
num_workers=2
)

# 定义损失函数为交叉熵损失，用于分类任务
criterion = nn.CrossEntropyLoss()
# 定义优化器为Adam，用于更新模型参数，学习率设置为0.001
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(epochs):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# 从数据加载器中获取图像和标签
inputs, labels = data
# 将图像和标签转移到对应的设备（GPU或CPU）上
inputs, labels = inputs.to(device), labels.to(device)

# 清空梯度，避免梯度累加
optimizer.zero_grad()
# 模型前向传播得到输出
outputs = model(inputs)
# 计算损失
loss = criterion(outputs, labels)
# 反向传播计算梯度
loss.backward()
# 更新模型参数
optimizer.step()

running_loss += loss.item()
if i % 100 == 99:
# 每100个批次打印一次平均损失
print(f'[{epoch + 1}, {i + 1}] 损失: {running_loss / 100:.3f}')
running_loss = 0.0

print("训练完成")

# 训练模型（可选，如果有预训练模型可以加载）
# 取消下面这行的注释来训练模型
# train_model(model, epochs=1)

# 或者尝试加载预训练模型（如果存在）
try:
# 尝试加载名为'cifar10_cnn.pth'的模型参数
model.load_state_dict(torch.load('cifar10_cnn.pth'))
print("已加载预训练模型")
except:
print("无法加载预训练模型，使用未训练模型或训练新模型")
# 如果没有预训练模型，可以在这里调用train_model函数
train_model(model, epochs=1)
# 保存训练后的模型参数
torch.save(model.state_dict(), 'cifar10_cnn.pth')

# 设置模型为评估模式，此时模型中的一些操作（如dropout、batchnorm等）会切换到评估状态
model.eval()

# Grad-CAM实现
class GradCAM:
def __init__(self, model, target_layer):
self.model = model
self.target_layer = target_layer
self.gradients = None
self.activations = None

# 注册钩子，用于获取目标层的前向传播输出和反向传播梯度
self.register_hooks()

def register_hooks(self):
# 前向钩子函数，在目标层前向传播后被调用，保存目标层的输出（激活值）
def forward_hook(module, input, output):
self.activations = output.detach()

# 反向钩子函数，在目标层反向传播后被调用，保存目标层的梯度
def backward_hook(module, grad_input, grad_output):
self.gradients = grad_output[0].detach()

# 在目标层注册前向钩子和反向钩子
self.target_layer.register_forward_hook(forward_hook)
self.target_layer.register_backward_hook(backward_hook)

def generate_cam(self, input_image, target_class=None):
# 前向传播，得到模型输出
model_output = self.model(input_image)

if target_class is None:
# 如果未指定目标类别，则取模型预测概率最大的类别作为目标类别
target_class = torch.argmax(model_output, dim=1).item()

# 清除模型梯度，避免之前的梯度影响
self.model.zero_grad()

# 反向传播，构造one-hot向量，使得目标类别对应的梯度为1，其余为0，然后进行反向传播计算梯度
one_hot = torch.zeros_like(model_output)
one_hot[0, target_class] = 1
model_output.backward(gradient=one_hot)

# 获取之前保存的目标层的梯度和激活值
gradients = self.gradients
activations = self.activations

# 对梯度进行全局平均池化，得到每个通道的权重，用于衡量每个通道的重要性
weights = torch.mean(gradients, dim=(2, 3), keepdim=True)

# 加权激活映射，将权重与激活值相乘并求和，得到类激活映射的初步结果
cam = torch.sum(weights * activations, dim=1, keepdim=True)

# ReLU激活，只保留对目标类别有正贡献的区域，去除负贡献的影响
cam = F.relu(cam)

# 调整大小并归一化，将类激活映射调整为与输入图像相同的尺寸（32×32），并归一化到[0, 1]范围
cam = F.interpolate(cam, size=(32, 32), mode='bilinear', align_corners=False)
cam = cam – cam.min()
cam = cam / cam.max() if cam.max() > 0 else cam

return cam.cpu().squeeze().numpy(), target_class
import warnings
warnings.filterwarnings("ignore")
import matplotlib.pyplot as plt
# 设置中文字体支持
plt.rcParams["font.family"] = ["SimHei"]
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题
# 选择一个随机图像
# idx = np.random.randint(len(testset))
idx = 102 # 选择测试集中的第101张图片 (索引从0开始)
image, label = testset[idx]
print(f"选择的图像类别: {classes[label]}")

# 转换图像以便可视化
def tensor_to_np(tensor):
img = tensor.cpu().numpy().transpose(1, 2, 0)
mean = np.array([0.5, 0.5, 0.5])
std = np.array([0.5, 0.5, 0.5])
img = std * img + mean
img = np.clip(img, 0, 1)
return img

# 添加批次维度并移动到设备
input_tensor = image.unsqueeze(0).to(device)

# 初始化Grad-CAM（选择最后一个卷积层）
grad_cam = GradCAM(model, model.conv3)

# 生成热力图
heatmap, pred_class = grad_cam.generate_cam(input_tensor)

# 可视化
plt.figure(figsize=(12, 4))

# 原始图像
plt.subplot(1, 3, 1)
plt.imshow(tensor_to_np(image))
plt.title(f"原始图像: {classes[label]}")
plt.axis('off')

# 热力图
plt.subplot(1, 3, 2)
plt.imshow(heatmap, cmap='jet')
plt.title(f"Grad-CAM热力图: {classes[pred_class]}")
plt.axis('off')

# 叠加的图像
plt.subplot(1, 3, 3)
img = tensor_to_np(image)
heatmap_resized = np.uint8(255 * heatmap)
heatmap_colored = plt.cm.jet(heatmap_resized)[:, :, :3]
superimposed_img = heatmap_colored * 0.4 + img * 0.6
plt.imshow(superimposed_img)
plt.title("叠加热力图")
plt.axis('off')

plt.tight_layout()
plt.savefig('grad_cam_result.png')
plt.show()

# print("Grad-CAM可视化完成。已保存为grad_cam_result.png")