PyTorch可视化神经网络中间层输出：从特征图到热力图

在做图像分类、目标检测或文本分类项目时，很多人只关心模型最后一层的预测概率。真正开始调模型时，最后一层反而价值有限。一次错误分类可能来自图像缩放方式不对、数据分布偏移，也可能来自模型中间层把某个关键模式错误激活。只看最终输出，很难判断问题发生在哪儿。所谓“可视化神经网络中间层输出”，就是把模型权重计算过程中产生的中间张量提取出来，转成肉眼能理解的特征图、热力图或分布图，用来回答一个核心问题：网络到底在原始输入上看懂了什么、忽略了什么。

本文就围绕这条主线展开。先讲中间层输出在视觉和序列任务里分别是什么，再给出 PyTorch 环境下提取中间张量的完整做法，然后分别对卷积神经网络（CNN）和循环神经网络（RNN/LSTM）做可视化，最后补充实际运行中最高频的报错、排查路径和生产环境注意事项。适合已经能跑通 PyTorch 训练、但还不会定位模型内部行为的开发者阅读。

1. 中间层输出不是调试信息，它是网络的一种解释材料

1.1 中间层输出在视觉任务里到底是什么

以卷积神经网络为例，输入图片进入网络后，会依次经过卷积、归一化、激活函数、池化等操作。每一次卷积输出仍然是一个四维张量，格式通常是[B, C, H, W]。B 是 batch 大小，C 是通道数，H 和 W 是特征图的高和宽。

这其中的“通道”并不是图像的 R、G、B 颜色通道，而是卷积核识别出的某种模式。比如第一个卷积层可能对横线、竖线、色块敏感，深层卷积可能对眼睛、车轮、窗户这类更抽象的语义模式敏感。某个通道输出值越大，说明输入图片中对应区域越像该通道关注的模式。

所以，中间层输出是对输入逐级抽象后的“半成品”。浅层接近像素细节，深层接近语义概念。可视化中间层输出，本质上是把某一层这个四维张量按通道拆开，把每个通道的值映射成灰度图或伪彩色图，再看哪些区域被激活。

1.2 可视化能帮助解决哪些问题

可视化中间层输出在实际开发中至少能帮助解决五类问题：

1. 判断网络是否学到了有效特征，而不是靠背景或水印发预测。
2. 定位模型在哪些区域产生了误激活，为数据清洗提供依据。
3. 对比不同层、不同初始化或不同训练策略下特征差异。
4. 检测梯度爆炸或激活值饱和，尤其是深层的激活值整体过大或过小。
5. 在调试代码时确认尺寸计算是否正确。最常见的是经过多层卷积后特征图尺寸变成了 1 或 0，导致后续全连接层报错。

第一类和第二类最常出现在图像分类项目的汇报阶段。当领导或甲方问“这个模型为什么这么准，它到底看了什么”，一张清晰的特征图叠加原图的热力图，比任何准确率数字都更有说服力。

1.3 一个方便理解的流水线类比

可以把网络理解成一个工厂流水线。原始像素是原材料，每一层卷积是不同工序，中间层输出是每道工序产生的半成品。只看最终出货结果，你不知道是哪道工序出了问题。可视化中间层，等于在流水线每个环节装上观察窗，随时可以看到当前半成品长什么样。

对于 RNN/LSTM 这类序列模型，半成品就是每个时间步的隐藏状态向量。你无法直接看见高维向量，需要把它降维后再画在坐标轴里，才能判断网络在处理哪些词时产生了较大的状态变化。

2. 环境准备与数据对齐，是可视化能复现的前提

2.1 环境要求与版本建议

PyTorch 可视化并不需要特殊依赖，常规训练环境即可。要求列在下面。

组件	建议版本	作用
Python	3.8 及以上	运行环境，3.10、3.11 均可
PyTorch	1.13 及以上，2.x 更好	模型定义与自动求导
torchvision	与 PyTorch 版本匹配	提供预训练模型与图像变换
matplotlib	3.6 及以上	绘制特征图网格、热力图
Pillow	9.0 及以上	读取和基础处理图片
numpy	1.24 及以上	张量转数组、数值计算
scikit-learn	可选	对 RNN 隐藏状态做 PCA 降维

安装时不必刻意追求最新版本。PyTorch 2.x 与 torchvision 的版本配套关系比较严格，建议以官方安装命令为准。先确认torch和torchvision版本能够匹配。

pip install torch torchvision matplotlib pillow numpy scikit-learn

