ARTICLE DETAIL

资讯详情

深耕网站建设、视觉设计与SEO优化的一线实战洞察。

ResNet残差分支注意力模块实战:SE、CBAM、ECA插入与消融

ResNet残差分支注意力模块实战:SE、CBAM、ECA插入与消融

简介:面向深度学习图像分类学习者和 PyTorch 实践者,这套 ResNet 结合注意力机制的代码包提供 SE 与 CBAM 两种模块接入示例,并以 CIFAR10 为训练数据集,适合用于理解主干网络改造、训练脚本调用及结果对比。包内共 16 个文件,以 5 个 Python 脚本和 8 个 XML 项目配置为主,另有 iml、gitignore 与 README 说明,压缩包约 15KB,体量轻便,便于快速查阅;Python 文件覆盖模型定义、SE/CBAM 模块及单卡、多卡训练入口,XML 主要用于 IDE 与项目环境配置。已有 13556 人学习,说明其在 ResNet 注意力改造主题上具有一定参考热度。读者可据此复现 CIFAR10 训练流程,按参数切换 se 或 cbam,并结合描述中的 Ubuntu20.04、GTX 1080Ti、PyTorch1.7.0/CUDA10.2 环境及 ResNet50 训练 160 轮 ACC@1=93.41% 的验证结果做对照,快速搭建实验基线并理解注意力模块的接入方式。

1. 一张特征图暴露的问题:ResNet 加注意力到底在加什么

去年帮人看一个细粒度分类任务,ResNet-50 训练集准确率冲到 99%,验证集却卡在 78% 上不去。把中间层特征图导出来做了个热力图,问题很清楚:卷积核在背景纹理上的响应比目标本身还强。网络不是不够深,是它对所有通道、所有位置一视同仁地分配权重,背景一多就被带偏。这个项目干的就是这件事——把 SE、CBAM、ECA 这类注意力模块按不同位置插进 ResNet 的残差分支,配一份能直接跑的 Python 训练脚本,把「插在哪、怎么插、插完掉不掉点」跑成可对比的实验。适合两类人:已经会用 PyTorch 搭分类网络、想搞清楚注意力模块真实实现细节的,以及手上有个几千张的小数据集、想靠轻量改造再抠一两个点的。项目不复杂,但它把容易翻车的地方都摆在了明面上。

2. 工程结构:ResNet 主干与注意力模块的拼装位置

2.1 目录分层与各文件职责

这份代码没有把所有东西塞进一个model.py里。这种拆法看着多几个文件,但你后面要加第四种注意力、要换数据集、要单独跑消融的时候,会感谢当初没偷懒。目录长这样:

resnet_attention/ ├── configs/ │ └── cifar100_se_r16.yaml # 一份实验一个 yaml,超参不进代码 ├── datasets/ │ ├── __init__.py │ └── build.py # 数据集注册与 transforms 组装 ├── models/ │ ├── __init__.py │ ├── attention.py # SE / CBAM / ECA 三种实现,互不依赖 │ ├── resnet.py # 主干,BasicBlock / Bottleneck 支持注入 │ └── build.py # 按字符串名字组装模型 + 权重初始化 ├── engine/ │ ├── train.py # 单 epoch 训练循环 │ ├── evaluate.py # 验证集评估 │ └── logger.py # 控制台 + TensorBoard 双写 ├── utils/ │ ├── seed.py # 随机种子与 cudnn 开关 │ └── misc.py # 参数量统计、模型保存 ├── train.py # 训练入口 ├── eval.py # 单独评估入口 └── requirements.txt

models/attention.py是纯函数式的,每个注意力模块只接收channels,不关心自己被插在哪个 stage;models/resnet.py负责「在哪插」;models/build.py负责「按名字拿模型」。三层拆开的好处是加一个 ECA 的变体不用动主干一行代码,只要在attention.py里写个类、在注册表里挂个名字。

提示:如果只是跑通看看效果,datasets/和engine/可以先照抄,真正需要你读懂的是attention.py和resnet.py这两个文件,加起来不到 300 行。

配置用 yaml 而不是 argparse 一把梭,是因为消融实验要跑十几组,命令行参数记不住。一份典型配置长这样:

