PyTorch07-PyTorch可视化

七、PyTorch可视化

7.1 可视化网络结构

7.1.1 神经网络可视化背景

前面说过,要想基于某个开源神经网络进行二开,修改成符合自己需求的神经网络,需要对原开源神经的结构、输入输出有熟悉的了解。

直接使用Python原生的print函数打印相关神经网络实例,固然可以输出其结构,但只能得到其最粗略的构件信息(每一个模型块或层由哪些模型块组成,及构造函数的关键参数),不能直观地查看每一个模型块或层的输出形状、参数量、整个神经网络的参数量、前向反向传播参数量等统计信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
# 70-使用print直接打印神经网络.py
# 以开源神经网络 resnet18 为例,使用print打印其粗略结构
import torchvision.models as models
resnet18 = models.resnet18()

print(resnet18)

"""
### 输出内容如下:
ResNet(
(conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
(bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
(layer1): Sequential(
(0): BasicBlock(
(conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)
(1): BasicBlock(
(conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)
)
(layer2): Sequential(
(0): BasicBlock(
(conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
(bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(downsample): Sequential(
(0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
(1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)
)
(1): BasicBlock(
(conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)
)
(layer3): Sequential(
(0): BasicBlock(
(conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
(bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(downsample): Sequential(
(0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
(1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)
)
(1): BasicBlock(
(conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)
)
(layer4): Sequential(
(0): BasicBlock(
(conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
(bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(downsample): Sequential(
(0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
(1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)
)
(1): BasicBlock(
(conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)
)
(avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
(fc): Linear(in_features=512, out_features=1000, bias=True)
)

"""

此外,虽然可以直接查看其源码实现来实现上述目的,但阅读源码方式耗时长、不够直观。其实如果不需要关注具体实现的前提下,只是想快速、直观了解某开源神经网络的上述信息,可以直接使用开源社区已经提供的torchinfo等模块。

7.1.2 当前主流的神经网络结构可视化“工具栈”

在实际开发中,大家通常会结合不同的场景搭配不同的工具:

需求场景 推荐工具 特点
终端/Notebook 打印结构、张量 Shapes、计算显存 torchinfo (首选) 纯文本表格,无系统依赖,信息最全面
交互式 UI 拖拽、查看完整节点计算图、导出图片 Netron 桌面端/Web 软件,支持将 .pth / .onnx 转换为漂亮的计算流程图
训练过程中的计算图轨迹记录 TensorBoard / WandB 记录模型的算子连接关系及标量/图像指标
论文/报告中绘制高质量的网络架构矢量图 PlotNeuralNet / DrawIO 专门用于绘制漂亮、符合学术规范的 3D/2D 神经网络结构框图

如果你需要快速检查模型的层级结构、输入输出 Tensor 维度变换(Shapes matching)以及参数量和显存占用,torchinfo 仍然是当下 PyTorch 开发者的首选工具。

7.1.3 torchinfo的安装与使用