安装完成后，用下面命令做一次最小化检查。这一步能排除最常见的环境问题。

python -c "import torch, torchvision, matplotlib; print(torch.__version__, torchvision.__version__)"

正常情况下终端会输出2.x.x+cu121 0.xx.x类似的信息。如果出现ModuleNotFoundError，说明依赖没有安装到当前虚拟环境。

2.2 检查 CUDA 与设备可用性

可视化通常建议把模型放到 CPU 上执行，因为中间层输出只是推理过程，不需要梯度计算，也不涉及大量 batch 并行。但如果你已经安装了 GPU 版本，可以用下面代码快速检查 GPU 是否可用。

import torch print("CUDA available:", torch.cuda.is_available()) if torch.cuda.is_available(): print("GPU name:", torch.cuda.get_device_name(0)) print("Device count:", torch.cuda.device_count())

如果本机有 GPU 但显示False，优先检查 PyTorch 版本对应的 CUDA 编译版本是否和驱动匹配。这不是可视化本身的问题，但会严重影响训练阶段复现。

2.3 准备一张测试图片并完成预处理

可视化需要一张真实图片做输入。这里先准备一张小猫或小狗的图片都行，注意要统一到预训练模型要求的尺寸。以 torchvision 自带的 ResNet18 为例，默认输入是224 x 224，归一化均值方差是 ImageNet 统计值。

下面的代码把图片读取、缩放、转张量、归一化这几步放在一起。

from PIL import Image from torchvision import transforms image_path = "test_cat.jpg" image = Image.open(image_path).convert("RGB") preprocess = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) input_tensor = preprocess(image).unsqueeze(0) print(input_tensor.shape) # 期望输出 torch.Size([1, 3, 224, 224])

unsqueeze(0)很关键。模型要求的输入是四维[B, C, H, W]，单张图片经过ToTensor()后是三维[C, H, W]，必须补一个 batch 维。漏掉这一步非常常见，报错信息是Expected 4-dimensional input。

3. 用 forward hook 提取 ResNet 的卷积输出，而不是暴力改 forward

3.1 为什么需要 forward hook

最直观的做法是修改模型代码，在 forward 里把中间层 return 出来。但这样做有两个问题：一是破坏了原始模型结构，预训练权重和后续模块的衔接容易出错；二是如果同时要测试多个层，需要反复改动 forward。

PyTorch 提供了register_forward_hook。它的原理是在指定模块执行完 forward 之后，自动调用你传入的回调函数，把该模块的输入和输出传给你。这样可以在不改模型结构的前提下取出任意中间层输出。

核心思路是定义一个字典来保存中间激活值，再用一个闭包函数把不同层的结果写入字典。

import torch import torch.nn as nn from torchvision import models activation = {} def get_activation(name): def hook(model, input, output): # output 是当前模块前向传播结束后的中间张量 activation[name] = output.detach() return hook model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1) model.eval()

3.2 注册关键层并提取特征图

ResNet18 中，layer1、layer2、layer3、layer4分别对应不同层次的卷积块。为了展示浅层和深层的差异，可以同时注册两个层。

model.layer1[-1].register_forward_hook(get_activation("layer1")) model.layer4[-1].register_forward_hook(get_activation("layer4")) with torch.no_grad(): output = model(input_tensor) feat1 = activation["layer1"] feat4 = activation["layer4"] print("layer1:", feat1.shape) print("layer4:", feat4.shape)

如果输入是[1, 3, 224, 224]，输出可能是：

• layer1:[1, 64, 56, 56]
• layer4:[1, 512, 7, 7]

layer1有 64 个通道，特征图分辨率高；layer4有 512 个通道，特征图分辨率低。这正体现了 CNN 的空间下采样规律：通道数逐渐增加，特征图尺寸逐渐缩小。

这里要注意，output.detach()必须加上。如果不加，hook 捕获到的张量会一直保存在计算图里，占用显存。在推理场景下这没有必要。

3.3 只看 shape 还不够，要检查值的分布

拿到特征图后，不要急着画图。先打印每个通道的均值、最大值和最小值，确认数值分布是正常的。

feat = feat1[0] # 去掉 batch 维，得到 [C, H, W] print("通道数:", feat.size(0)) print("全局最小值:", feat.min().item()) print("全局最大值:", feat.max().item()) print("各通道均值示例:", feat.mean(dim=(1, 2))[:5])

如果全局最大值非常小，比如小于 0.1，说明该层几乎没有被激活，可能是输入图片内容与该层识别模式不匹配，也可能是权重没有正确加载。如果最大值非常大，比如超过 100，要警惕激活值异常爆炸，通常需要检查归一化配置是否正确。