# configs/cifar100_se_r16.yaml model: name: resnet18 attn: se # none / se / cbam / eca reduction: 16 zero_init_gamma: true data: name: cifar100 root: ./data batch_size: 128 num_workers: 8 train: epochs: 200 lr: 0.1 weight_decay: 5.0e-4 warmup_epochs: 5 amp: true

attn这一项填none就是原版 ResNet,填se就是加通道注意力,这样消融实验的对照组不用另拉分支,同一份代码跑两次就够。

2.2 主干选型:BasicBlock 与 Bottleneck 决定注意力插哪

ResNet 有两套残差块:18/34 层用 BasicBlock(两个 3×3 卷积),50 层以上用 Bottleneck(1×1 降维 → 3×3 → 1×1 升维)。这个差别直接决定注意力模块往哪放、参数涨多少。

我的处理是在残差分支内部、bn2之后、和 identity 相加之前插一个注意力模块。理由很实在:这里的特征图通道数已经回到planes(BasicBlock)或planes * 4(Bottleneck),维度规整,注意力模块不用关心降维升维的中间态;而且它只重标定「这一层新学出来的残差」,identity 那条捷径保持干净,梯度回传路径最短。

插入位置参数增量(ResNet-18)小目标收益风险
stem 之后(conv1 后)极小低分辨率太高,池化丢信息严重
每个 stage 出口小中只做跨 stage 融合,粒度粗
残差分支内、相加前中高每个 block 都加,推理耗时涨 5%~8%
相加后、ReLU 前中中注意力会连 identity 一起缩放,深层易掉点

还有第三种选择,只在每个 stage 的最后一个 block 加,参数量和耗时都能砍到三分之一,精度基本追平全插。数据量小于一万张的时候我一般用这个折中方案,全插反而容易过拟合。

主干层数也别一上来就 50。CIFAR 这种 32×32 的输入,ResNet-18 已经够用,50 层的第一个 stage 就下采样到 8×8,注意力模块在这么小的图上做空间注意力基本是浪费。真要上 50,把conv1换成 3×3 stride 1、去掉 maxpool(CIFAR 版的常见改法),别直接套 ImageNet 那套 stem。

2.3 依赖与运行环境

requirements.txt保持最小集,不引 timm 那种大包,因为这里的注意力模块都是自己写的,不依赖外部实现:

# requirements.txt torch>=2.0.0 torchvision>=0.15.0 pyyaml>=6.0 tensorboard>=2.13.0 tqdm>=4.65.0

Python 用 3.9 及以上,CUDA 版本跟着torch的官方命令走,别混装。装完先跑一句环境自检,确认 GPU 能认到、torch.backends.cudnn.version()有输出,再往下走:

python -c "import torch; print(torch.__version__, torch.cuda.is_available(), torch.cuda.device_count())"

注意:tensorboard和torch.utils.tensorboard是两个东西,前者是可视化服务端,后者是 PyTorch 内置的写入接口,两个都要装。只装tensorboardX会在新版 torch 上报重复注册的 warning。

3. 核心代码拆解:三种注意力模块与残差分支的拼接

3.1 SE 模块:通道注意力的最小实现

SE 是这类改造里性价比最高的一个:只学一组通道权重,参数量是2 * C² / r,在 C=512、r=16 的时候也就 3 万多个参数。实现上有两个细节容易写歪——中间层通道数别让它除成 0,以及用 1×1 卷积代替全连接层。

import torch import torch.nn as nn class SEBlock(nn.Module): """通道注意力:全局平均池化压成向量,再学一组 0~1 的通道权重。""" def __init__(self, channels: int, reduction: int = 16): super().__init__() # 中间层至少留 4 个通道,否则小模型上 channels // r 会变成 0,直接报维度错 hidden = max(channels // reduction, 4) self.pool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Sequential( # 用 1x1 卷积替代 Linear,省掉一次 [N,C] 和 [N,C,1,1] 的 reshape nn.Conv2d(channels, hidden, 1, bias=False), nn.ReLU(inplace=True), nn.Conv2d(hidden, channels, 1, bias=False), nn.Sigmoid(), ) def forward(self, x): w = self.pool(x) # [N, C, 1, 1] w = self.fc(w) # [N, C, 1, 1] return x * w # 广播相乘,逐通道重标定