根据开源项目torchinfo官网文档(https://github.com/TylerYep/torchinfo)的介绍,其有如下两种安装方式:

1
2
3
4
5
6
7
# 方法1: 通过pip安装
(ai_py312) jsy@jmac ~ % pip install torchinfo
(ai_py312) jsy@jmac ~ % pip list | grep torchinfo
torchinfo 1.8.0

# 方法2: 通过conda安装
conda install -c conda-forge torchinfo

因为自己习惯于使用pip来安装python模块,且pip与conda两种方式混用可能造成冲突,所以笔者使用pip安装torchinfo。

参考torchinfo官方文档https://github.com/TylerYep/torchinfo#how-to-use,使用torchinfo可视化神经网络的方法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
import torchvision.models as models
resnet18 = models.resnet18(weights=None)
# print(resnet18)

import torchinfo
batch_size = 1
torchinfo.summary(resnet18, input_size=(batch_size, 3, 224, 224))

"""
# 执行时输出如下:
==========================================================================================
Layer (type:depth-idx) Output Shape Param #
==========================================================================================
ResNet [1, 1000] --
├─Conv2d: 1-1 [1, 64, 112, 112] 9,408
├─BatchNorm2d: 1-2 [1, 64, 112, 112] 128
├─ReLU: 1-3 [1, 64, 112, 112] --
├─MaxPool2d: 1-4 [1, 64, 56, 56] --
├─Sequential: 1-5 [1, 64, 56, 56] --
│ └─BasicBlock: 2-1 [1, 64, 56, 56] --
│ │ └─Conv2d: 3-1 [1, 64, 56, 56] 36,864
│ │ └─BatchNorm2d: 3-2 [1, 64, 56, 56] 128
│ │ └─ReLU: 3-3 [1, 64, 56, 56] --
│ │ └─Conv2d: 3-4 [1, 64, 56, 56] 36,864
│ │ └─BatchNorm2d: 3-5 [1, 64, 56, 56] 128
│ │ └─ReLU: 3-6 [1, 64, 56, 56] --
│ └─BasicBlock: 2-2 [1, 64, 56, 56] --
│ │ └─Conv2d: 3-7 [1, 64, 56, 56] 36,864
│ │ └─BatchNorm2d: 3-8 [1, 64, 56, 56] 128
│ │ └─ReLU: 3-9 [1, 64, 56, 56] --
│ │ └─Conv2d: 3-10 [1, 64, 56, 56] 36,864
│ │ └─BatchNorm2d: 3-11 [1, 64, 56, 56] 128
│ │ └─ReLU: 3-12 [1, 64, 56, 56] --
├─Sequential: 1-6 [1, 128, 28, 28] --
│ └─BasicBlock: 2-3 [1, 128, 28, 28] --
│ │ └─Conv2d: 3-13 [1, 128, 28, 28] 73,728
│ │ └─BatchNorm2d: 3-14 [1, 128, 28, 28] 256
│ │ └─ReLU: 3-15 [1, 128, 28, 28] --
│ │ └─Conv2d: 3-16 [1, 128, 28, 28] 147,456
│ │ └─BatchNorm2d: 3-17 [1, 128, 28, 28] 256
│ │ └─Sequential: 3-18 [1, 128, 28, 28] 8,448
│ │ └─ReLU: 3-19 [1, 128, 28, 28] --
│ └─BasicBlock: 2-4 [1, 128, 28, 28] --
│ │ └─Conv2d: 3-20 [1, 128, 28, 28] 147,456
│ │ └─BatchNorm2d: 3-21 [1, 128, 28, 28] 256
│ │ └─ReLU: 3-22 [1, 128, 28, 28] --
│ │ └─Conv2d: 3-23 [1, 128, 28, 28] 147,456
│ │ └─BatchNorm2d: 3-24 [1, 128, 28, 28] 256
│ │ └─ReLU: 3-25 [1, 128, 28, 28] --
├─Sequential: 1-7 [1, 256, 14, 14] --
│ └─BasicBlock: 2-5 [1, 256, 14, 14] --
│ │ └─Conv2d: 3-26 [1, 256, 14, 14] 294,912
│ │ └─BatchNorm2d: 3-27 [1, 256, 14, 14] 512
│ │ └─ReLU: 3-28 [1, 256, 14, 14] --
│ │ └─Conv2d: 3-29 [1, 256, 14, 14] 589,824
│ │ └─BatchNorm2d: 3-30 [1, 256, 14, 14] 512
│ │ └─Sequential: 3-31 [1, 256, 14, 14] 33,280
│ │ └─ReLU: 3-32 [1, 256, 14, 14] --
│ └─BasicBlock: 2-6 [1, 256, 14, 14] --
│ │ └─Conv2d: 3-33 [1, 256, 14, 14] 589,824
│ │ └─BatchNorm2d: 3-34 [1, 256, 14, 14] 512
│ │ └─ReLU: 3-35 [1, 256, 14, 14] --
│ │ └─Conv2d: 3-36 [1, 256, 14, 14] 589,824
│ │ └─BatchNorm2d: 3-37 [1, 256, 14, 14] 512
│ │ └─ReLU: 3-38 [1, 256, 14, 14] --
├─Sequential: 1-8 [1, 512, 7, 7] --
│ └─BasicBlock: 2-7 [1, 512, 7, 7] --
│ │ └─Conv2d: 3-39 [1, 512, 7, 7] 1,179,648
│ │ └─BatchNorm2d: 3-40 [1, 512, 7, 7] 1,024
│ │ └─ReLU: 3-41 [1, 512, 7, 7] --
│ │ └─Conv2d: 3-42 [1, 512, 7, 7] 2,359,296
│ │ └─BatchNorm2d: 3-43 [1, 512, 7, 7] 1,024
│ │ └─Sequential: 3-44 [1, 512, 7, 7] 132,096
│ │ └─ReLU: 3-45 [1, 512, 7, 7] --
│ └─BasicBlock: 2-8 [1, 512, 7, 7] --
│ │ └─Conv2d: 3-46 [1, 512, 7, 7] 2,359,296
│ │ └─BatchNorm2d: 3-47 [1, 512, 7, 7] 1,024
│ │ └─ReLU: 3-48 [1, 512, 7, 7] --
│ │ └─Conv2d: 3-49 [1, 512, 7, 7] 2,359,296
│ │ └─BatchNorm2d: 3-50 [1, 512, 7, 7] 1,024
│ │ └─ReLU: 3-51 [1, 512, 7, 7] --
├─AdaptiveAvgPool2d: 1-9 [1, 512, 1, 1] --
├─Linear: 1-10 [1, 1000] 513,000
==========================================================================================
Total params: 11,689,512 # 模型总参数量(约 1169 万个权重和偏置参数)
Trainable params: 11,689,512 # 可训练参数量(需要通过梯度更新的参数,全量微调/训练时通常等于总参数量)
Non-trainable params: 0 # 冻结/不可训练的参数量(如被 freeze 的层或 BatchNorm 中固定的统计量)
Total mult-adds (Units.GIGABYTES): 1.81 # 单次前向传播的总乘加运算量(FLOPs/MACs,此处约为 1.81 GFLOPs)
==========================================================================================
Input size (MB): 0.60 # 输入数据(Tensor)占用的显存/内存大小(以单批次计算)
Forward/backward pass size (MB): 39.75 # 前向与反向传播过程中保存的中间激活值(Activation Maps)及梯度的显存大小
Params size (MB): 46.76 # 模型权重参数本身占用的显存大小(11,689,512 个 FP32 参数 ≈ 11.69M × 4 Bytes ≈ 46.76 MB)
Estimated Total Size (MB): 87.11 # 训练该模型时估计所需的最小显存总量(Input + Pass + Params 三者相加之和)
==========================================================================================
"""

可以看到调用torchinfo.summary方法,不仅将模型实例传入,还传入了input_size参数,这将使得 torchinfo 内部在内存中自动创建一个 Dummy Tensor(虚拟数据,形状为 (1, 3, 224, 224)),并将其送入 resnet18 模型进行一次前向传播(Forward Pass) 。

上例中输出结果包含如下内容:

  • 模型的完整网络结构层级;
  • 完整显示每一层特征图的输出尺寸(例如:Conv2d 输出 [1, 64, 112, 112],Linear 输出 [1, 1000]);
  • 精准统计并显示模型的总运算量(Total mult-adds / FLOPs);
  • 估算前向/反向传播占用的内存/显存大小(Forward/backward pass size)。

另外,可以注意到此方法输出的内容中并不会像print方法那样输出每个模型块的详细构造信息(部分信息如卷积层的kernel_size可以通过col_names=["kernel_size"]参数来实现输出),如果需要可能需要结合此两种方法来查看与确认。

关于torchinfo.summary方法更多参数的用法可参考https://github.com/TylerYep/torchinfo#documentation

7.2 CNN可视化

卷积层是神经网络中非常重要的层,根据前面的学习,可以知道它的作用是提取输入数据的各种特征信息的。其被广泛地应用于图像处理领域,提升了神经网络处理问题的准确性和效率,促进了计算机视觉技术的发展与应用。

前面只是学习如何使用它即在模型中添加一个或多个卷积层,执行前向传播、反向传播不断更新优化它,就可以达到上述目的。但其是如何工作的、为什么能提取数据的各类特征?这也是我在学习中时常在思考的问题。就是说到目前为止,我们只是把它当成黑盒子来用,输入数据、得到结果,黑盒子中发生了什么不知道,这就涉及到卷积层的可解释性问题。

解决了卷积层的可解释性问题,我们可以从数理与逻辑分析角度解释其原理与工作过程,提升模型的稳定性与鲁棒性,进一步推动与控制其向更优化的方向前进。

到目前为止,确实有一些解决方案尝试或已经解决此问题,此处介绍主要是CNN的可视化这类方案。通过这类技术方案,我们可以知道CNN中卷积核关注哪些特征?特征图具体提到哪些特征?

本节学习的内容包括:卷积核的可视化、特征图的可视化、基于CAM的CNN可视化、基于FlashTorch的CNN可视化。

7.2.1 CNN卷积核可视化

7.2.1.1 卷积核可视化介绍

神经网络中,卷积层是用来提取数据特征的。如果将卷积核以 “蓝-白-红” 伪彩色热力图的形式绘制出来,可以以直接的形式来知道卷积核在关注哪些特征,进一步了解模型的关注重点与工作原理。

PyTorch 神经网络中卷积核其实就是某卷积层对应的模型权重矩阵, 它们是以PyTorch张量形式存在。要将神经网络中某卷积核可视化,就是将卷积层对应的模型权重矩阵可视化,就是将这些PyTorch张量可视化。

7.2.1.2 示例代码

下面以VGG-11 模型为例,将其中某个卷积核可视化。完整可执行示例代码如下(核心的可视化代码在最后的两个嵌套for循环):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
# 20-确认模型的层信息(包含卷积核可视化).py
import matplotlib.pyplot as plt # 提供 figure、subplot、imshow 等绘图函数。
import torchvision # 提供 torchvision.models.VGG11_Weights 预训练权重枚举。
from torchvision.models import vgg11 # 导入 VGG-11 模型构造函数。
import torchinfo # 用 summary() 按层打印模型的输入/输出形状及参数量。
import torch.nn as nn # 下面会额外创建一个 Conv2d 层,观察其权重形状。

# 创建已加载 ImageNet 预训练权重的 VGG-11 模型;若本地没有该权重,首次运行会下载。
model = vgg11(weights=torchvision.models.VGG11_Weights.IMAGENET1K_V1)

# model.features 是 VGG 的卷积特征提取部分(nn.Sequential)。
# named_children() 产生 (“层编号字符串”, 层对象);转成字典后可按编号取层。
model_dict = dict(model.features.named_children())

print(f"直接以 print(model) 打印 VGG-11 模型对象时,输出的内容是模型的完整层级结构:")
print(model) # 打印 VGG-11 的完整层级结构。

print(f"\n 使用 torchinfo.summary(model) 打印 VGG-11 模型时,输出的内容是每层的形状、参数量等概要信息:")
torchinfo.summary(model) # 输出每层的形状、参数量等概要信息。

# VGG-11 的 features[3] 是第二个卷积层 Conv2d(64, 128, kernel_size=3)。
# 注意:变量名 conv1 表示“本代码取来观察的卷积层”,并不是 VGG 的第一个卷积层。
conv1 = model_dict['3']

# Conv2d.weight 是需要梯度的 Parameter;detach() 得到不再参与自动求导的 Tensor,
# 因而可以安全地交给 Matplotlib 读取和可视化,不会保留计算图。
# 此处的形状为 (out_channels, in_channels, kernel_height, kernel_width),即 (128, 64, 3, 3)。
kernel_set = conv1.weight.detach()

# len(Tensor) 返回第 0 维长度;对于卷积核权重就是输出通道数 out_channels=128。
# 每个输出通道对应一个“完整卷积核组”,该组包含对全部输入通道的 64 个 3×3 小核。
num = len(kernel_set)
print(f"\nVGG-11 的 features[3] 是第二个卷积层的形状:")
print(kernel_set.shape) # 打印预训练 VGG 这一层的卷积核权重形状: torch.Size([128, 64, 3, 3])

# # 另建一个普通卷积层作形状对照:3 个输入通道、64 个输出通道、每个小核大小 3×3。
# # 它的 weight 形状为 (64, 3, 3, 3):64 组输出卷积核,每组含 RGB 三个输入通道的小核。
# conv_1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
# print(conv_1.weight.detach().shape)

print(f"\n下面开始可视化 VGG-11 的 features[3] 卷积层的卷积核权重:")
# 外层循环按“输出通道”逐组查看卷积核。
# i 依次为 0~127;kernel_set[i] 的形状为 (64, 3, 3),代表第 i 个输出通道
# 与 64 个输入通道分别连接的 64 个 3×3 小卷积核。
for i in range(0, num):
i_kernel = kernel_set[i]

# 为第 i 个输出通道单独创建一张画布。
# 每次外层循环都会产生一个 Figure,因此本代码一共会创建 128 张图。
plt.figure(figsize=(20, 17))

# len(i_kernel) 是输入通道数。这里只在输入通道数大于 1 时进行网格绘图;
# 对当前 VGG 层,它等于 64,所以条件成立。
if len(i_kernel) > 1:
# 内层循环逐个枚举“第 i 个输出通道对应的各输入通道小核”。
# idx 是输入通道编号(0~63);filer 是对应的二维 3×3 权重 Tensor。
# 变量名 filer 沿用原代码;它实际表示 filter(滤波器/小卷积核)。
for idx, filer in enumerate(i_kernel):
# 将当前小核放进 9 行 × 9 列的第 idx+1 个子图位置。
# subplot 的位置编号从 1 开始,故这里使用 idx+1;64 个小核只占前 64 格,
# 其余 17 格保持空白。9×9 网格足以容纳这一层每组的 64 个小核。
plt.subplot(9, 9, idx + 1)

# 不显示坐标轴刻度和边框,因为 3×3 权重矩阵的坐标位置在这里没有实际含义。
plt.axis('off')

# filer[:, :] 取出完整二维 3×3 权重矩阵;detach() 再次确保它仅用于显示。
# 此处是打印二维矩阵,直接使用 filer.detach() 即可
# cmap='bwr' 使用蓝-白-红配色:通常负权重偏蓝、接近 0 的权重偏白、
# 正权重偏红。每个子图默认会按自身最小/最大值缩放颜色,因此颜色主要
# 用于观察单个小核内部的正负分布,不能严格比较不同子图权重绝对值大小。
# plt.imshow(filer[:, :].detach(), cmap='bwr')
plt.imshow(filer.detach(), cmap='bwr')

# 在普通 .py 脚本中,若运行后没有自动弹出图窗,可在此处添加 plt.show();
# 在 Jupyter Notebook 等交互式环境中,图形通常会自动显示。
# plt.show() # 以普通 .py 脚本执行时弹出的窗口太多,最好在Jupyter Notebook中执行

上述代码会创建128个画布,每个画面上绘制64个子图,其中每个子图就对应一个3*3卷积核。此处是以颜色映射表cmap=bwr来绘图的,就是说每个子图中具体有9个像素格子,每个像素格子只能是蓝色(b/blue)、白色(w/white)、红色(r/red)之一,但颜色深度根据实际而定。且三种不同颜色代表不同含义:

  • 深蓝(Blue):映射矩阵中的极小值 / 负数值(负权重/负响应)。
  • 纯白(White):映射接近 0 的数值(对输出几乎无贡献的数值)。
  • 深红(Red):映射矩阵中的极大值 / 正数值(正权重/正响应)。

7.2.1.3 可视化结果分析

下图是上述代码在Jupyter Notebook中执行输出的卷积核可视化结果的第一个画布中的图。 aa7c33ba-7f61-4f15-92d4-928e839d3b4b.png 针对这张图的大致分析如下:

首先,这张图并不是把某一张输入汽车图片“卷积后的结果”画出来;它画的是模型参数,即 VGG-11 的第二个卷积层 features[3] 已经学习到的权重。此层的权重张量形状为 (128, 64, 3, 3),其四个维度的含义是:

1
2
(输出通道数, 输入通道数, 卷积核高度, 卷积核宽度)
128 64 3 3

上述代码的外层循环第一次执行时,i=0,所以得到的正是这一张“第一个画布”。这张画布对应的是第 0 个输出通道。kernel_set[0] 的形状为 (64, 3, 3),因此画布中有 64 个小图;每个小图都是一个 3×3 的二维权重矩阵,分别对应第 0 个输出通道与前一层第 0~63 个输入通道之间的连接权重。

也就是说,应该把这张图理解为:

1
2
3
4
5
6
7
这 64 个 3×3 小矩阵共同构成一个完整的多通道卷积核组
↓
它们分别作用于前一层的 64 张输入特征图
↓
64 个卷积结果在对应位置相加,再加上一个 bias
↓
得到本层的第 0 张输出特征图

用公式表示,若前一层的 64 张输入特征图记为 \(X_c\),这张图所对应的第 0 个输出特征图可概略写为:

\[ Y_0=\sum_{c=0}^{63}X_c * W_{0,c}+b_0 \]

其中 \(W_{0,c}\) 就是画面中的第 \(c\) 个 3×3 小图,星号表示卷积层实际执行的互相关运算。因而,单个小图并不是完整的“第 0 个卷积核”;完整的卷积核组是 kernel_set[0],它由 64 个小图一起组成。

从画面布局看,代码使用的是 9×9 网格。前 64 个位置放置 64 个小图,最后 17 个位置没有对应的输入通道,因此保持空白。小图在大网格中的位置只表示输入通道编号顺序,例如第一个小图对应输入通道 0、第二个对应输入通道 1;它们彼此上下左右相邻并不表示图像空间中的相邻位置。真正具有空间含义的是每个小图内部的 3×3 格子。

如果只观察每个 3×3 小图内部,许多小图表现出“某些位置颜色较暖、另一些位置颜色较冷”的对比结构,例如有些小图大致呈现左上偏暖、右下偏冷的趋势。这说明该层正在学习对前一层特征图中某些局部空间排列更敏感:当输入特征在权重较大的位置激活较强、在权重较小的位置激活较弱时,这个小卷积核会给第 0 个输出通道带来较大的响应。类似的局部对比模式在浅层中常与边缘、方向、明暗变化等简单结构有关;但这里已经是第二个卷积层,输入的 64 个通道本身已不是 RGB 三个颜色通道,而是第一层提取出的特征图,所以不能把某一个小图简单地解释为“它正在检测红色”“它正在检测车轮”等具体语义。

还需要特别注意颜色的含义。当前代码的 plt.imshow(filer.detach(), cmap='bwr') 没有指定统一的 vmin、vmax 或以 0 为中心的颜色归一化方式。Matplotlib 会对每一个小图单独按照它自己的最小值、最大值映射颜色。因此,在当前画法下:

  • 红色可靠表示“这个小图内部相对较大的权重”;
  • 蓝色可靠表示“这个小图内部相对较小的权重”;
  • 白色大致表示“该小图自身数值范围的中间位置”;
  • 但红色不一定严格表示正数、蓝色不一定严格表示负数,白色也不一定严格等于 0;
  • 不同小图的颜色深浅不能直接用于比较它们的权重绝对值大小。

若希望让颜色严格以 0 为中心,并且使不同小图可以使用同一尺度比较,可以先计算整层权重的绝对值最大值,再在每次绘图时统一指定颜色范围:

1
2
3
4
5
6
7
8
9
10
# 放在循环外:用整层权重的最大绝对值作为统一颜色尺度。
max_abs = kernel_set.abs().max().item()

# 放在内层循环中:0 映射为白色,负值偏蓝,正值偏红。
plt.imshow(
filer.detach(),
cmap="bwr",
vmin=-max_abs,
vmax=max_abs,
)

最后,这类卷积核权重可视化回答的是“模型已经学到怎样的局部加权规则”。它并不能直接说明模型面对某一张具体汽车图片时究竟在哪些区域被激活、最终关注了什么。若要回答后一类问题,需要像后面的“CNN 特征图可视化”那样,把具体图片送入模型,观察实际产生的特征图;若要进一步解释某个分类结果关注原图哪里,则需要使用 CAM 或 Grad-CAM 等方法。

7.2.2 CNN特征图可视化

7.2.2.1 特征图可视化介绍

卷积核可视化,是直接查看卷积层中已经学习好的权重;特征图可视化则是把某一张具体图片输入模型后,查看它经过某一层时实际得到的输出结果。也就是说,前者主要看“模型学到了什么样的局部加权规则”,后者主要看“这张图片经过模型后,哪些特征被激活了”。

对于图像 CNN,某一层输出的特征图通常是一个形状为 (N, C, H, W) 的张量。其中 N 是一次输入的图片数量,C 是输出通道数,H、W 是每张二维特征图的高和宽。若一次只输入一张图片,则 N=1;此时取出第 0 张图片后,会得到形状为 (C, H, W) 的张量,也就是 C 张不同的二维特征图。特征图可视化,就是将这些二维矩阵逐张绘制成灰度图或伪彩色图。

特征图中较亮或颜色较明显的位置,表示该通道在这些空间位置的激活相对更强;较暗的位置则表示该通道的激活相对较弱。通过观察不同通道的图像,可以大致了解这一层对图片中的哪些局部模式有响应。一般情况下,靠近输入的层更容易响应边缘、方向、纹理等简单结构;更深的层会在前面层提取到的特征基础上,组合出更复杂的模式。

不过,特征图只是网络的中间计算结果。看到某个通道在某处激活较强,并不能直接说明模型最终预测某个类别时“只关注了这里”,因为后面的卷积层、池化层和分类器还会继续处理、组合这些特征。若想进一步查看模型为了预测某个具体类别主要依赖原图的哪些区域,需要使用后面的 CAM、Grad-CAM 等方法。

Matthew D. Zeiler 和 Rob Fergus 在 2013 年的论文 Visualizing and Understanding Convolutional Networks 中,使用反卷积网络(Deconvolutional Network)等方法观察 CNN 中间层的激活情况。这样的可视化为理解 CNN 的中间表示提供了直观的经验工具,也帮助研究者改进了当时的网络结构(ZFNet);但它是辅助理解模型的方式,不是对模型全部决策过程的数学证明。

7.2.2.2 自定义特征图勾子

要可视化某一层的特征图,首先需要在模型前向传播时把该层的输出保存下来。PyTorch 提供了 forward hook(前向钩子)接口来完成这件事:先在目标层上挂上一个“钩子”,图片经过该层后,钩子就会自动得到这一层的输入和输出。

hook 可以写成普通函数,也可以像下面这样写成一个可调用类。本例选择类的形式,是因为它可以把本次前向传播中得到的层对象、层输入和层输出都保存在自己的属性中,后面读取比较方便。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import torch

class FeatureHook:
"""forward hook 的回调对象:在目标层完成前向计算时保存层、输入和输出。"""

def __init__(self) -> None:
# 三个属性在 hook 触发前都没有值。完整前向传播后它们仍为 None,说明目标层
# 没有被执行,或 hook 没有成功注册。
#
# module 保存的是模型中真实层对象的“引用”,不是复制的层;可以通过它查看层的
# 类型、超参数和权重,例如 hook.module.weight(仅适用于有 weight 的层)。
self.module: torch.nn.Module | None = None

# inputs 是目标层接收到的位置参数组成的元组。对当前 VGG 的 ReLU 层而言,
# 元组中只有一个张量,inputs[0] 的形状为 (1, 128, 112, 112)。
# 为避免保存的输入继续关联自动求导图,稍后会对其中每个张量执行 detach/cpu/clone。
self.inputs: tuple[torch.Tensor, ...] | None = None

# output 是目标层的输出特征图;同样会保存一个脱离计算图的 CPU 副本。
self.output: torch.Tensor | None = None

def __call__(
self,
module: torch.nn.Module,
inputs: tuple[torch.Tensor, ...],
output: torch.Tensor,
) -> None:
"""这是 PyTorch 在目标层 forward 后自动调用的方法。

参数 module 是被挂钩的层,inputs 是该层输入组成的元组,output 是该层输出。
PyTorch 会在目标层的 forward 执行结束后自动传入这三项。
"""
# 保存目标层对象本身。这里不 clone:nn.Module 通常包含参数和子模块,直接保存
# 引用才能表示“模型中实际执行过的那一层”。
self.module = module

# inputs 的类型是“张量元组”。逐个处理后仍保持元组结构:
# detach() 脱离自动求导图;cpu() 移到 CPU;clone() 创建独立副本。
# 这样即使原模型在 GPU 上,或后续代码原地修改原输入,本属性中的副本也不受影响。
self.inputs = tuple(
input_tensor.detach().cpu().clone() for input_tensor in inputs
)

# 对 output 做相同处理;它是需要绘制的输出特征图。
self.output = output.detach().cpu().clone()

# 注意:这是 register_forward_hook() 的回调,调用时机在目标层执行“之后”。
# 当前目标层是 ReLU(inplace=True),它会原地改写输入张量;因此本 forward hook
# 中保存的 inputs[0] 在数值上可能已经是 ReLU 处理后的结果。若必须保存层计算
# 前、绝不受原地操作影响的原始输入,应改用 register_forward_pre_hook()。

写好用于保存数据的 hook 后,再把它注册到想观察的网络层中。例如本例要观察 VGG-11 的第二个 ReLU 层:

1
2
3
4
5
6
7
8
9
10
11
# VGG 的 features 是 nn.Sequential,可像列表一样按下标访问其中的层。
layer_index = 4
# model.features 可按下标被索引,索引序号从0开始。
# 所以,此处 target_layer 表示 VGG11 中的第二个 ReLU。它是需要可视化输出特征图的层。
# 它前面是一个 Conv2d
target_layer = model.features[layer_index]

# 创建 hook 回调对象,再把它注册到目标层。register_forward_hook() 返回 handle;
# 后续一定要调用 handle.remove(),否则多次调用本函数会不断叠加旧 hook。
hook = FeatureHook()
hook_handle = target_layer.register_forward_hook(hook)
完成注册后,还必须让图片真正通过一次 model(inputs) 前向传播。图片到达目标层、该层完成计算后,hook 才会被调用;这时保存下来的 hook.output,就是需要可视化的当前层输出特征图。

当前示例注册的是 ReLU(inplace=True)。它会直接把输入 Tensor 中的负数改为 0;而 forward hook 在 ReLU 执行完成后才调用。因此,这里保存的 hook.inputs[0] 在数值上可能已经和 hook.output 相同,无法再看到 ReLU 处理前的负值。若确实需要查看 ReLU 的原始输入,则应改用 register_forward_pre_hook(),使 hook 在 ReLU 执行前立即复制保存输入。

1
2
3
4
5
6
7
8
9
10
11
Conv2d 输出 Tensor
↓
作为 ReLU 的 inputs[0]
↓
ReLU(inplace=True) 将其中全部负数原地改为 0
↓
ReLU forward 结束
↓
forward hook 才被调用
↓
此时 hook 收到的 inputs[0] 已经被改写

7.2.2.3 示例代码

仍以VGG-11 模型为例,可视化其第二个ReLU层的输出特征图。完整可执行示例代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
"""使用 forward hook 可视化 CNN 中间层输出的特征图(feature maps)。

本示例完成如下流程:

本地汽车图片
-> VGG11 预训练权重附带的图像预处理
-> VGG11 的 features[4](第二个卷积块中的 ReLU)
-> forward hook 捕获输出特征图
-> 将第一个样本的前 64 个通道画成 8×8 网格并保存为 PNG

运行方式(在项目根目录执行):

conda run -n ai_py312 python source/07第七章/21-CNN特征图可视化方法.py

第一次运行若本机没有 VGG11 预训练权重,torchvision 会自动下载它。运行成功后,
本脚本会在本文件所在目录生成或覆盖“21-CNN特征图可视化结果.png”。
"""

import os # 在导入 Matplotlib 前设置其缓存目录。
import tempfile # 获取当前系统可写的临时目录。
from pathlib import Path # 使用 Path 拼接项目内的图片路径和输出路径。

# 必须在导入 matplotlib.pyplot 之前设置后端。
# Agg 是不需要图形界面的绘图后端,因此在终端、远程服务器中也能正常保存 PNG。
# 受限终端中用户主目录的 .matplotlib 可能不可写;把缓存放入系统临时目录可避免
# 首次运行时的权限警告。setdefault 不会覆盖用户已经主动设置的 MPLCONFIGDIR。
os.environ.setdefault(
"MPLCONFIGDIR", str(Path(tempfile.gettempdir()) / "pytorch_feature_maps_matplotlib")
)
import matplotlib

matplotlib.use("Agg")

import matplotlib.pyplot as plt # 绘制原图和特征图网格。
from matplotlib.font_manager import FontProperties # 直接从字体文件创建中文字体对象。
import torch # 张量计算、设备选择,以及 no_grad()。
from PIL import Image # 打开本地 RGB 图片。
from torchvision.models import VGG11_Weights, vgg11 # VGG11 与其 ImageNet 预训练权重。


def find_chinese_font() -> Path:
"""返回当前 macOS 上可用的一种中文字体文件路径。

不能只把字体的“名称”放入 plt.rcParams:当 Matplotlib 的字体缓存过旧,或字体名称
匹配失败时,它可能错误地回退到 DejaVu Sans,从而出现“Glyph ... missing”警告。
直接传入字体文件路径可以避免这个问题。
"""

# 依次尝试 macOS 常见的内置中文字体;本机通常至少存在其中之一。
candidate_paths = (
Path("/System/Library/Fonts/Supplemental/Arial Unicode.ttf"),
Path("/System/Library/Fonts/Hiragino Sans GB.ttc"),
Path("/System/Library/Fonts/STHeiti Medium.ttc"),
Path("/System/Library/Fonts/Supplemental/Songti.ttc"),
)
for font_path in candidate_paths:
if font_path.is_file():
return font_path

raise FileNotFoundError(
"没有找到可显示中文的 macOS 系统字体。请安装中文字体,或在 find_chinese_font() "
"的 candidate_paths 中加入已安装字体的 .ttf/.ttc 文件路径。"
)


# 直接通过字体文件创建 FontProperties。后面每一个含中文的标题都会显式使用它,
# 因而不会意外回退到不含中文字符的 DejaVu Sans。
CHINESE_FONT_PATH = find_chinese_font()
print(f"使用的中文字体文件:{CHINESE_FONT_PATH}")
CHINESE_FONT_SMALL = FontProperties(fname=CHINESE_FONT_PATH, size=8)
CHINESE_FONT_LARGE = FontProperties(fname=CHINESE_FONT_PATH, size=14)


# resolve = Path(__file__).resolve() # 当前脚本的绝对路径
# print(f"当前脚本绝对路径:{resolve}") # 当前脚本绝对路径
# print(f"当前脚本父目录:{resolve.parents}") # 当前脚本所在目录的父目录列表
# print(f"resolve.parents[0]: {resolve.parents[0]}") # 当前脚本所在目录
# print(f"项目根目录resolve.parents[1]:{resolve.parents[1]}") # 当前脚本所在目录的父目录,即项目根目录
# print(f"resolve.parents[2]: {resolve.parents[2]}") # 当前脚本所在目录的父目录的父目录

# 本文件位于 source/07第七章/,parents[1] 就是项目内的 source/ 目录。
SOURCE_DIR = Path(__file__).resolve().parents[1]

# 选用项目中已存在的一张 Carvana 汽车 RGB 图片作为模型输入。
# 如需观察其他图片的特征图,只要将此路径换成另一张 RGB 图片即可。
IMAGE_PATH = (
SOURCE_DIR
/ "carvana-image-masking-challenge-data"
/ "imgs"
/ "ce74dfdf123b_04.jpg"
)

# 输出图片保存到本脚本所在的“07第七章”目录。每次运行会覆盖同名旧图。
OUTPUT_PATH = Path(__file__).resolve().parent / "21-CNN特征图可视化结果.png"

# 要观察 VGG11 特征提取器中的哪一层。可以自由更改
# VGG11 的 features[3] 是 Conv2d(64, 128, 3×3),features[4] 是紧随其后的 ReLU。
# 如果选择 features[4],所以得到的是已经过 ReLU 的非负激活特征图;
# 如果选择 features[3] (将TARGET_LAYER_INDEX 设置为 3),则可观察卷积层的原始输出,其中通常也包含负值。
TARGET_LAYER_INDEX = 4

# 一张特征图网格中最多展示的通道数。features[4] 实际有 128 个输出通道,
# 但同时显示 128 张图较拥挤,故本例只显示前 64 张。
MAX_CHANNELS_TO_SHOW = 64


class FeatureHook:
"""forward hook 的回调对象:在目标层完成前向计算时保存层、输入和输出。"""

def __init__(self) -> None:
# 三个属性在 hook 触发前都没有值。完整前向传播后它们仍为 None,说明目标层
# 没有被执行,或 hook 没有成功注册。
#
# module 保存的是模型中真实层对象的“引用”,不是复制的层;可以通过它查看层的
# 类型、超参数和权重,例如 hook.module.weight(仅适用于有 weight 的层)。
self.module: torch.nn.Module | None = None

# inputs 是目标层接收到的位置参数组成的元组。对当前 VGG 的 ReLU 层而言,
# 元组中只有一个张量,inputs[0] 的形状为 (1, 128, 112, 112)。
# 为避免保存的输入继续关联自动求导图,稍后会对其中每个张量执行 detach/cpu/clone。
self.inputs: tuple[torch.Tensor, ...] | None = None

# output 是目标层的输出特征图;同样会保存一个脱离计算图的 CPU 副本。
self.output: torch.Tensor | None = None

def __call__(
self,
module: torch.nn.Module,
inputs: tuple[torch.Tensor, ...],
output: torch.Tensor,
) -> None:
"""这是 PyTorch 在目标层 forward 后自动调用的方法。

参数 module 是被挂钩的层,inputs 是该层输入组成的元组,output 是该层输出。
PyTorch 会在目标层的 forward 执行结束后自动传入这三项。
"""
# 保存目标层对象本身。这里不 clone:nn.Module 通常包含参数和子模块,直接保存
# 引用才能表示“模型中实际执行过的那一层”。
self.module = module

# inputs 的类型是“张量元组”。逐个处理后仍保持元组结构:
# detach() 脱离自动求导图;cpu() 移到 CPU;clone() 创建独立副本。
# 这样即使原模型在 GPU 上,或后续代码原地修改原输入,本属性中的副本也不受影响。
self.inputs = tuple(
input_tensor.detach().cpu().clone() for input_tensor in inputs
)

# 对 output 做相同处理;它是需要绘制的输出特征图。
self.output = output.detach().cpu().clone()

# 注意:这是 register_forward_hook() 的回调,调用时机在目标层执行“之后”。
# 当前目标层是 ReLU(inplace=True),它会原地改写输入张量;因此本 forward hook
# 中保存的 inputs[0] 在数值上可能已经是 ReLU 处理后的结果。若必须保存层计算
# 前、绝不受原地操作影响的原始输入,应改用 register_forward_pre_hook()。


def load_and_preprocess_image(
image_path: Path, weights: VGG11_Weights
) -> tuple[Image.Image, torch.Tensor]:
"""读取一张 RGB 图片,并按 VGG11 预训练权重的要求将其转换为模型输入张量。"""

if not image_path.is_file():
raise FileNotFoundError(f"找不到待可视化的图片:{image_path}")

# convert("RGB") 保证输入始终是 3 个颜色通道;即使原图为灰度图或 RGBA 图也可处理。
original_image = Image.open(image_path).convert("RGB")

# weights.transforms() 是 torchvision 0.21 推荐的权重配套预处理:
# 它会缩放、中心裁剪到 224×224、转换为 float32 Tensor,并用 ImageNet 的均值/标准差
# 标准化。不要随意换成其他均值/标准差,否则模型输入分布会与预训练阶段不一致。
preprocess = weights.transforms()
image_tensor = preprocess(original_image)

# VGG11 需要形状为 (N, C, H, W) 的四维输入;单张图片原本是 (C, H, W),
# unsqueeze(0) 在最前面补一个 batch 维度,得到 (1, 3, 224, 224)。
return original_image, image_tensor.unsqueeze(0)


def capture_feature_maps(
model: torch.nn.Module, layer_index: int, inputs: torch.Tensor
) -> FeatureHook:
"""执行一次前向传播,返回保存了目标层 module、inputs、output 的 hook 对象。"""

# VGG 的 features 是 nn.Sequential,可像列表一样按下标访问其中的层。
target_layer = model.features[layer_index]

# 创建 hook 回调对象,再把它注册到目标层。register_forward_hook() 返回 handle;
# 后续一定要调用 handle.remove(),否则多次调用本函数会不断叠加旧 hook。
hook = FeatureHook()
hook_handle = target_layer.register_forward_hook(hook)

try:
# eval() 切换到推理模式。VGG11 虽然 features 部分没有 BatchNorm,但养成在
# 可视化预训练模型时先调用 eval() 的习惯很重要:含 BatchNorm/Dropout 的模型
# 在 train() 和 eval() 下的输出可能不同。
model.eval()

# 这里只做推理与可视化,不计算梯度。no_grad() 可减少内存占用并加快前向传播。
with torch.no_grad():
_ = model(inputs)
finally:
# 无论前向传播是否报错都移除 hook,避免它残留在模型内。
hook_handle.remove()

if hook.module is None or hook.inputs is None or hook.output is None:
raise RuntimeError(
f"hook 没有完整捕获 features[{layer_index}] 的层、输入和输出,"
"请检查层编号和模型前向传播。"
)

# 调用者可以从返回值中访问:
# hook.module:被挂钩的层对象;
# hook.inputs:该层输入元组,例如 hook.inputs[0];
# hook.output:该层输出特征图。
return hook


def normalize_for_display(feature_map: torch.Tensor) -> torch.Tensor:
"""将单张二维特征图线性映射到 [0, 1],便于以灰度图显示。

不同通道的激活值范围经常不同,因此本函数对“每一个通道”单独归一化。
这样能看清每张图的空间纹理;代价是不同通道之间的亮度不能用来比较绝对激活大小。
"""

minimum = feature_map.min()
maximum = feature_map.max()

# 若一张特征图所有像素完全相同,maximum - minimum 为 0。
# 此时返回全 0 图,避免除以 0 产生 NaN。
if torch.isclose(maximum, minimum):
return torch.zeros_like(feature_map)

return (feature_map - minimum) / (maximum - minimum)


def plot_feature_maps(
original_image: Image.Image,
feature_maps: torch.Tensor,
layer_index: int,
output_path: Path,
max_channels: int,
) -> None:
"""把原始图片与第一个样本的若干特征图绘制到一个 Figure,并保存为 PNG。"""

# hook 输出必须是 CNN 常用的四维形状 (N, C, H, W)。
if feature_maps.ndim != 4:
raise ValueError(
f"期望特征图形状为 (N, C, H, W),实际得到:{tuple(feature_maps.shape)}"
)

# 本例只有 1 张输入图片,所以取 feature_maps[0]。
# 取完后形状由 (1, C, H, W) 变成 (C, H, W),每个通道对应一张二维特征图。
first_sample_maps = feature_maps[0]
total_channels = first_sample_maps.shape[0]

# 可视化通道数不超过模型实际通道数,也不超过预先设置的上限。
channels_to_show = min(total_channels, max_channels)

# 计算接近正方形的网格尺寸。显示 64 张图时得到 8 行×8 列;
# 若以后观察的层通道数不是完全平方数,ceil() 仍可保证格子足够。
columns = int(torch.ceil(torch.sqrt(torch.tensor(channels_to_show))).item())
rows = (channels_to_show + columns - 1) // columns

# Figure 的第一行预留给原图;余下 rows 行放特征图。
figure, axes = plt.subplots(
nrows=rows + 1,
ncols=columns,
figsize=(columns * 2, (rows + 1) * 2),
constrained_layout=True,
)

# axes 在 rows、columns 都大于 1 时是二维数组;本例固定将其按行、列索引使用。
# 第 0 行的第 0 个子图显示原始 RGB 图片。
axes[0, 0].imshow(original_image)
# 标题含中文,明确传入由字体文件创建的 FontProperties,避免字体回退导致中文缺字。
axes[0, 0].set_title("输入原图", fontproperties=CHINESE_FONT_SMALL)
axes[0, 0].axis("off")

# 原图只需要占一个子图,第 0 行剩余位置没有内容,故关闭它们的坐标轴。
for column_index in range(1, columns):
axes[0, column_index].axis("off")

# 逐通道绘制特征图。channel_index=0 表示该层第 0 个输出通道的激活图。
for channel_index in range(channels_to_show):
# // 得到该特征图在网格中的行号,% 得到列号。
# 要加 1 是因为 axes 的第 0 行已经留给输入原图。
row_index = channel_index // columns + 1
column_index = channel_index % columns
axis = axes[row_index, column_index]

# first_sample_maps[channel_index] 的形状为 (H, W),如 (112, 112)。
# 单通道单独归一化后以灰度显示:亮处表示该通道在该空间位置激活相对更强。
image_to_show = normalize_for_display(first_sample_maps[channel_index])
axis.imshow(image_to_show.numpy(), cmap="gray", vmin=0.0, vmax=1.0)
axis.set_title(
f"通道 {channel_index}",
fontproperties=CHINESE_FONT_SMALL,
)
axis.axis("off")

# 若网格格子数大于实际需要显示的通道数,关闭最后多出来的空子图。
for empty_index in range(channels_to_show, rows * columns):
row_index = empty_index // columns + 1
column_index = empty_index % columns
axes[row_index, column_index].axis("off")

# 图标题说明“这一批图来自哪里、总共有多少通道、当前展示了多少张”。
figure.suptitle(
f"VGG11 features[{layer_index}] 特征图:"
f"共 {total_channels} 个通道,展示前 {channels_to_show} 个",
fontproperties=CHINESE_FONT_LARGE,
)

# 先确保父目录存在,再保存。dpi=150 在清晰度与文件大小之间较平衡。
output_path.parent.mkdir(parents=True, exist_ok=True)
figure.savefig(output_path, dpi=150)
plt.close(figure) # 关闭 Figure,避免多次调用时不断占用 Matplotlib 内存。


def main() -> None:
# CUDA 可用时把模型和输入放到 GPU;否则在 CPU 上也能完整运行。
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 使用 ImageNet1K 预训练权重。该 weights 对象同时提供预处理配置与类别元数据。
weights = VGG11_Weights.IMAGENET1K_V1
model = vgg11(weights=weights).to(device)

original_image, inputs = load_and_preprocess_image(IMAGE_PATH, weights)
inputs = inputs.to(device)

# captured 同时保存目标层对象、目标层输入和目标层输出。
# 此处的断言也让后续代码可以明确把这三项当作非 None 的对象使用。
captured = capture_feature_maps(model, TARGET_LAYER_INDEX, inputs)
assert captured.module is not None
assert captured.inputs is not None
assert captured.output is not None

captured_module = captured.module
captured_inputs = captured.inputs
feature_maps = captured.output

plot_feature_maps(
original_image=original_image,
feature_maps=feature_maps,
layer_index=TARGET_LAYER_INDEX,
output_path=OUTPUT_PATH,
max_channels=MAX_CHANNELS_TO_SHOW,
)

print(f"运行设备:{device}")
print(f"输入图片:{IMAGE_PATH}")
# captured_module 是 hook 回调实际收到的层对象;它应与 model.features[...] 是同一对象。
print(f"捕获层:model.features[{TARGET_LAYER_INDEX}] = {captured_module}")
print(f"保存的 module 是否就是目标层:{captured_module is model.features[TARGET_LAYER_INDEX]}")
print(f"保存的 inputs 个数:{len(captured_inputs)}")
for input_index, captured_input in enumerate(captured_inputs):
print(f"保存的 inputs[{input_index}] 形状:{tuple(captured_input.shape)}")
print(f"特征图形状:{tuple(feature_maps.shape)}")
print(f"已保存可视化结果:{OUTPUT_PATH}")


if __name__ == "__main__":
main()

7.2.2.4 可视化结果分析

上述示例代码执行时的输出如下:

1
2
3
4
5
6
7
8
9
10
(ai_py312) jsy@jmac 07第七章 % python 21-CNN特征图可视化方法.py
使用的中文字体文件:/System/Library/Fonts/Supplemental/Arial Unicode.ttf
运行设备:cpu
输入图片:xxx/source/carvana-image-masking-challenge-data/imgs/ce74dfdf123b_04.jpg
捕获层:model.features[4] = ReLU(inplace=True)
保存的 module 是否就是目标层:True
保存的 inputs 个数:1
保存的 inputs[0] 形状:(1, 128, 112, 112)
特征图形状:(1, 128, 112, 112)
已保存可视化结果:xxx/source/07第七章/21-CNN特征图可视化结果.png

除上述终端输出外,程序还会将 ReLU 输出特征图的可视化结果保存为一个单独的 PNG 文件。 2c372c57-ff19-4ccb-988c-a4e01041db5b.png

这个 PNG 文件中,主要包含两个部分内容:

  1. 最开始的一行显示的是从磁盘读取的原始 RGB 图片,用作观察特征图时的视觉参照。严格说,它不是模型实际接收的 Tensor:示例会先按 VGG11 权重配套的预处理规则将图片缩放、中心裁剪为 224×224,并进行 ImageNet 标准化,然后才送入模型。
  2. 下方以 8×8 网格显示了此处 ReLU 层输出特征图的一部分。该输出的形状是 (1, 128, 112, 112),依次表示 1 张输入图片、128 个输出通道、每个通道一张 112×112 的二维特征图。限于篇幅,代码只显示前 64 个通道。每张小图都按自身的最小值、最大值映射到灰度范围:较亮处表示该通道内部相对较强的激活,较暗处表示相对较弱的激活;不能根据不同小图的亮度直接比较不同通道的绝对激活大小。

可以看到这 64 个小图的纹理与明暗分布不同,说明不同输出通道对输入图片中的不同局部模式产生了不同响应。这里的“不同模式”不应立即解释为具体语义物体或部件;它们只是第二个卷积块中的中间表示。若想知道某个最终类别预测主要受原图哪些区域影响,应继续使用 CAM 或 Grad-CAM 等类别相关可视化方法。

7.2.3 CNN的CAM可视化及其衍进

7.2.3.1 CAM 的介绍

7.2.3.1.1 CAM的作用

Class Activation Mapping(CAM,类激活映射) 是一种用于深度学习模型(特别是卷积神经网络 CNN)“可解释性”的可视化技术。由Bolei Zhou等在2016年的论文 Learning Deep Features for Discriminative Localization 中提出。

简单来说,它就像是一张神经网络的“注意力热力图”:当模型把一张图片分类为“狗”时,CAM 能够以热力图的形式直接叠加在原图上,精准标示出模型究竟是看到了图片的哪个局部区域(比如狗的头部或耳朵),才做出了这个分类决定。即以醒目地方式标示出对预测结果最重要的区域。

7.2.3.1.2 CAM的工作原理

CAM 集中用于分类模型的CNN可视化。CAM 算法要求网络倒数第二层必须是“全局平均池化(GAP)”,且最后一层必须是全连接层。将模型最后一个卷积层输出的多个特征图(Feature Maps),按照它们对特定类别贡献的大小,进行“加权求和”。即将模型最后一个卷积层输出的多个特征图按照对应的权重乘起来并叠加在一起,最终得到一张反映“具体某分类结果比如猫”这个类别激活程度的高亮区域图。

打个比方: 假设最后一个卷积层输出了 512 个特征图:

  • 第 1 个特征图可能抓取到了“毛发纹理”;
  • 第 2 个特征图可能抓取到了“圆形的眼睛”;
  • 第 3 个特征图可能抓取到了“尖尖的耳朵”。

当模型识别“猫”这个类别时,全连接层的权重会告诉我们:“耳朵”和“眼睛”的特征图最重要(权重高),而“背景”特征图不重要(权重接近 0)。 CAM 就是把这 512 张特征图按照对应的权重乘起来并叠加在一起,最终得到一张反映“猫”这个类别激活程度的高亮区域图。

7.2.3.1.3 CAM 热力图如何解读?

生成的 CAM 图通常以伪彩色(Colormap,如 Jet 或 Rainbow)叠加在原图上:

  • 红色 / 暖色区域:高激活区。代表模型做决策时最关注、贡献最大的核心特征位置(例如猫的脸部)。
  • 蓝色 / 寒色区域:低激活区。代表模型认为与该类别无关或贡献极小的区域(例如背景墙面)。
7.2.3.1.4 CAM安装与示例

参考此开源项目的github仓库地址:https://github.com/zhoubolei/CAM。

由于CAM 算法要求网络倒数第二层必须是“全局平均池化(GAP)”,且最后一层必须是全连接层。就说是此算法对模型网络结构上面有非常严苛的限制,可以说这是它的一个“死穴”,导致通用性较差,学术界后续演化出了更强大的工具族。

此项目已经5年未更新,不推荐使用。但此CAM作为开山之作,首次给出了“直接的经验实证(Empirical Proof)”,即通过“眼见为实”的直接可视化解释了卷积层在干什么、是怎么工作的(在这之前,人们已经感知到“低层提取简单结构(线条/边缘),高层提取复杂实体形状”,也通过“理论推导与间接证明” 验证这一点,但仅仅局限于抽象层面),仍具有重要意义。

7.2.3.2 Grad-CAM 的介绍(推荐)

Grad-CAM 是CAM的演进版本。

7.2.3.2.1 为什么提出Grad-CAM

由于CAM存在以下致命缺陷:CAM 破坏了模型结构,且适用范围极窄

  • 必须包含全局平均池化(GAP, Global Average Pooling):CAM 算法的公式推导严重依赖于网络倒数第二层必须是 GAP 层,且最后一层必须是全连接层(FC Layer)。
  • 模型需要重构甚至重新训练:如果原模型(如早期的 VGG、AlexNet、甚至包含多层全连接层的自定义网络)没有 GAP 层,或者全连接层不止一层,CAM 就完全无法直接使用。你必须修改网络结构(删掉 FC 层、加上 GAP),然后再重新训练模型,这对于已上线或结构复杂的模型来说成本极高。
  • 无法用于非分类任务:CAM 依赖类别 score 对 GAP 后的特征图权重的显式映射,因此很难直接应用于图像描述(Image Captioning)、视觉问答(VQA)、目标检测等复杂的多模态/复合任务。

为此Ramprasaath R. Selvaraju 等人提出了Grad-CAM (2017年的论文 Visual Explanations from Deep Networks via Gradient-based Localization 中提出)。

Grad-CAM 实现了如下突破性改进:

  • 结构零侵入(Model-Agnostic):完全不需要修改现有网络结构,也不需要重新训练。无论是 ResNet、VGG、DenseNet 还是目标检测网络,只要是基于 CNN 的模型,拿来就能直接用。
  • 适用任意任务:只要网络是可导的,无论输出是分类得分、生成的文本词汇、还是目标的检测框坐标,都可以通过求导生成热力图。 如需了解其实现细节,继续深入阅读原论文。

CAM与Grad-CAM的精简对比总结如下:

特性 CAM (CVPR 2016) Grad-CAM (ICCV 2017)
网络结构要求 极严(必须带有 GAP + 单层 FC) 毫无限制(适用于任意 CNN 架构)
是否需要改动/重训网络 是(若无 GAP 则需修改并重新训练) 否(即插即用)
权重的获取方式 直接读取 FC 层的参数矩阵权重 通过反向传播计算梯度(Gradient)
适用任务范围 仅限图像分类 分类、目标检测、VQA、图像描述等
历史地位 开启了基于特征图加权的热力图先河 成为深度学习可解释性(XAI)的通用基准算法
7.2.3.2.2 grad-cam 的工作原理

Grad-CAM 的名称可以拆开理解:Grad 是 Gradient(梯度),CAM 是 Class Activation Mapping(类激活映射)。它不再像原始 CAM 那样直接读取“全连接层中已经存在的类别权重”,而是反过来问模型:

如果希望“猫”这个类别的得分更高,最后一个卷积层的哪些特征图、哪些位置最需要发生变化?

这个“需要怎样变化”的信息,就保存在梯度中。因此,Grad-CAM 的关键思想可以概括为:用目标类别得分对最后一个卷积层特征图的梯度,计算每个特征图对该类别的重要程度;再按重要程度把这些特征图加权合成一张热力图。

以“输入一张同时有猫和狗的图片,并解释模型为什么认为它是狗”为例,整个过程可以分为以下几步:

  1. 正常做一次前向传播,确定要解释的类别

    图片先经过卷积层、池化层和分类器,模型会给每个类别输出一个分数。假设本次关注的是“狗”类别,记它的分类分数为 \(y^c\),其中 \(c\) 表示目标类别编号。

    这里通常使用分类器输出的原始分数(logit),而不是先经过 Softmax 得到的概率。可以简单理解为:Grad-CAM 要直接观察“让狗这一类得分变高”的依据。

  2. 取出一个较靠后的卷积层输出的特征图

    假设该卷积层一共输出 \(K\) 个通道,则可记为 \(A^1, A^2, \ldots, A^K\)。每个 \(A^k\) 都是一张二维特征图,图上的每个位置对应原图中的一个较大区域。

    和前面观察 CNN 特征图时一样,不同通道会对不同的图像模式产生响应。例如某些通道可能更容易响应于毛发、眼睛、轮廓或局部纹理。Grad-CAM 通常选择最后一个卷积层:它已经包含较高层的类别语义,同时仍保留“特征来自图片哪个位置”的二维空间信息。

  3. 从目标类别分数反向传播,计算梯度

    Grad-CAM 不训练模型,也不修改模型参数;它只针对本次输入,计算:

    \[ \frac{\partial y^c}{\partial A^k_{ij}} \]

    其中,\(A^k_{ij}\) 表示第 \(k\) 张特征图中第 \(i\) 行、第 \(j\) 列的一个数值。这个梯度可以通俗地理解为:若稍微增大该位置的激活值,目标类别“狗”的分数会受到多大影响。

    • 梯度为正且较大:该位置的激活增强通常会提高“狗”的得分;
    • 梯度接近 0:该位置对“狗”得分几乎没有影响;
    • 梯度为负:该位置的激活增强反而会降低“狗”的得分。
  4. 把每张特征图的梯度汇总为一个通道权重

    一张特征图上有许多位置,Grad-CAM 会对其梯度做全局平均池化(GAP),得到该通道对目标类别的总体重要性权重:

    \[ \alpha_k^c = \frac{1}{Z}\sum_i\sum_j \frac{\partial y^c}{\partial A^k_{ij}} \]

    其中,\(Z\) 是该特征图的空间位置总数。例如特征图大小为 \(14\times14\) 时,\(Z=196\)。\(\alpha_k^c\) 越大,说明第 \(k\) 个通道整体上越有助于提高“狗”这个目标类别的得分。

    这正是 Grad-CAM 相比 CAM 最重要的区别:CAM 使用分类器中固定存在的权重;Grad-CAM 每次都通过反向传播,根据当前图片、当前目标类别的梯度动态算出权重。

  5. 按权重叠加特征图,得到类别相关热力图

    有了每个通道的权重后,将所有特征图加权求和,并经过 ReLU:

    \[ L_{\mathrm{Grad\text{-}CAM}}^c = \operatorname{ReLU}\left(\sum_k \alpha_k^c A^k\right) \]

    ReLU 会将负值置为 0,因此最终热力图重点保留“对目标类别有正向支持作用”的区域,而不突出“会降低该类别得分”的区域。得到的 \(L_{\mathrm{Grad\text{-}CAM}}^c\) 就是一张较小的二维热力图。

  6. 放大并叠加回原图,便于人眼观察

    最后一个卷积层的特征图通常只有 \(7\times7\) 或 \(14\times14\),而输入图片可能是 \(224\times224\)。因此需要先把热力图插值放大到输入图片大小,再使用伪彩色叠加到原图上。

    红色、黄色等暖色区域表示:在本次解释的目标类别下,该位置相对更有助于提高类别得分;蓝色等冷色区域表示相对贡献较小。这里的颜色表示同一张热力图内部的相对重要性,并不等价于“该像素属于目标物体的概率”,也不能把热力图当作精确的目标检测框或分割掩码。

把上述过程连起来,可以简记为:

1
2
3
4
5
6
输入图片
→ 前向传播,得到目标类别分数 y^c
→ 目标分数对最后卷积层特征图反向传播,得到梯度
→ 对每个通道的梯度做全局平均,得到通道权重 α_k^c
→ 通道权重 × 对应特征图,再加权求和并经过 ReLU
→ 放大热力图并叠加到原图

因此,同一张“猫和狗”图片可以分别指定“狗”与“猫”作为目标类别:虽然模型和输入图片都不变,但目标类别分数 \(y^c\) 不同,反向传播得到的梯度、通道权重和最终热力图也会不同。这就是 Grad-CAM 能够做到“解释同一张图片中不同类别关注位置”的原因。

7.2.3.2.3 当前使用的pytorch-grad-cam

由于原作者(首次提出Grad-CAM的作者)早期的代码多基于 Caffe 或旧版 Torch,目前在 Python/PyTorch 开发中,大家普遍使用的 Grad-CAM 官方标准开源库 是由 Jacob Gildenblat 维护的 pytorch-grad-cam(支持 CAM、Grad-CAM、Grad-CAM++、Eigen-CAM 等几乎所有衍生算法)。 即原作者提出的 Grad-CAM 算法(GitHub项目地址是:https://github.com/ramprs/grad-cam/)的“学术源头与开山官方实现”,pytorch-grad-cam(GitHub项目地址是:https://github.com/jacobgil/pytorch-grad-cam,)是开源社区基于前者思想推演、迭代并高度工程化封装后的“现代主流标准库”。

pytorch-grad-cam项目的官方文档网站:https://jacobgil.github.io/pytorch-gradcam-book/introduction.html。

学术界为了改进它的各种局限性,后来提出与实现了多个演进版本,形成了多个 CAM 算法家族衍生品,详见 CAM 算法家族衍生品 。

下图来自pytorch-grad-cam项目的官方文档网站: image.png 这张图展示了 Grad-CAM 论文中最经典的核心效果示例(Visual Examples),证明 Grad-CAM 具备良好的类别区分能力(Class-discriminative Property)以及细粒度特征可视化能力(Guided Grad-CAM)。

原图包含了一只哈巴狗(Pug)和一只斑纹猫(Tabby Cat),图中从左到右三张子图分别展示了不同算法与视角下的可视化结果:

  1. 第一张图:针对“狗(pug, pug-dog)”类别的 Grad-CAM 热力图

    • 标题含义:“是什么让网络认为图像标签是‘哈巴狗’?”
    • 图示结果:暖色/红色高亮区域精准覆盖在上方那只狗的头部与身体上,而下方的猫几乎处于深蓝色的未激活状态。
    • 说明含义:当告诉模型“我要解释‘狗’这个类别”时,Grad-CAM 能够准确指出模型决策的依据是狗所在的位置。
  2. 第二张图:针对“猫(tabby, tabby cat)”类别的 Grad-CAM 热力图

    • 标题含义:“是什么让网络认为图像标签是‘斑纹猫’?”
    • 图示结果:高亮区域瞬间转移到了下方那只猫的头部与背部斑纹区域,而上方的狗变成了深蓝色。
    • 说明含义:证明了 Grad-CAM 具备高度的类别针对性——即使同一张图片中包含多个目标(既有猫又有狗),它也能根据指定的不同类别,分别给出对应的注意力关注区域。
  3. 第三张图:结合 Guided Backpropagation 的 Guided Grad-CAM 结果

    • 标题含义:“针对‘哈巴狗’类别将 Grad-CAM 与引导反向传播结合”
    • 图示结果:不再是模糊的粗粒度热力图,而是绘制出了极度清晰、像素级别的细粒度纹理线条(狗的眼眶、褶皱、耳朵边缘等)。
    • 说明含义:由于倒数第一层卷积特征图分辨率较低(通常只有 \(7\times 7\) 或 \(14\times 14\)),放大的 Grad-CAM 热力图比较模糊。论文将 Grad-CAM 与 Guided Backpropagation(引导反向传播) 逐像素点乘相乘,提出了 Guided Grad-CAM,既保留了 Grad-CAM 的类别区分度(只保留狗的纹理,猫被过滤掉了),又具备了引导反向传播的高分辨率细粒度边缘特征。
7.2.3.2.4 pytorch-grad-cam的安装与示例

官方文档只提供了通过pip安装pytorch-grad-cam:

1
2
3
4
(ai_py312) jsy@jmac ~ % pip install grad-cam

(ai_py312) jsy@jmac ~ % pip list | grep cam
grad-cam 1.5.7

知道图片的分类标签、直接指定模型预测结果,要求对结果的依据进行可视化:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import torch  # PyTorch:创建张量,并让模型执行前向传播。
from torchvision.models import vgg11, VGG11_Weights # 导入 VGG11 结构及其 ImageNet 预训练权重配置。
import matplotlib.pyplot as plt # 导入 Matplotlib 绘图接口,用于显示原图和 CAM 叠加图。
from PIL import Image # 导入 Pillow 的 Image,用于从磁盘读取图片。
import numpy as np # 导入 NumPy,用于保存和处理 H×W×C 格式的图像数组。

from pytorch_grad_cam import GradCAM # 导入 Grad-CAM:根据特征图与梯度生成类别关注热力图。
from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget # 导入分类目标,指定要解释哪个类别。
from pytorch_grad_cam.utils.image import show_cam_on_image # 导入工具函数,将热力图覆盖到 RGB 原图上。

"""
此文件演示如何使用 pytorch-grad-cam 对 VGG11 的分类依据进行 Grad-CAM 可视化。

其中没有进行模型预测,而是直接指定类别编号 243(bull mastiff,斗牛獒犬)作为解释目标,
实际上就是对此预测结果的依据进行可视化。
"""

# 创建并加载 ImageNet 预训练的 VGG11 模型。
model = vgg11(weights=VGG11_Weights.IMAGENET1K_V1)
# 指定待解释图片的相对路径;路径相对于运行脚本时的当前目录。
# 来自 https://github.com/ramprs/grad-cam/blob/master/images/cat_dog.jpg
img_path = './cat_dog.jpg'
# resize 操作是为了让图片尺寸与传入神经网络的常用输入尺寸一致。
# 读取图片并缩放为 224×224 像素,适配 VGG 的常用输入尺寸。
img = Image.open(img_path).resize((224,224))

# 创建 1 行 2 列子图:左侧显示原图,右侧显示 Grad-CAM 结果。
fig, axes = plt.subplots(1, 2)

# 将原始图片转为 np.float32 格式,并把每个像素值缩放到 [0, 1]。
# 转换结果是形状为 H×W×3 的 RGB 数组。
rgb_img = np.float32(img)/255

# 输出 rgb_img 的 Python 类型,确认其为 NumPy 数组。
print(f"type(rgb_img): {type(rgb_img)}") # <class 'numpy.ndarray'>
# 在左侧子图中显示归一化后的 RGB 原图。
axes[0].imshow(rgb_img)

# 将图片转为模型输入 Tensor:(H,W,C)→(C,H,W),再增加批次维度为 (1,3,224,224)。
img_tensor = torch.from_numpy(rgb_img).permute(2,0,1).unsqueeze(0)

# 选择 VGG11 特征提取器的最后一层 MaxPool2d;列表形式可支持多个目标层。
target_layers = [model.features[-1]]

# 在 ImageNet 1000 分类数据中,每类事物都有一个类索引编号;243 对应 bull mastiff(斗牛獒犬)。
# 此模型所用到的训练数据集中所有分类的编号和名称都可以在 VGG11_Weights.IMAGENET1K_V1.meta["categories"] 中查到。
preds = 243
# 把类别 243 包装成 Grad-CAM 的解释目标,而不是默认解释模型预测的最大类别。
targets = [ClassifierOutputTarget(preds)]

# 创建 Grad-CAM 对象;它会在目标层注册 hook,以保存激活值和对应梯度。
# ScoreCAM 和 AblationCAM 等其他 CAM 方法还需要额外设置 batch_size。
with GradCAM(model=model, target_layers=target_layers) as cam:
# 前向与反向传播后得到灰度 CAM,形状为 (批次大小, 高度, 宽度)。
grayscale_cam = cam(input_tensor=img_tensor, targets=targets)
# 当前批次只有 1 张图,取批次索引 0,结果形状为 (224,224)。
grayscale_cam = grayscale_cam[0]

# 将灰度热力图伪彩色化并叠加到原图,返回 uint8 RGB 数组。
cam_img = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True)
# 输出叠加结果的 Python 类型,确认其为 NumPy 数组。
print(f"type(cam_img): {type(cam_img)}") # <class 'numpy.ndarray'>
# 在右侧子图中显示 Grad-CAM 叠加结果。
axes[1].imshow(cam_img)

# 把当前整张 Figure 保存到当前工作目录;同名文件会被覆盖。
plt.savefig('22-Grad-CAM可视化结果01.png')

上述示例执行后输出的图片结果如下所示: image.png

7.2.4 CNN的FlashTorch可视化

注:由于FlashTorch相关兼容性问题,要在 PyTorch 2.6.x 及以后版本中长期、可靠地实现显著性图或 Guided Backpropagation,建议使用原生 PyTorch 实现,或选择仍在维护的可解释性工具库(如前面介绍的 pytorch-grad-cam)。

7.2.4.1 FlashTorch 的介绍

MisaOgura/flashtorch 是一个专门针对 PyTorch 模型打造的神经网络特征可视化(Feature Visualization)与可解释性(XAI)轻量级 Python 工具包。

它的核心设计初衷是为了解决“神经网络黑盒化”以及“在 PyTorch 中从头编写可解释性可视化算法太繁琐”的问题。开发者只需几行代码,就可以直观地“看透”CNN 等模型内部到底关注了图像的哪些区域。

主要功能模块包括: 1. 显著性图 / 梯度可视化(flashtorch.saliency)

- **普通反向传播梯度图(Saliency Maps)**:计算预测类别相对于输入图像的梯度,高亮显示图像中对最终分类贡献最大的像素区域。
- **引导反向传播(Guided Backpropagation)**:通过在反向传播时过滤负梯度,绘制出像素级别的高分辨率细粒度纹理/轮廓。
  1. 激活极大化(flashtorch.activmax)

    • 激活最大化(Activation Maximization):从随机噪声图像开始,通过梯度上升(Gradient Ascent)不断迭代更新输入像素,生成一张能够“最大程度激活指定神经元或卷积核(Filter)”的合成图像。这常用来观察网络不同深度(如浅层 Edge/Texture、高层 Object Concept)各自学会了什么概念。
  2. 数据与图像便捷处理(flashtorch.utils)

    • 内置针对 torchvision 预训练模型(如 AlexNet、VGG、ResNet 等)的图像预处理、ImageNet 类别索引查询(ImageNetIndex)以及可视化绘制工具。

7.2.4.2 与 pytorch-grad-cam 的定位区别

flashtorch与pytorch-grad-cam都能用于 CNN 可视化,但它们的侧重点和主要应用场景不一样。 主要区别如下:

维度 FlashTorch pytorch-grad-cam
侧重方向 梯度/显著性图(Saliency Maps) 与 激活极大化(Activation Maximization) 类激活映射图(CAM / Grad-CAM / Score-CAM 算法全家桶)
实现原理 侧重直接计算“像素级梯度”或合成“刺激神经元的最佳图案” 侧重在“最后一个卷积层”上进行特征图加权叠加
应用场景 适合分析细粒度线条/边缘/神经元偏好 适合定位目标主体的大致空间位置(粗粒度热力图)

7.2.4.3 flashtorch安装

可以使用 pip 安装这个 Python 包:

1
2
3
4
5
# 第一次安装或在已有安装的基础上升级:
python -m pip install -U flashtorch

# 查看当前环境中实际安装的版本:
python -m pip show flashtorch

7.2.4.4 flashtorch示例与兼容性说明

与仍在维护的 pytorch-grad-cam 相比,flashtorch 已长期没有更新。当前通过 PyPI 安装的版本为 0.1.3;它的源码仍使用旧式的 register_backward_hook()。因此,即使它可以安装到较新的 Python / PyTorch 环境,在 PyTorch 2.6.x 中运行官网示例时仍可能出现兼容性错误或 FutureWarning。

因此,FlashTorch 更适合用来理解显著性图、Guided Backpropagation 和激活最大化的基本思路。若要在 PyTorch 2.6.x 及以后版本中长期、可靠地实现显著性图或 Guided Backpropagation,建议使用原生 PyTorch 实现,或选择仍在维护的可解释性工具库(如前面介绍的 pytorch-grad-cam)。

下面两个示例是在官网示例基础上修改而成。它们均使用当前 torchvision 推荐的 weights=... 形式加载预训练权重。

显著性图示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# 导入 torchvision 中的常见预训练模型;下面会通过 models 创建 AlexNet。
import torchvision.models as models
# 导入 FlashTorch 的图片读取函数和与 ImageNet 预训练模型匹配的图像预处理函数。
from flashtorch.utils import apply_transforms, load_image
# 导入 Backprop 类,用于计算分类结果相对于输入像素的梯度并绘制显著性图。
from flashtorch.saliency import Backprop
# 导入 Matplotlib,用于保存和显示 FlashTorch 创建的图像。
import matplotlib.pyplot as plt

# 创建并加载在 ImageNet 数据集上预训练的 AlexNet 分类模型。
model = models.alexnet(weights=models.AlexNet_Weights.IMAGENET1K_V1)
# 用模型创建显著性图工具;其内部会将模型切换到评估模式并注册所需的梯度 hook。
backprop = Backprop(model)

# 此图来自 https://github.com/MisaOgura/flashtorch/blob/main/examples/images/great_grey_owl.jpg
# 从当前工作目录读取猫头鹰图片,返回 Pillow 的 Image 对象。
image = load_image('./great_grey_owl.jpg')
# 按 ImageNet 预训练模型的要求缩放、转为 Tensor、标准化,并增加批次维度。
owl = apply_transforms(image)

# 记录这张示例图预期对应的 ImageNet 类别编号;24 对应 great grey owl(大灰猫头鹰)。
# 注意:FlashTorch 0.1.3 实际总是解释模型 top-1 预测类别;若其不等于 24,只会发出警告。
target_class = 24
# 创建 FlashTorch 的四幅显著性图。
# guided=True 表示使用 Guided Backpropagation,突出对该类别有正向贡献的细粒度边缘。
# use_gpu=False 表示在 CPU 上运行;若有可用 CUDA GPU,可改为 True。
backprop.visualize(owl, target_class, guided=True, use_gpu=False)

# 调整子图之间的间距,避免标题或图片相互遮挡。
plt.tight_layout()

# 保存结果;先保存,再 show,避免某些 Matplotlib 后端在关闭显示窗口后清空 Figure。
plt.savefig("23-FlashTorch显著性图结果.png", dpi=150, bbox_inches="tight")

# 显示窗口;程序会在这里等待,直到手动关闭图片窗口后才结束。
plt.show()

在当前 PyTorch 2.6.x 环境中,原版 FlashTorch 的 denormalize() 可能报出如下错误,导致不能绘图:

1
RuntimeError: Output 0 of UnbindBackward0 is a view and is being modified inplace.

这是因为它在反标准化图片时,对由张量视图得到的通道进行了原地修改;并不是示例图片或 AlexNet 前向传播本身出错。可将当前虚拟环境中 FlashTorch 的 denormalize() 改为下方的非原地实现。注意:此修改位于 site-packages,日后重新安装或升级环境时可能需要重新应用。

以当前 ai_py312 环境为例,需修改:

1
/opt/anaconda3/envs/ai_py312/lib/python3.12/site-packages/flashtorch/utils/__init__.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 修改前的核心内容(约第 116 行):
denormalized = tensor.clone()

for channel, mean, std in zip(denormalized[0], means, stds):
channel.mul_(std).add_(mean)

return denormalized

# 替换为如下非原地实现:
# 创建形状为 (1, 3, 1, 1) 的均值、标准差张量,
# 使它们能自动广播到输入的 (N, 3, H, W) 图像张量。
mean = tensor.new_tensor(means).view(1, 3, 1, 1)
std = tensor.new_tensor(stds).view(1, 3, 1, 1)

# 使用非原地运算:不会修改任何视图,因此兼容新版 PyTorch。
return tensor * std + mean

修复后运行本示例会生成四个子图:输入图片、RGB 三通道梯度、每个像素位置的最大梯度,以及最大梯度叠加在原图上的效果。FlashTorch 0.1.3 的显著性图与激活最大化实现都仍使用旧式 backward hook,因此在 PyTorch 2.6.x 中仍可能触发 FutureWarning;这是独立的遗留兼容性提示,不能仅通过上述反标准化修改彻底消除。

修复后的显著性图效果示例如下: image.png


激活最大化示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 导入 torchvision 中的常见预训练模型;下面会通过 models 创建 VGG16。
import torchvision.models as models
# 导入 GradientAscent 类:它从随机图像出发,迭代优化出最能激活指定卷积核的图案。
from flashtorch.activmax import GradientAscent
# 导入 Matplotlib,用于保存和显示 FlashTorch 创建的图像。
import matplotlib.pyplot as plt

# 创建并加载在 ImageNet 数据集上预训练的 VGG16 分类模型。
model = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1)
# 把 VGG16 的卷积特征提取部分传给 GradientAscent;全连接分类器不参与本示例的卷积核可视化。
g_ascent = GradientAscent(model.features)