4. 把特征图处理成一张能看的图

4.1 为什么不能直接把原始张量交给 matplotlib

中间层输出的值是神经网络内部的浮点数，范围不固定，可能包含负数。而matplotlib的imshow默认把最小值映射到黑色，最大值映射到白色。如果不做归一化，显示出来的图会整体偏黑或偏白，细节全部丢失。

正确的做法是逐通道做最小最大归一化，将数值映射到[0, 1]区间。给每个通道单独归一化可以保留该通道内部的对比度，避免因为全图极端值压制了弱激活通道。

import numpy as np def normalize_feature(feature_map): # feature_map: [C, H, W] 或 [H, W] if len(feature_map.shape) == 3: normalized = torch.zeros_like(feature_map) for c in range(feature_map.size(0)): channel = feature_map[c] c_min = channel.min() c_max = channel.max() if c_max - c_min < 1e-8: normalized[c] = torch.zeros_like(channel) else: normalized[c] = (channel - c_min) / (c_max - c_min) return normalized else: return (feature_map - feature_map.min()) / (feature_map.max() - feature_map.min() + 1e-8)

这里之所以加1e-8，是防止某个通道所有值完全相同时出现除零错误。虽然实际中少见，但不能不处理。

4.2 以网格方式绘制多个通道的特征图

浅层 64 个通道，如果全部画出来会很占版面。通常选取前 8 个或 16 个有明显梯度的通道展示即可。下面代码以 2 行 4 列为例。

import matplotlib.pyplot as plt def draw_feature_grid(feature_map, save_path="feature_grid.png", num_cols=4): feature_map = normalize_feature(feature_map) C = feature_map.size(0) num_rows = (C + num_cols - 1) // num_cols fig, axes = plt.subplots(num_rows, num_cols, figsize=(num_cols * 3, num_rows * 3)) axes = axes.flatten() for i in range(num_cols * num_rows): if i < C: axes[i].imshow(feature_map[i].cpu().numpy(), cmap="viridis") axes[i].set_title(f"channel {i}", fontsize=10) axes[i].axis("off") plt.tight_layout() plt.savefig(save_path, dpi=150) plt.close(fig) draw_feature_grid(feat1[0], "layer1_features.png", num_cols=8)

这里cmap="viridis"是伪彩色映射，便于肉眼区分高低激活区域。浅色表示高激活，深色表示低激活。

4.3 把单张特征图叠加到原图上，得到热力图

只看单通道特征图，很难定位它在原图上的位置。更直观的做法是把特征图缩放到原图尺寸，再叠加回原图。

流程如下：

1. 选择某个通道的特征图。
2. 归一化并转成 numpy 数组。
3. 用 OpenCV 或 PIL 缩放到原图尺寸。
4. 把灰度图应用伪彩色映射。
5. 与原图按比例融合。

import cv2 def overlay_heatmap(original_path, feature_map, channel_idx=0, alpha=0.5): original = cv2.imread(original_path) original = cv2.cvtColor(original, cv2.COLOR_BGR2RGB) h, w = original.shape[:2] feat = normalize_feature(feature_map)[channel_idx].cpu().numpy() feat = cv2.resize(feat, (w, h), interpolation=cv2.INTER_LINEAR) feat = (feat - feat.min()) / (feat.max() - feat.min() + 1e-8) heat = cv2.applyColorMap((feat * 255).astype(np.uint8), cv2.COLORMAP_JET) heat = cv2.cvtColor(heat, cv2.COLOR_BGR2RGB) blend = (original * (1 - alpha) + heat * alpha).astype(np.uint8) return blend blend_layer4 = overlay_heatmap("test_cat.jpg", feat4[0], channel_idx=10, alpha=0.5) plt.imshow(blend_layer4) plt.title("layer4 channel 10 heatmap") plt.axis("off") plt.savefig("heatmap_layer4.png", dpi=150)

当某个通道的红色区域刚好落在原图中的主体目标上时，说明该通道确实学到了和该目标相关的特征。如果红色区域集中在背景、边框或水印位置，就要警惕模型存在偏置。

5. 扩展到 RNN 和 LSTM：中间层输出是一组隐藏状态向量

5.1 序列模型可视化不能用图像网格

RNN、LSTM 这类模型的中间层输出不是二维特征图，而是形状为[batch, seq_len, hidden_size]的张量。对文本任务来说，seq_len是序列长度，hidden_size是每个时间步的隐藏状态维度。你无法直接把它当作图片来显示。