reduction控制压缩比,论文默认 16,实测在 8~16 之间抖动很小,但降到 2 或 4 会开始掉点——中间层太宽,相当于给网络加了个没正则的小全连接,小数据集上立刻过拟合。bias=False是有意的,后面紧跟 BN 或者本身就是乘性权重,加 bias 没有意义还多一组参数。

要注意 SE 的乘法顺序:x * w里w是 sigmoid 出来的,值域 (0,1),所以它只能「压制」通道响应,不能放大。有人为了让某些通道增强,把 sigmoid 换成2 * sigmoid,这属于个人口味,实测差异在噪声范围内,别在这上面纠结。

3.2 CBAM 与 ECA:空间注意力和无降维的通道交互

CBAM 在 SE 的基础上多了一条空间分支,ECA 则干脆把全连接换成 1D 卷积。三个模块可以共用一个注册表,主干只认名字。

class ChannelAttention(nn.Module): """CBAM 的通道分支:平均池化和最大池化两路共享 MLP,结果相加。""" def __init__(self, channels: int, reduction: int = 16): super().__init__() hidden = max(channels // reduction, 4) self.avg_pool = nn.AdaptiveAvgPool2d(1) self.max_pool = nn.AdaptiveMaxPool2d(1) self.mlp = nn.Sequential( nn.Conv2d(channels, hidden, 1, bias=False), nn.ReLU(inplace=True), nn.Conv2d(hidden, channels, 1, bias=False), ) self.sigmoid = nn.Sigmoid() def forward(self, x): # 平均看整体响应强度,最大看最显著的那个目标,两路互补 w = self.mlp(self.avg_pool(x)) + self.mlp(self.max_pool(x)) return x * self.sigmoid(w) class SpatialAttention(nn.Module): """CBAM 的空间分支:沿通道维取平均图和最大图,拼成 2 通道做一次卷积。""" def __init__(self, kernel_size: int = 7): super().__init__() self.conv = nn.Conv2d(2, 1, kernel_size, padding=kernel_size // 2, bias=False) self.sigmoid = nn.Sigmoid() def forward(self, x): avg_map = torch.mean(x, dim=1, keepdim=True) max_map, _ = torch.max(x, dim=1, keepdim=True) w = self.sigmoid(self.conv(torch.cat([avg_map, max_map], dim=1))) return x * w class CBAM(nn.Module): def __init__(self, channels: int, reduction: int = 16, kernel_size: int = 7): super().__init__() self.ca = ChannelAttention(channels, reduction) self.sa = SpatialAttention(kernel_size) def forward(self, x): # 顺序固定为先通道后空间,反过来在 7x7 以下的小特征图上收益不稳 return self.sa(self.ca(x))

SpatialAttention的kernel_size取 7 是论文默认值,它的感受野要能覆盖特征图上的目标才有意义。你在 CIFAR 上跑到 stage4,特征图只有 4×4,7×7 卷积的 padding 比图还大,这时候改成 3 更合理——这类根据输入分辨率调参的事,配置文件里留个字段就行。

ECA 的思路不一样,它认为 SE 的降维本身就破坏了通道和权重之间的对应关系,于是用 1D 卷积做局部跨通道交互,参数量只有k个:

class ECABlock(nn.Module): """无降维的通道注意力:每个通道只和相邻 k 个通道交互。""" def __init__(self, channels: int, gamma: int = 2, b: int = 1): super().__init__() # 卷积核大小随通道数自适应,公式来自 ECA 原文,k 必须取奇数 t = int(abs((torch.log2(torch.tensor(channels, dtype=torch.float32)) + b) / gamma)) k = t if t % 2 == 1 else t + 1 self.pool = nn.AdaptiveAvgPool2d(1) self.conv = nn.Conv1d(1, 1, kernel_size=k, padding=k // 2, bias=False) self.sigmoid = nn.Sigmoid() def forward(self, x): y = self.pool(x) # [N, C, 1, 1] y = y.squeeze(-1).transpose(-1, -2) # [N, 1, C],把通道维当成序列长度 y = self.conv(y) # 相邻通道做卷积,等价于局部跨通道交互 y = y.transpose(-1, -2).unsqueeze(-1) # 还原成 [N, C, 1, 1] return x * self.sigmoid(y)

channels=512时log2(512)=9,(9+1)/2=5,k=5;channels=64时算出 3,k=3。这个自适应公式保证深层(通道多)交互范围大、浅层范围小,比固定k=3在 ImageNet 上高零点几个点,但在小数据集上两者没区别,不用太当真。

三个模块统一注册,主干只认字符串:

# models/attention.py 末尾 ATTENTION_REGISTRY = { "none": lambda c, r: nn.Identity(), "se": lambda c, r: SEBlock(c, r), "cbam": lambda c, r: CBAM(c, r), "eca": lambda c, r: ECABlock(c), } def build_attention(name: str, channels: int, reduction: int = 16) -> nn.Module: if name not in ATTENTION_REGISTRY: raise KeyError(f"未知注意力类型 {name},可选:{list(ATTENTION_REGISTRY)}") return ATTENTION_REGISTRY[name](channels, reduction)

用nn.Identity()占位而不是if attn is not None到处判空,好处是forward里永远是一行out = self.attn(out),加不加模块代码路径完全一致,消融实验不会因为分支不同引入额外差异。

3.3 把注意力塞进残差块:顺序和初始化都是坑

改造后的 BasicBlock 长这样,关键点有三处注释标出来了:

class BasicBlock(nn.Module): expansion = 1 def __init__(self, inplanes, planes, stride=1, downsample=None, attn="se", reduction=16, zero_init_gamma=True): super().__init__() self.conv1 = nn.Conv2d(inplanes, planes, 3, stride, 1, bias=False) self.bn1 = nn.BatchNorm2d(planes) self.relu = nn.ReLU(inplace=True) self.conv2 = nn.Conv2d(planes, planes, 3, 1, 1, bias=False) self.bn2 = nn.BatchNorm2d(planes) self.downsample = downsample self.attn = build_attention(attn, planes, reduction) if zero_init_gamma: # bn2 的 gamma 置零,残差分支初始输出恒为 0,整个 block 起步等价于恒等映射 nn.init.zeros_(self.bn2.weight) def forward(self, x): identity = x if self.downsample is None else self.downsample(x) out = self.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) out = self.attn(out) # 注意力只重标定新学的残差,捷径保持干净 out = out + identity return self.relu(out)

第一处是zero_init_gamma。这一手是从残差改进的思路里借来的:把bn2的缩放系数初始化为 0,训练开始时每个 block 就是恒等映射,网络先学「不改变」,再逐步学「改变什么」。加了注意力模块之后这个技巧更有必要,因为注意力本身的 sigmoid 初始输出在 0.5 附近,相当于一上来就把残差砍半,深网络前几个 epoch 的 loss 会明显更抖。

第二处是顺序。bn2 → attn → add和bn2 → add → attn都能跑,但后者会让注意力连 identity 一起缩放,网络越深、identity 被反复乘的次数越多,实测在 ResNet-50 上验证集准确率会低 0.4 个点左右。

第三处是不给 downsample 分支加注意力。下采样那一支只有一次 1×1 卷积,通道数刚对齐,在这里加个 SE 收益几乎为零,还多一份参数。

Bottleneck 的改法一样,只是插在第三个 1×1 卷积后的bn3后面,通道数是planes * 4,别忘了乘expansion:

class Bottleneck(nn.Module): expansion = 4 def __init__(self, inplanes, planes, stride=1, downsample=None, attn="se", reduction=16, zero_init_gamma=True): super().__init__() width = planes * self.expansion self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False) self.bn1 = nn.BatchNorm2d(planes) self.conv2 = nn.Conv2d(planes, planes, 3, stride, 1, bias=False) self.bn2 = nn.BatchNorm2d(planes) self.conv3 = nn.Conv2d(planes, width, 1, bias=False) self.bn3 = nn.BatchNorm2d(width) self.relu = nn.ReLU(inplace=True) self.downsample = downsample # 注意这里是 width 不是 planes,写错会在第一次 forward 时报通道不匹配 self.attn = build_attention(attn, width, reduction) if zero_init_gamma: nn.init.zeros_(self.bn3.weight) def forward(self, x): identity = x if self.downsample is None else self.downsample(x) out = self.relu(self.bn1(self.conv1(x))) out = self.relu(self.bn2(self.conv2(out))) out = self.attn(self.bn3(self.conv3(out))) return self.relu(out + identity)