# specify layer and filter info
# 选择 VGG16 的 features[24]:它是第 5 个卷积块的第 1 个 Conv2d 层,通常称为 conv5_1。
conv5_1 = model.features[24]
# 指定要可视化的 4 个输出通道(卷积核)编号;每个编号都会生成一张能强烈激活它的合成图。
conv5_1_filters = [45, 271, 363, 489]

# 对指定层和 4 个卷积核执行梯度上升,并在当前 Figure 中绘制激活最大化结果。
g_ascent.visualize(conv5_1, conv5_1_filters, title="VGG16: conv5_1")

# 调整子图之间的间距,避免标题或图片相互遮挡。
plt.tight_layout()

# 保存结果;先保存,再 show,避免某些 Matplotlib 后端在关闭显示窗口后清空 Figure。
plt.savefig("24-FlashTorch激活最大化结果.png", dpi=150, bbox_inches="tight")

# 显示窗口;程序会在这里等待,直到手动关闭图片窗口后才结束。
plt.show()

激活最大化会对每个指定卷积核各执行多轮梯度上升;在 CPU 上可能需要等待一段时间。脚本会保存结果图片后再显示窗口,关闭窗口后程序才会结束。运行完成后可得到如下结果: image.png

7.3 使用TensorBoard可视化训练过程