常见做法有两种：

1. 把每个时间步的隐藏状态向量看成一个点，用 PCA 或 t-SNE 降到二维后画散点图。
2. 把隐藏状态矩阵当作热力图画出来，横轴是时间步，纵轴是隐藏维度，颜色表示激活强度。

第二种方法更简单，适合观察不同位置的状态差异。

5.2 构造一个最小 LSTM 可视化示例

假设有一个包含 4 个 token 的短句，词表大小为 4，词向量维度为 8，LSTM 隐藏维度为 16。运行过程如下。

import torch import torch.nn as nn embedding = nn.Embedding(4, 8) lstm = nn.LSTM(input_size=8, hidden_size=16, batch_first=True) input_ids = torch.tensor([[0, 1, 2, 3]]) embedded = embedding(input_ids) # [1, 4, 8] output, (h_n, c_n) = lstm(embedded) # output: [1, 4, 16] hidden_states = output.squeeze(0).detach() # [4, 16] print(hidden_states.shape)

lstm的返回值中，output保存了每个时间步的隐藏状态，这是真正需要可视化的中间层输出。h_n是最后一步的隐藏状态，c_n是细胞状态。

将隐藏状态矩阵画成热力图。

import matplotlib.pyplot as plt def draw_rnn_hidden_heatmap(hidden, save_path="rnn_hidden.png"): plt.figure(figsize=(6, 4)) plt.imshow(hidden.numpy(), aspect="auto", cmap="viridis") plt.colorbar(label="activation") plt.xlabel("hidden dimension") plt.ylabel("time step") plt.title("LSTM hidden states") plt.tight_layout() plt.savefig(save_path, dpi=150) plt.close() draw_rnn_hidden_heatmap(hidden_states)

5.3 用 PCA 观察隐藏状态的空间分布

当hidden_size比较大时，比如 256 或 512，热力图可读性有限。可以用 PCA 把每个时间步的隐藏状态投影到二维平面，观察模型在处理序列过程中状态的移动轨迹。

from sklearn.decomposition import PCA hidden_np = hidden_states.numpy() pca = PCA(n_components=2) coords = pca.fit_transform(hidden_np) plt.figure(figsize=(6, 4)) plt.plot(coords[:, 0], coords[:, 1], marker="o", linestyle="-") for i, (x, y) in enumerate(coords): plt.text(x + 0.01, y + 0.01, f"t={i}", fontsize=9) plt.xlabel("PC1") plt.ylabel("PC2") plt.title("LSTM hidden state trajectory") plt.tight_layout() plt.savefig("rnn_pca_trajectory.png", dpi=150)

这里看到的状态轨迹也有实际意义：如果相邻时间步状态在二维空间里分布很近，说明模型处理这些位置时没有产生明显区分；如果某个时间步出现明显的方向切换，说明该位置对应的输入对模型状态影响较大。

6. 可视化过程中常见的坑，按现象、原因、处理排序

6.1 高频报错对照表

下面整理的是实践中最常遇到的几类问题。

问题现象	常见原因	检查方式	处理建议
RuntimeError: Expected 4-dimensional input	输入张量少了 batch 维	打印input_tensor.shape	加上unsqueeze(0)
TypeError: can't convert CUDA tensor to numpy	直接在 GPU 张量上调用numpy()	查看张量所在设备	先.cpu()再.detach()再.numpy()
特征图全黑或全白	没有归一化，或最小值等于最大值	打印通道min和max	用最小最大归一化处理
IndexError: index out of range	网格绘制的通道数少于子图数量	检查num_cols * num_rows和 C 的关系	超出部分调用axis("off")
ValueError: operands could not be broadcast together	特征图缩放尺寸与原图不一致	打印两者的shape	用cv2.resize统一到(w, h)
绘制热力图时颜色异常	OpenCV 是 BGR 通道顺序	对比原图颜色	用cv2.COLOR_BGR2RGB转换
matplotlib 中文乱码	系统缺少中文字体	检查系统字体	绘制前设置plt.rcParams["font.sans-serif"]

6.2 一个完整排查示例

现象：运行上面draw_feature_grid时，某层的特征图全是深色，完全看不出结构。

排查顺序如下：