3.4 模型装配与参数量核对

装配层负责把attn、reduction透传到每个 block,同时统一做权重初始化:

# models/build.py import torch.nn as nn from .resnet import ResNet, BasicBlock, Bottleneck CFG = { "resnet18": (BasicBlock, [2, 2, 2, 2]), "resnet34": (BasicBlock, [3, 4, 6, 3]), "resnet50": (Bottleneck, [3, 4, 6, 3]), } def build_model(name="resnet18", num_classes=100, attn="se", reduction=16, zero_init_gamma=True): block, layers = CFG[name] model = ResNet(block, layers, num_classes=num_classes, attn=attn, reduction=reduction, zero_init_gamma=zero_init_gamma) # 常规初始化:卷积用 kaiming,BN 的 gamma 保持 1(前面已单独处理 bn2/bn3) for m in model.modules(): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu") elif isinstance(m, nn.BatchNorm2d): nn.init.ones_(m.weight) nn.init.zeros_(m.bias) return model

初始化顺序有讲究:先让build_model统一初始化,zero_init_gamma在 block 的__init__里已经置过零,但后面这个循环又把 BN 的weight全部ones_了——所以正确做法是把zero_init_gamma的处理挪到循环之后,或者在循环里跳过bn2/bn3。我一般直接挪到循环之后:

# 放在统一初始化之后,否则会被上面的 ones_ 覆盖掉 if zero_init_gamma: for m in model.modules(): if isinstance(m, (BasicBlock, Bottleneck)): target = m.bn2 if isinstance(m, BasicBlock) else m.bn3 nn.init.zeros_(target.weight)

装完先别急着训练,把参数量和前向耗时打出来对一眼,这是最省时间的自检:

def count_params(model): total = sum(p.numel() for p in model.parameters()) trainable = sum(p.numel() for p in model.parameters() if p.requires_grad) return total, trainable # 以 CIFAR-100 十类输出为例,实际是 100 类 for attn in ["none", "se", "cbam", "eca"]: m = build_model("resnet18", num_classes=100, attn=attn) t, _ = count_params(m) print(f"{attn:>5}: {t / 1e6:.2f} M")

在 ResNet-18 上大致是这样的量级:原版 11.2M,SE 加 0.11M,CBAM 加 0.12M,ECA 只加不到 0.001M。ECA 那个参数量少到你会怀疑它有没有生效,验证方法是打印一下eca.conv.weight.shape,看到[1, 1, 5]就对了。

提示:参数量不等于推理耗时。SE 里那个AdaptiveAvgPool2d加两次 1×1 卷积,在 GPU 上会引入额外的 kernel launch,实测 ResNet-18 + SE 的 batch=1 推理延迟比原版高 5%~8%,移动端部署要单独跑一遍 benchmark 再决定。

4. 训练流程:从数据管道到学习率调度的可复现配置

4.1 数据增强与 DataLoader 的几个关键参数

注意力模块对数据增强比主干更敏感——你等于在教网络「哪里重要」,如果增强把目标裁掉了,注意力学到的是噪声。所以RandomResizedCrop的scale下限别设太低,CIFAR 上我一般用(0.6, 1.0)而不是 ImageNet 那套(0.08, 1.0)。

# datasets/build.py import torch from torchvision import transforms, datasets from torch.utils.data import DataLoader def build_loader(cfg): train_tf = transforms.Compose([ transforms.RandomResizedCrop(32, scale=(0.6, 1.0), antialias=True), transforms.RandomHorizontalFlip(), transforms.ColorJitter(0.2, 0.2, 0.2), # 别开太大,颜色是重要线索时反而掉点 transforms.ToTensor(), transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276)), transforms.RandomErasing(p=0.25, value="random"), # 模拟遮挡,注意力更关注结构 ]) val_tf = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276)), ]) train_set = datasets.CIFAR100(cfg["data"]["root"], train=True, transform=train_tf, download=True) val_set = datasets.CIFAR100(cfg["data"]["root"], train=False, transform=val_tf) common = dict(batch_size=cfg["data"]["batch_size"], num_workers=cfg["data"]["num_workers"], pin_memory=True, persistent_workers=cfg["data"]["num_workers"] > 0) train_loader = DataLoader(train_set, shuffle=True, drop_last=True, **common) val_loader = DataLoader(val_set, shuffle=False, **common) return train_loader, val_loader