深度学习是一个较耗时的过程,为了能够了解模型结构或即时的训练结果,便于及时优化训练策略、及时中止不合期望的训练过程,不仅需要对模型结构与相关层的输出特征图进行可视化,还需要对训练过程的一些关键指标或变量进行监测。

比如我们在训练过程中不断计算与打印的模型损失值与精确率,就是对训练过程的一种监测手段。其实除了它们外,训练过程中还有一些关键指标与变量也很有监测价值,如输入数据及其特征、学习率等连续变量、模型权重参数的分布情况等等。在深度学习领域中,对于这些事物的监测也就是模型训练过程的可视化。

TensorBoard(X)作为一款开源的可视化工具,最初由TensorFlow团队开发并应用于TensorFlow框架范围内,由于其功能的强大与使用的便利性,被越来越多的人接纳,逐渐被推广与应用于各种深度学习框架的可视化中。

本章节学习的内容包括:TensorBoard(X)的介绍与安装、TensorBoard的上层工作逻辑、TensorBoard的配置与启动、利用TensorBoard进行模型结构可视化、利用TensorBoard进行训练过程可视化。

7.3.1 TensorBoard(X)的介绍与安装

7.3.1.1 TensorBoard(X)的介绍

当前在开源社区内,有一个独立的TensorBoardX项目,同时PyTorch内部也包含了tensorboard这个子项目。但它们的根源都是 TensorFlow 开发的 TensorBoard,且PyTorch内部自带的tensorboard是PyTorch官方推荐的可视化工具、已成为主流的可视化工具。