1. 先打印该层张量的最小值和最大值。
2. 如果min=0.0、max=0.0，说明该层输出全部为 0，大概率是网络没有执行到该层，或权重没有初始化。
3. 如果min=-0.1、max=0.1，说明激活幅度很小，直接归一化后会被压缩到接近 0.5 的位置，看起来灰蒙蒙。这时应该先看该层前面是否有激活函数失效的问题。
4. 如果数值正常但图仍然看不清，检查绘制时是否对[C, H, W]和[H, W]的维度混淆。

一个常见误操作是调用normalize_feature(feat1[0])，然后在循环里又写了feature_map[i]，实际此时feature_map[i]已经是一个[H, W]的二维张量，再传入normalize_feature时走了二维分支，逻辑没有错，但容易搞混维度。建议在函数入口处打印一次shape，避免层层传递时出错。

7. 区分实验阶段和生产环境，可视化才算落地

7.1 实验阶段怎么做最有效

在本地实验阶段，可视化可以随意一些。推荐做法是先把可视化逻辑封装成独立模块，比如visualize.py，不要在训练脚本里堆一堆plt.show()。这样做的原因是训练和验证每个 epoch 都要调用，可视化逻辑如果写得太重，会拖慢训练节奏。

实验阶段的建议：

• 每个 epoch 保存少量样本的特征图，不需要全量保存。
• 用容器固定特征图数量，避免文件无限增长。
• 同时保存原图和叠加图，方便对比。
• 对中间层输出加日志记录，记录最小值、最大值、均值和标准差。

下面是一个简单的保存结构。

experiments/ exp001/ epoch_001/ sample_001_original.png sample_001_layer4.png sample_001_heatmap.png epoch_002/ ...

7.2 生产环境要注意资源开销和权限控制

生产环境做可视化，重点不是画图样式，而是不影响主流程。特征图占用的内存随通道数和空间尺寸增大而增加。如果线上服务每一张请求都做可视化，会增加推理延迟和存储成本。

生产环境建议：

• 只在指定请求或采样率下启用可视化，比如按 1% 比例采样。
• 可视化模块单独部署，不放在核心推理链路。
• 中间层张量需要脱敏处理，尤其是文本数据可能包含用户隐私信息。
• 设置文件大小上限，超过后自动清理。
• 把可视化结果写入独立存储目录，与业务日志分离。

7.3 可复用的发布前检查清单

每次发布前，建议按下面清单逐项确认。

1. 确认输入预处理格式和模型训练时一致，包括尺寸、均值、方差。
2. 确认 hook 注册后没有影响原始输出。model(input_tensor)的预测结果是否与注册前一致。
3. 确认每个保存的中间层张量都已经detach()，避免显存泄漏。
4. 确认特征图归一化逻辑覆盖了全零通道的分支。
5. 确认绘制超大网格时限制了图片尺寸，避免文件过大。
6. 确认 GPU 环境下.cpu()与.detach()的顺序正确。
7. 确认生产环境中的采样率、保存目录权限和磁盘清理策略已经配置。
8. 确认异常分支下可视化失败不会导致主流程崩溃，用try/except包裹。

8. 中间层可视化延伸出的几个工程方向

做完基础可视化后，有三个方向值得继续深入。

第一个方向是自动分析中间层输出分布。不在每个 epoch 人工看图，而是在训练循环里定期计算通道激活率、稀疏度、均值方差，并把指标输出到日志系统。当指标出现明显偏移时触发告警，这比事后翻图更高效。

第二个方向是把可视化结果用于模型压缩和剪枝。如果某些通道在大量样本上始终接近零激活，说明这些通道对最终预测贡献有限。可以结合剪枝工具删除这些通道，从而缩小模型体积。可视化只是第一步，真正做通道筛选需要统计大量样本的激活情况。

第三个方向是把中间层输出用于可解释性报告。在实际业务中，尤其是医疗影像、金融风控、内容审核场景，模型输出往往需要附带原因说明。将高激活通道对应的原图区域截取出来，配合业务规则生成报告，能显著提高结果的可信度。这种做法的核心不是生成热力图本身，而是如何把激活位置和业务语义对应起来。

可视化神经网络中间层输出这件事，从技术难度上看并不高，但非常依赖一个干净的结构：先提取张量，再理解维度含义，再选择合适的呈现方式，最后把结果沉淀成可复用的工具。对于一个刚开始做模型调试的开发者来说，我建议今天就拿一张自己手边的图片，把 ResNet 的layer1和layer4都打印出来，先只看通道数和特征图尺寸的变化，再画第一张图。不要急着叠加原图，先把归一化、网格绘制的逻辑跑通，后面再逐步加热力图和序列模型的可视化，你会发现模型内部的结构远比自己想象的可读。