drop_last=True对加了 BN 的网络是必须的:最后一个 batch 只剩一两个样本时,BN 统计量会严重偏离,训练后期偶尔冒出一个尖峰 loss,八成就是它。persistent_workers在num_workers > 0时打开,避免每个 epoch 重启 worker 进程,CIFAR 这种小数据集上能省掉每次几秒的启动开销。

RandomErasing的p我一般给 0.25,配合注意力模块用效果比不加好一点。原理不玄学:随机挖掉一块之后,模型没法靠局部纹理蒙对,只能依赖更大范围的形状,而注意力恰好是学这个的。但p超过 0.5 会伤精度,别贪。

4.2 训练循环:AMP、梯度裁剪与 no_sync 之外的细节

训练循环本身没什么花活,但有三个地方决定你能不能一次跑通。第一个是optimizer.zero_grad(set_to_none=True),比默认的置零省一次显存写;第二个是 AMP 下的GradScaler,别手动.half();第三个是梯度裁剪,加了注意力之后梯度分布会比原版更散,clip_grad_norm_的阈值给 5.0 比较合适。

# engine/train.py import torch from tqdm import tqdm def train_one_epoch(model, loader, criterion, optimizer, scaler, device, epoch, clip=5.0): model.train() total_loss, correct, seen = 0.0, 0, 0 pbar = tqdm(loader, desc=f"train ep{epoch}", leave=False) for images, targets in pbar: images = images.to(device, non_blocking=True) targets = targets.to(device, non_blocking=True) optimizer.zero_grad(set_to_none=True) # 省一次显存写入 with torch.autocast(device_type="cuda", dtype=torch.float16): logits = model(images) loss = criterion(logits, targets) scaler.scale(loss).backward() # 先 unscale 再裁剪,否则裁的是被放大过的梯度,等于没裁 scaler.unscale_(optimizer) torch.nn.utils.clip_grad_norm_(model.parameters(), clip) scaler.step(optimizer) scaler.update() total_loss += loss.item() * targets.size(0) correct += (logits.argmax(1) == targets).sum().item() seen += targets.size(0) pbar.set_postfix(loss=f"{total_loss / seen:.4f}", acc=f"{correct / seen:.3f}") return total_loss / seen, correct / seen

scaler.unscale_(optimizer)这一行是最容易漏的。AMP 会把 loss 乘一个缩放系数再反传,梯度也跟着放大,直接裁剪等于阈值失效;unscale_之后梯度回到真实尺度,裁剪才有意义。而且unscale_每个 step 只能调一次,调完必须紧跟scaler.step(),中间不要再插别的反传,否则会抛RuntimeError: unscale_() has already been called。

学习率调度用 warmup + cosine,warmup 的 5 个 epoch 里线性从 0.01 倍爬到 1 倍。加了注意力模块的模型在头两个 epoch loss 下降会明显比原版慢(因为zero_init_gamma让残差分支一开始是零),别以为是代码写错了,跑到第 10 个 epoch 之后会追上来并反超。

def build_scheduler(optimizer, epochs, warmup=5): def lr_lambda(ep): if ep < warmup: return (ep + 1) / warmup progress = (ep - warmup) / max(1, epochs - warmup) return 0.5 * (1 + torch.cos(torch.tensor(progress * 3.14159)).item()) return torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)

4.3 评估、日志与可复现性

评估函数要区分 top-1 和 top-5,尤其是 CIFAR-100 这种 100 类任务,top-1 抖动大,top-5 更能看出模块之间的差异。

# engine/evaluate.py @torch.no_grad() def evaluate(model, loader, device): model.eval() top1, top5, seen = 0, 0, 0 for images, targets in loader: images = images.to(device, non_blocking=True) targets = targets.to(device, non_blocking=True) logits = model(images) # topk 返回的是值在前、索引在后,别把顺序写反 _, pred = logits.topk(5, dim=1, largest=True, sorted=True) correct = pred.eq(targets.view(-1, 1).expand_as(pred)) top1 += correct[:, :1].sum().item() top5 += correct.any(dim=1).sum().item() seen += targets.size(0) return top1 / seen, top5 / seen