这两者之间有着非常紧密的演进与迭代关系。可以用一句话来概括它们的渊源:TensorBoardX 是社区为了让 PyTorch 用上 TensorBoard 而开发的第三方桥梁,而 PyTorch 官方后来直接“收编”并吸纳了这一思路(PyTorch 官方自带的 tensorboard = 以 TensorFlow 的 TensorBoard 为格式基底 + 吸收 TensorBoardX 的社区实现思路),将其官方化(即 torch.utils.tensorboard)。

它们的发展脉络和关系如下:

7.3.1.1.1 历史演进脉络
  1. TensorBoard 的诞生(Google / TensorFlow): TensorBoard 最初作为 TensorFlow 的专属生态工具被开发出来,用来将训练过程中的 Loss、权重、计算图等写入日志并进行网页端可视化。

  2. TensorBoardX 的出现(社区自救): 在 PyTorch 早期(大约 2017–2018 年前后),PyTorch 生态里并没有官方的可视化工具。当时社区开发者(如 Thomas Wolf 等人)非常眼馋 TensorFlow 的 TensorBoard 功能,于是用 Python 开发了一个第三方开源库叫 tensorboardX。它的原理非常巧妙:不需要安装 TensorFlow,直接在 PyTorch 中通过 Python 将数据写入 TensorBoard 能够解析的 Event 文件中,从而让 PyTorch 用户也能用上 TensorBoard。

  3. PyTorch 官方收编(torch.utils.tensorboard): 随着 PyTorch 的爆发式增长,官方意识到将数据写入 TensorBoard 的可视化能力对于用户至关重要。于是,在 PyTorch 1.2 及以后版本中,官方直接将 tensorboardX 的核心功能与理念吸纳并集成了进来,推出了原生自带的 torch.utils.tensorboard 模块(其底层代码和 API 设计很大程度上借鉴或直接依赖了 tensorboardX 的成熟经验)。

7.3.1.1.2. 两者的现状与区别
维度 tensorboardX(第三方库) torch.utils.tensorboard(PyTorch 自带)
性质 独立的第三方开源项目(需 pip install tensorboardX) PyTorch 官方内置模块(安装 PyTorch 后直接可用)
底层实现 独立维护写入 Protocol Buffers 的逻辑 底层同样依赖 tensorboard(Python 包)作为后端解析与网页展示
API 风格 writer.add_scalar(...), writer.add_image(...) 等 API 名称、参数与 tensorboardX 几乎完全一致(用法无缝衔接)
当前状态 依然存在并独立更新,主要服务于一些旧版 PyTorch 或需要特殊定制的场景 现代 PyTorch 开发的绝对主流与官方推荐
7.3.1.1.3 TensorBoardX vs PyTorch's TensorBoard
  • 它们是不是起源于 TensorFlow 的 TensorBoard? 是的。 无论是 TensorBoardX 还是 PyTorch 自带的工具,它们最终输出的日志文件(Event file)格式、前端网页呈现的 UI 界面,全部都是同一个 TensorBoard。
  • 我们现在该用哪个? 在当前的开发实践中,直接使用 PyTorch 自带的 torch.utils.tensorboard 即可(配合 pip install tensorboard 保证前端能运行),无需再单独安装 tensorboardX。