可复现性上,torch.backends.cudnn.benchmark = True会让每次输入尺寸变化时重新选卷积算法,速度能快 10%~20%,但结果不完全可复现。做消融对比的时候我一般关掉它,宁可慢一点也要保证两组实验只差一个变量;等到确定方案、跑最终结果时再打开。

# utils/seed.py import os, random import numpy as np import torch def set_seed(seed=42, deterministic=True): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) os.environ["PYTHONHASHSEED"] = str(seed) if deterministic: torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True

日志同时写控制台和 TensorBoard,重点记三个量:train/loss、val/top1、lr。加了注意力之后我还会额外记一下每个注意力模块 sigmoid 输出的均值,方法是在模块里挂个 hook 把w.mean()存到 buffer 里。如果某一层的权重均值长期贴着 0.05 或 0.95,说明这层在「关死」或者「常开」,基本等于没起作用,这时候该考虑降reduction或者干脆去掉这一层的模块。

5. 避坑与排查:注意力模块最容易翻车的五个地方

5.1 精度类:加了模块反而掉点

现象:同一份数据、同一套超参,加 SE 之后验证集 top-1 比原版低 0.5~1.5 个点,训练集却更高。

原因:多数情况是学习率没跟着调。加注意力等于给网络多塞了一层乘性门控,等效于缩小了有效学习率,但也可能反过来让浅层梯度变大。另一种情况是数据量太小,注意力模块把有限的信息过度集中到少数通道上,训练集拟合得飞快,验证集直接崩。

解决:先把lr降一半试,还不行就把reduction从 16 调到 8(中间层更宽、表达更强,但更容易过拟合,小数据集反而要往 32 调)。数据量小于 5000 张时,改成只在每个 stage 最后一个 block 插模块,参数量砍到三分之一,我这边实测能回 0.8 个点。

5.2 精度类:模块不生效但你不知道

现象:训练正常、精度也正常,但把注意力模块整个换成nn.Identity(),结果几乎没变。

原因:zero_init_gamma和注意力的初始化撞车了。如果bn2的 gamma 是 0,残差分支输出恒为 0,传进注意力的特征全是零,池化出来也是零,sigmoid(0)=0.5,权重恒定,等于没学。更隐蔽的一种是reduction设得太大,中间层只剩 4 个通道(被max(..., 4)兜住了),表达能力不够,学出来的权重接近常数。

解决:训练 20 个 epoch 后把某个 block 的attn.fc[-2].weight打出来看,如果标准差小于 1e-3,说明确实没学动。要么关掉zero_init_gamma,要么把reduction降到 8 以下。

5.3 稳定性类:loss 变 NaN

现象:训练到第 30 个 epoch 左右 loss 突然变 NaN,前面一切正常。

原因:两个高频原因。一是 AMP 下Sigmoid在 fp16 里输入绝对值超过 20 就饱和成 0 或 1,反传梯度直接为 0,配合后面的除法或者 LN 就炸;二是channels // reduction在某些自定义宽度下算出 0,Conv2d(64, 0, 1)不报错但输出维度是 0,等到下一步 reshape 才炸,报错信息跟真正的原因隔了十万八千里。