以下内容将基于 PyTorch 自带的 torch.utils.tensorboard。

7.3.1.2 TensorBoard的安装

(1)PyTorch深度学习框架内,虽然 PyTorch 官方集成了 torch.utils.tensorboard 模块,但它运行时的底层渲染和后端解析依赖于独立的 tensorboard 库,需要单独安装。通过pip安装tensorboard 库:

1
pip install tensorboard

(2)顺便提下,tensorboardX 的安装方式如下:

1
pip install tensorboardX
且tensorboardX的 API 名称、参数与 PyTorch 自带的 torch.utils.tensorboard的 几乎完全一致。

7.3.2 TensorBoard的上层工作逻辑

可以将TensorBoard看做一个记录员,它可以记录指定的数据,包括模型每一层的feature map、权重、训练loss等等。TensorBoard 将记录下来的内容保存在一个用户指定的文件夹里,程序不断运行不断产生数据、TensorBoard会不断记录。记录下的内容经过 TensorBoard 内的渲染引擎 渲染成图表 等内容,通过网页的形式展示。

7.3.3 TensorBoard的配置与启动

PyTorch中自带的tensorboard的官方文档地址:https://docs.pytorch.org/docs/2.6/tensorboard.html。

使用TensorBoard最开始的动作就是要创建一个SummaryWriter实例,创建时最好指定一个保存待记录数据的目录,如果不指定则使用当前目录下的runs/{CURRENT_DATETIME_HOSTNAME}。

每创建一次新的 SummaryWriter,TensorBoard 就会在指定目录中新建一个事件文件。一个正常初始化的 SummaryWriter 实例在其生命周期内通常只对应并写入一个具体的事件文件,且注意在使用完成后调用writer.close()释放句柄与资源。

1
2
3
4
5
from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('./runs')
...
writer.close()

这样,之后调用writer相关接口记录的数据,都会被保存在这个指定的目录下。

事件文件名的生成格式来自 TensorBoard 内部实现:

1
events.out.tfevents.<创建时间>.<主机名>.<进程号>.<同一进程内的序号>

比如某事件文件名为:events.out.tfevents.1791767898.jmac.local.53466.0,含义如下:

  • events.out.tfevents 固定前缀,可整体理解为“TensorBoard 事件输出文件”。
    • events:事件记录;
    • out:输出;
    • tfevents:TensorFlow Event 格式。TensorBoard 最初来自 TensorFlow,但 PyTorch 的 SummaryWriter 也采用这个通用格式写日志。
  • 1791767898 事件文件创建时的 Unix 时间戳,单位是秒。 该值对应本机当时的时间缀:2026-10-12 09:18:18(Asia/Shanghai) 三个文件的时间戳相同,是因为三次创建 SummaryWriter 都发生在同一秒内。
  • jmac.local 当前计算机主机名。
  • 53466 执行该 Python 脚本的进程 ID(PID)。同一次运行产生的三个 SummaryWriter 都在同一个 Python 进程中,所以 PID 相同。
  • .0、.1、.2 TensorBoard 在当前 Python 进程中的递增文件序号,从 0 开始。它用于避免同一秒、同一主机、同一进程创建多个 Writer 时发生文件名冲突。

由于tensorboard可视化是基于事件文件的,只会校验事件文件格式是否合法,并不会做事件文件生成时所在服务器与tensorboard命令执行时所在服务器是否同一个 等校验,那么这些事件文件就是可以复制粘贴到其他服务器上进行解析的。解析与获取对应的可视化结果页面的命令如下:

1
2
3
4
5
6
7
8
9
10
11
# (1)命令格式如下:
## 其中 --logdir 参数指定事件文件的存放目录,是必需的
## --port 参数指定serving端口,可选,默认端口是6006
## 其他参数可通过 "tensorboard --help" 命令探索
tensorboard --logdir="/path/to/logs/" [--port=xxx]

# (2)以下是具体命令:
(ai_py312) jsy@jmac 07第七章 % tensorboard --logdir="./pytorch_tb/test/"
TensorFlow installation not found - running with reduced feature set.
Serving TensorBoard on localhost; to expose to the network, use a proxy or pass --bind_all
TensorBoard 2.21.0 at http://localhost:6006/ (Press CTRL+C to quit)

之后在当前服务器浏览器中访问http://localhost:6006/即可看到可视化结果。 如果在服务器 A (假如IP为:192.168.20.174)上执行tensorboard命令,但想在服务器B或自己电脑上打开与直接查看最终的可视化结果,在服务器 A 上执行tensorboard命令时需要在在最后加上--bind_all 参数,如下:

1
tensorboard --logdir="./pytorch_tb/test/" --bind_all
此时在服务器B或自己电脑上浏览器中访问http://{服务器A的IP}:6006即http://192.168.20.174:6006即可。

7.3.4 用TensorBoard做模型结构可视化

调用的核心API是SummaryWriter.add_graph(xxx),将模型结构信息记录下来,以供后续渲染。

为此首先需要自定义模型或找到一个开源/可用的模型,并实例化。然后调用SummaryWriter.add_graph(xxx),传入如下参数:模型实例、模型前向传播所需要的输入张量。模型结构信息记录下来后,再执行tensorboard解析记录信息、渲染成最终可视化效果。

此处为了简便,使用了一个自定义的简单模型,当然也可以使用其他开源模型。完整示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 30-TensorBoard模型结构可视化.py
from torch.utils.tensorboard import SummaryWriter
import torch
import torch.nn as nn

class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size = 3)
self.pool = nn.MaxPool2d(kernel_size = 2, stride = 2)
self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size = 5)
# AdaptiveMaxPool2d 会把任意输入空间尺寸压缩为指定的 1×1。
self.adaptive_pool = nn.AdaptiveMaxPool2d((1,1))
self.flatten = nn.Flatten()
self.linear1 = nn.Linear(64,32)
self.relu = nn.ReLU()
self.linear2 = nn.Linear(32,1)
self.sigmoid = nn.Sigmoid()

def forward(self,x):
x = self.conv1(x) # 1, 3, 224, 224 -> 1, 32, 222, 222
x = self.pool(x) # 1, 32, 222, 222 -> 1, 32, 111, 111
x = self.conv2(x) # 1, 32, 111, 111 -> 1, 64, 107, 107
x = self.pool(x) # 1, 64, 107, 107 -> 1, 64, 53, 53
x = self.adaptive_pool(x) # 1, 64, 53, 53 -> 1, 64, 1, 1
x = self.flatten(x) # 1, 64, 1, 1 -> 1, 64
x = self.linear1(x) # 1, 64 -> 1, 32
x = self.relu(x) # 1, 32 -> 1, 32
x = self.linear2(x) # 1, 32 -> 1, 1
y = self.sigmoid(x) # 1, 1 -> 1, 1
return y

model = Net()
# 打印粗略的模型结构
print(model)
print("\n")

# 打印CNN在前向传播时的每一层的输出形状
# import torchinfo
# torchinfo.summary(model, input_size=(1, 3, 224, 224))

# 将模型结构利用 TensorBoard 写入“./runs”目录下的事件文件中
writer = SummaryWriter('./runs')
writer.add_graph(model, input_to_model = torch.rand(1, 3, 224, 224))
writer.close()

上述30-TensorBoard模型结构可视化.py文件执行完成后,将在当前目录下的./runs目录生成一个事件文件:
1
2
3
4
5
(ai_py312) jsy@jmac 07第七章 % ls -al ./runs                                              
total 16
drwxr-xr-x@ 3 jsy staff 96 10月 12 10:19 .
drwxr-xr-x 30 jsy staff 960 10月 12 09:18 ..
-rw-r--r--@ 1 jsy staff 6989 10月 12 10:05 events.out.tfevents.1791770748.jmac.local.56091.0

然后执行如下命令,启动tensorboard程序:

1
2
3
4
(ai_py312) jsy@jmac 07第七章 % tensorboard --logdir="./runs" 
TensorFlow installation not found - running with reduced feature set.
Serving TensorBoard on localhost; to expose to the network, use a proxy or pass --bind_all
TensorBoard 2.21.0 at http://localhost:6006/ (Press CTRL+C to quit)
image.png

7.3.5 用TensorBoard做训练过程可视化

TensorBoard 还可以做训练过程的可视化,个人觉得这才是它的功能特性。

7.3.5.1 TensorBoard图像可视化