解决:hidden = max(channels // reduction, 4)这行兜底一定要留;AMP 已经在autocast里自动把 sigmoid 提到 fp32 算,但要是你自己在外面套了.half()就失效了,检查有没有手动转半精度的地方。真遇上 NaN,先用torch.autograd.set_detect_anomaly(True)跑一遍定位到具体算子,别靠猜。

5.4 稳定性类:多卡训练精度抖动大

现象:单卡跑到 78.5%,换成 4 卡 DDP 之后同样的配置只到 77.2%,而且每次跑波动能有 0.6 个点。

原因:batch_size从 128 变成 512,等效学习率没跟着放大,warmup 又只有 5 个 epoch,前几轮基本在白跑。另外如果用了SyncBatchNorm以外的 BN,每张卡上的统计量只来自本卡的样本,注意力权重会更抖。

解决:lr按batch_size线性放大(128→512 时 0.1→0.4),warmup 同步拉长到 8~10 个 epoch;多卡一定用nn.SyncBatchNorm.convert_sync_batchnorm(model),转换要在DDP(model)之前做。改完再跑一次,如果还是抖,把drop_last确认一遍。

5.5 工程类:导出 ONNX 直接报错

现象:torch.onnx.export跑到 ECA 那里抛Unsupported: ONNX export of operator Conv1d with dynamic kernel,或者 SE 那里说AdaptiveAvgPool2d输出尺寸不匹配。

原因:ECA 里的k是在__init__里用torch.log2算的,如果你图省事把这段写进了forward,导出时 trace 会把它当成动态计算;AdaptiveAvgPool2d(1)在 opset 9 以下的支持也不完整,会退化成固定尺寸的AveragePool。

解决:k一定在__init__里算完存成 Python int,forward里只做张量运算;导出时opset_version=12起步,并显式model.eval()。SE 的池化换成nn.AdaptiveAvgPool2d(1)在 opset 12 上是支持的,再低就得改成nn.AvgPool2d(kernel_size=x.size(-1))这种固定尺寸写法。

注意:导出之后一定要用onnxruntime跑一遍,把同一份输入的输出和 PyTorch 对比,误差在 1e-4 以内才算过。只看导出没报错是不够的,SE 的乘法顺序错了照样能导出,只是结果全错。

6. 二次开发:换模块、跑消融、接进自己的工程

拿到这份代码之后最常做的二次开发,是接一种不在注册表里的注意力。做法很简单:在attention.py里写个接收(channels, reduction)的类,返回[N, C, H, W]形状的张量,然后在ATTENTION_REGISTRY里挂一行名字。比如想试「只对通道维做 GroupNorm 再算权重」的变体,几十行就够,主干和训练脚本一行都不用动。

跑消融的时候有个规矩:一次只改一个变量。常见翻车是同时换了注意力和lr,最后精度涨了 1 个点,你根本说不清是模块的功劳还是调参的功劳。我一般的对照表是这样的:

实验名主干注意力插桩位置lr目的
baseliner18none-0.1对照组
se_fullr18se r=16全 block0.1单独看 SE 收益
se_lastr18se r=16每 stage 末0.1看减少插桩的代价
se_full_lr05r18se r=16全 block0.05排除学习率干扰
cbam_fullr18cbam r=16全 block0.1换模块对比

每个实验固定种子跑三次取均值,看标准差,别只跑一次就下结论——CIFAR 这种规模,单次结果和三次均值的差异能到 0.4 个点,比你要测的模块收益还大。

想把它搬进自己的分类工程,改动量其实只有三处:把attention.py和resnet.py拷过去;在你自己建主干的地方把block换成带attn参数的版本;在配置里加一个attn字段。如果你的主干是torchvision.models.resnet18,不想改源码,也有个取巧办法:遍历model.layer1~4的每个 block,把block.bn2后面塞一个nn.Sequential(original_forward)的钩子——不建议,钩子多了之后state_dict的 key 会变得没法看,调试时抓瞎。老老实实复制一份改过的resnet.py,长远看省事得多。

验证效果别只盯最后那个 top-1。我习惯在训练结束后额外看一眼注意力权重的分布:把某层的w拿出来在验证集上求均值,画个通道维的直方图。如果分布接近一条平线(所有权重都差不多),说明这层根本没学出选择性,加了等于加了个恒等映射加噪音。真正起作用的层,直方图会有明显的双峰或者长尾。这个检查花不了五分钟,但能让你在写论文或者交付前少走一大截弯路。

踩过最疼的一次,是拿一个加了 SE 的 ResNet-34 去做迁移,源域上涨了 0.9 个点,换到目标域反而掉 1.2 个点,回头查了半天才发现是zero_init_gamma打开着、迁移时又是整模型加载权重,bn 的 gamma 全被覆盖成了预训练值,zero_init这个初值压根没生效,相当于两边实验条件根本不一样。从那以后我每次跑消融,都会在脚本开头打印一遍「本次实验的关键开关」——attn、reduction、zero_init_gamma、lr、batch_size、seed,六个字段写进日志第一行。看着傻,但真能救你一次返工。希望帮到你。

本文还有配套的精品资源,点击获取

返回列表