在做图像识别等图像相关任务时,可以将训练集、验证集/测试集中的部分图像利用TensorBoard进行展示,以在一定程度上检验图像是否正常加载、真实内容如何等等。TensorBoard支持一次性可视化一张图片,也支持一次可视化多张图片。

  • 一次只可视化一张图片:使用add_image。
  • 一次可视化多张图片:
    • 将多张图片直接批量排列展示:使用add_images。
    • 创建一个网格将多张图片分别放入不同格子中,拼接成一张图片后集中展示。比直接批量展示时能更加清晰地看到图片之间的界线、便于进行统一的格式调整。使用make_grid、add_image

以下示例以torchvision的CIFAR10数据集为例,完整可执行:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# 31-TensorBoard图像可视化.py
import torchvision
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

# 数据转换pipeline
transform_train = transforms.Compose(
[transforms.ToTensor()])
transform_test = transforms.Compose(
[transforms.ToTensor()])

# 下载或加载已有的 CIFAR10 数据集
train_data = datasets.CIFAR10("../cifar10-dataset-data/", train=True, download=True, transform=transform_train)
test_data = datasets.CIFAR10("../cifar10-dataset-data/", train=False, download=True, transform=transform_test)
# 创建训练、测试用的数据加载器
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=64)

images, labels = next(iter(train_loader)) # 取第一批图片及对应的标签
runs_dir = "./pytorch_tb/test/" # 此多级目录不存在时,程序会自动创建

# 仅查看一张图片
writer = SummaryWriter(runs_dir)
writer.add_image('images[0]', images[0])
writer.close()

# 将多张图片拼接成一张图片,中间用黑色网格分割
# create grid of images
writer = SummaryWriter(runs_dir)
img_grid = torchvision.utils.make_grid(images)
writer.add_image('image_grid', img_grid)
writer.close()

# 将多张图片直接写入
writer = SummaryWriter(runs_dir)
writer.add_images("images", images, global_step = 0)
writer.close()

上述31-TensorBoard图像可视化.py文件执行后,在当前目录下的./pytorch_tb/test目录下会生成如下文件:

1
2
3
4
5
6
7
(ai_py312) jsy@jmac 07第七章 % ls -al ./pytorch_tb/test 
total 560
drwxr-xr-x@ 5 jsy staff 160 10月 12 10:57 .
drwxr-xr-x@ 4 jsy staff 128 10月 12 10:04 ..
-rw-r--r--@ 1 jsy staff 2211 10月 12 09:18 events.out.tfevents.1791767898.jmac.local.53466.0
-rw-r--r--@ 1 jsy staff 143084 10月 12 09:18 events.out.tfevents.1791767898.jmac.local.53466.1
-rw-r--r--@ 1 jsy staff 138801 10月 12 09:18 events.out.tfevents.1791767898.jmac.local.53466.2
生成的三个事件文件名只有最后一个字符不同,表示它们是在同一个进程中创建中,只是归属于不同的SummaryWriter实例。

然后执行如下命令,启动tensorboard程序:

1
2
3
4
(ai_py312) jsy@jmac 07第七章 % tensorboard --logdir="./pytorch_tb/test" 
TensorFlow installation not found - running with reduced feature set.
Serving TensorBoard on localhost; to expose to the network, use a proxy or pass --bind_all
TensorBoard 2.21.0 at http://localhost:6006/ (Press CTRL+C to quit)

image.png 可以看到,在tensorboard中,图像的展示位置与对应记录图像信息的代码语句位置是倒过来的,后执行的记录图像信息的代码语句对应的图像,在tensorboard中反而展示在最上面。

7.3.5.2 TensorBoard连续变量可视化

对于连续变量的可视化,这里主要讲述在单个chart中绘制一组自变量因变量变化过程、在同一个chart中绘制多组自变量因变量变化过程。

7.3.5.2.1 一个chart单组自因变量

主要通过writer.add_scalar(xxx)这个API来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 32-TensorBoard连续变量可视化-一个chart单组自因变量.py
from torch.utils.tensorboard import SummaryWriter
import torch
import subprocess
import math
import numpy as np

log_dir = "./runs/scalars"
# 删除已有的日志文件
subprocess.run(["rm", "-rf", log_dir])

print(f"TensorBoard 日志文件保存路径:{log_dir}")
writer = SummaryWriter(log_dir=log_dir)
# 生成从 -20π 到 20π 的等间隔数据,步长为 π/2
x = np.arange(-20 * math.pi, 20 * math.pi + 1e-5, math.pi / 2)
for i in x:
# 第一个参数是标签tag,第二个参数是值,第三个参数是全局步数
# 通过第一个参数将不同的曲线分组显示,组名是第一个斜杠前的部分,曲线名是第一个斜杠后的部分
writer.add_scalar("一次函数/y=x/100", i / 100, i)
writer.add_scalar("一次函数/正弦sin", torch.sin(torch.tensor(i * 0.1)), i)
writer.add_scalar("一次函数/余弦cos", torch.cos(torch.tensor(i * 0.1)), i)
writer.add_scalar("二次函数/y=x**2/1000", i**2 / 1000, i)
writer.add_scalar("二次函数/反正切y=atan(x**2)", math.atan(i**2), i)

# 用完后,关闭 SummaryWriter
writer.close()

最后得到的可视化结果如下图: image.png

7.3.5.2.2 一个chart多组自因变量

在同一个chart中绘制多组自变量因变量变化图,有两种实现思路:

  • 使用不同的目录参数创建不同的SummaryWriter实例,然后调用writer.add_scalar(xxx)。
  • 使用一个SummaryWriter实例,然后调用writer.add_scalars(xxx)。更推荐使用。

对于前一种情况,需要注意的是,绝对不能使用同一个SummaryWriter实例尝试在一个chart中绘制多条曲线,此时tensorboard会将同一个自变量标对应的不同因变量直接用竖直线段连接起来、相邻的两个自变量也直接用线段连接起来,得到的不是预期的效果。

对于上述两种实现思路的示例代码分别如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from torch.utils.tensorboard import SummaryWriter
import torch
import subprocess
import math
import numpy as np

log_dir = "./runs/scalars/y"
# 删除已有的日志文件
subprocess.run(["rm", "-rf", log_dir])

print(f"TensorBoard 日志文件保存路径:{log_dir}")
writer_num = 3
writer_arr = []
for i in range(writer_num):
writer_arr.append(SummaryWriter(log_dir=log_dir + f"/y{i}"))

# 生成从 -20π 到 20π 的等间隔数据,步长为 π/2
x = np.arange(-20 * math.pi, 20 * math.pi + 1e-5, math.pi / 2)

for i in x:
# 第一个参数是标签tag,第二个参数是值,第三个参数是全局步数
# 此时第一个参数标签一定要相同,否则以多个chart显示,无法在同一个chart中显示多条曲线
writer_arr[0].add_scalar("低次函数", i / 100, i)
writer_arr[1].add_scalar("低次函数", torch.sin(torch.tensor(i * 0.1)), i)
writer_arr[2].add_scalar("低次函数", torch.cos(torch.tensor(i * 0.1)), i)

# 用完后,关闭 SummaryWriter
for writer in writer_arr:
writer.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from torch.utils.tensorboard import SummaryWriter
import torch
import subprocess
import math
import numpy as np

log_dir = "./runs/scalars/y"
# 删除已有的日志文件
subprocess.run(f"rm -rf {log_dir}", shell=True)

print(f"TensorBoard 日志文件保存路径:{log_dir}")
writer = SummaryWriter(log_dir=log_dir)

# 生成从 -20π 到 20π 的等间隔数据,步长为 π/2
x = np.arange(-20 * math.pi, 20 * math.pi + 1e-5, math.pi / 2)

for i in x:
# 第一个参数是父标签名,第二个参数是字典(其中每个键值对代表一个子标签和对应的值),第三个参数是全局步数
# 此时可以给不同的子标签设置不同的值,从而在同一个chart中的多条曲线拥有不同的名字
writer.add_scalars('run_14h', {'低次函数x':i/100,
'低次函数sin(x * 0.1)': torch.sin(torch.tensor(i * 0.1)),
'低次函数cos(x * 0.1)': torch.cos(torch.tensor(i * 0.1))}, i)
# writer.add_scalars('run_14h', {'低次函数x':i/100,
# '低次函数sin(x * 0.1)': np.sin(i * 0.1),
# '低次函数cos(x * 0.1)': np.cos(i * 0.1)}, i)

# 用完后,关闭 SummaryWriter
writer.close()

两个程序最终得到的效果都如下图: image.png 在 TensorBoard 的 Scalars(标量)页面中,有一个Smoothing调节功能,可调大调小。Smoothing(平滑度) 调节功能的核心作用是:通过指数移动平均算法(Exponential Moving Average)对曲线进行平滑处理,从而过滤掉局部的剧烈波动(噪声),让整体的变化趋势更加清晰。

当需要观察训练过程中的每一个 Step(或 Batch)的原始细节、排查突发的梯度剧烈震荡、或者寻找某些异常尖峰(Spike)时,把 Smoothing 调小可以看清最真实的抖动情况。

当想向别人展示实验结果、对比不同模型的整体收敛趋势、宏观走向时,调大 Smoothing 可以让图表看起来干净、直观,一眼看出哪个模型收敛得更快、更稳。此功能的另外一个用法是,当损失函数震荡较大时,调大 Smoothing 有助于观察loss的整体变化趋势。

如果在某个目录A下保存了多个不同程序生成的tensorboard事件文件,此时启动tensorboard程序时传递此目录A作为--logdir参数的值,tensorboard会尝试将此目录A下的所有事件文件进行解析与渲染,最后得到的可视化效果会非常杂。所以要规划、管理好事件文件保存的目录,保证其干净不受污染。

7.3.5.3 TensorBoard参数分布可视化

当我们需要对模型的权重参数的变化趋势或分布情况进行观察研究时,可以多次调用writer.add_histogram(xxx)来绘制持续变化的多个直方图。

示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import torch
import numpy as np
from torch.utils.tensorboard import SummaryWriter

# 创建正态分布的张量模拟参数矩阵
def norm(mean, std):
t = mean + std * torch.randn((100, 20))
return t

logdir = "./runs/histogram"
print(f"TensorBoard 日志文件保存路径:{logdir}")

writer = SummaryWriter(log_dir=logdir)
# 生成从 -10 到 10 的等间隔数据,步长为 1
for step, mean in enumerate(range(-10, 10, 1)):
w = norm(mean, 1)
writer.add_histogram("正太分布w", w, step)
# writer.flush()

writer.close()

最终的效果如下图所示: image.png

针对这张 Histogram 图的大致分析如下:

  1. 每一条橙色“山脊”表示一个 step 的参数分布

    代码循环了 20 次,step 从 0 到 19。每次调用 norm(mean, 1) 都会生成一个形状为 (100, 20) 的张量,因此每个 step 实际写入了 \(100\times20=2000\) 个模拟参数值。TensorBoard 将同一个 tag(正太分布w)在不同 step 写入的直方图沿纵向依次排开,于是形成截图中一层层橙色的“山脊”。

  2. 横轴是参数取值,不是 step

    图底部横轴大约从 -13 到 13,表示参数值落在什么位置。例如最前方 step=0 的分布峰值位于约 -10 附近;最后方 step=19 的峰值位于约 9 附近。右侧标出的 0、1、2、...、19 才是写入时传给 add_histogram(..., step) 的 step;当前界面选择的是 OFFSET 显示模式,因此这些 step 被错开排列,便于同时观察各时刻的分布形状。

  3. 整条分布逐步向右移动,表示均值在持续增大

    循环中传入 norm(mean, 1) 的 mean 依次是 -10、-9、...、9。正态分布的峰值通常靠近均值,所以从 step=0 到 step=19,橙色峰顶从左侧约 -10 逐渐平移到右侧约 9。这正是代码故意模拟的“参数整体数值持续增大”的过程,而不是训练随机波动造成的异常。

  4. 各层山脊的宽度大体相近,表示离散程度基本稳定

    每次都固定使用 std=1,因此理论上每个 step 的标准差都应接近 1,分布的宽窄大致相同。实际每次重新随机采样 2,000 个数,峰高、边缘和最小/最大值会有轻微变化,但不会改变“均值右移、方差近似不变”的总体趋势。

  5. 峰顶旁的 601 是该直方图桶中的样本计数

    TensorBoard 会把连续参数值划分为多个区间(histogram bins / 桶)。鼠标所在的黑点对应一个桶,601 表示该桶中统计到了 601 个参数值;它不是均值、step,也不是模型参数的总数。不同 step 的桶边界和桶数可由 TensorBoard 根据数值范围自动确定,所以不应直接把不同山脊峰顶的计数当作精确可比的“参数数量”。

在真实训练中,可以把 w 替换为某层的权重或梯度,例如 model.layer.weight 或 model.layer.weight.grad,并在每个 epoch / step 写入一次。若看到分布突然整体偏移、明显变宽、塌缩到接近 0,或出现异常长尾,就值得进一步检查学习率、初始化、梯度爆炸/消失等训练问题。

参考文档:TensorBoard可视化 。

7.4 使用wandb可视化训练过程

参考自己以前写的博客:本地微调DeepSeek-R1-8b模型


PyTorch07-PyTorch可视化
https://jiangsanyin.github.io/2026/10/06/PyTorch07-PyTorch可视化/
作者
sanyinjiang
发布于
2026年10月6日
许可协议