企业官网建设流程全解析

做图像分类的模型跑不动、涨点慢的时候，我第一个想到的补丁往往不是换 backbone，而是往卷积块里塞一个轻量的注意力模块。CNN 的注意力机制这几年已经攒下了一大批成熟实现，SE、ECA、CBAM 是最常用的三个，代码短、参数少、几乎不用改训练流程，插进 ResNet、MobileNet 甚至 YOLO 的 backbone 里，很多时候都能拿到零点几个点到一两个点的提升。这篇就把这三个模块从头到尾拆一遍：原理讲透，PyTorch 代码给全，包括怎么插进 ResNet 的 Bottleneck、怎么核算多出来的参数量、以及我在实际训练里踩过的那些坑。如果你刚搭好 PyTorch 环境，能跑通一个 ResNet 训练脚本，那这篇内容可以直接抄作业；如果你已经用过注意力模块但总觉得"加了没效果"，后面关于插入位置和超参的部分应该更对你有用。

1. 卷积到底缺了什么：注意力机制要补的短板

先别急着看代码。理解一个模块为什么这么设计，比记住它的实现更重要，因为真正决定涨不涨点的是"你把它插在哪、为了补什么缺陷"，而不是模块本身。

1.1 局部性与固定权重的先天限制

卷积操作有两个刻在骨子里的性质：局部连接和平移等变性。一个 3×3 卷积核只看得到 3×3 邻域，靠层层堆叠来扩大感受野；同时，同一个卷积核在整张特征图上滑动时权重完全共享，也就是说，不管这个位置是猫的耳朵还是背景的树叶，网络用的都是同一套权重。

这套设计非常高效，参数量小、泛化性好，是 CNN 能在图像任务上碾压全连接网络的根本原因。但它的短板也很明显：权重一旦训练完就固定了，推理时不会根据输入内容做任何调整。一张图里真正有用的信息可能只集中在少数通道和少数空间位置上，其余大部分计算其实是在处理背景噪声。理想情况下，网络应该有能力"看一眼当前这张图，再决定把注意力放在哪几个通道、哪几块区域上"。

注意力机制干的就是这件事。它的核心动作叫特征重标定（feature recalibration）：先对特征做一个全局统计，得到一组描述"当前输入里什么重要"的系数，再把这组系数乘回原特征上。这个过程是数据驱动的，同一层卷积在不同图片上会产生不同的注意力权重，这就补上了卷积"权重固定"的短板。你可以把它理解成给每个通道、每个位置动态调音量——该响的地方调大，背景噪声压下去。

1.2 通道与空间的两个维度：注意力该加在哪

特征图的形状是(B, C, H, W)，注意力可以从三个维度下手：通道维（哪个通道重要）、空间维（哪个位置重要）、以及两者结合。目前主流的做法基本都在通道和空间这两个维度上做文章，原因也很直白：通道本质上代表"某种语义特征的检测器"，空间代表"这个特征出现在哪里"，这两者对分类、检测任务的影响最大。

把三个模块放在一起对比，你会发现它们的差异其实就在"怎么算权重"和"算哪个维度"上：

表格里的参数量是按 ResNet-50 整体估算的，具体数字和你的实现细节有关，下面第 3 章我会把计算过程完整推一遍，你可以照着算自己模型的情况。这里只需要先建立一个直觉：SE 最"重"，ECA 最"轻"，CBAM 介于中间但覆盖了两个维度。

还有一点值得提前说明：这三个模块都属于"即插即用"的 plugin，不改变特征图的尺寸和通道数，所以可以塞进任何现成网络的任何位置，不需要改后续结构。这是它们能被大量工程直接采用的关键原因——改动成本几乎为零，收益却相对确定。

2. SE、ECA、CBAM 三个模块的原理与设计取舍

三个模块出自三篇论文，思路有继承关系：SE 提出通道注意力的基本范式，ECA 指出 SE 里降维这一步其实有害，CBAM 则把注意力扩展到空间维度。按这个顺序看，设计动机就很清楚了。

2.1 SE：压缩-激励，通道重标定的开山之作

SE 模块（Squeeze-and-Excitation）把整个流程拆成三步，命名就来自前两步。

第一步是 Squeeze（压缩）。对每个通道做全局平均池化，把(B, C, H, W)压成(B, C, 1, 1)。这一步的作用是让每个通道拿到一个能代表自己"整体活跃程度"的标量。为什么要用全局平均池化而不是别的？因为它把空间信息做了加权平均，得到的数值对图像里目标的位置不敏感——不管猫在左上角还是右下角，只要这个通道在响应猫，池化后的值就大。这种位置无关性正是通道注意力需要的。

第二步是 Excitation（激励）。把C维向量过两层全连接：第一层把维度降到C/r（r 是 reduction ratio，默认 16），过 ReLU，第二层再升回C，最后过 Sigmoid 得到 0~1 之间的权重。写成公式是：

s = sigmoid(W2 * ReLU(W1 * z))

这里的降维-升维结构是个瓶颈（bottleneck），它做了两件事：一是限制参数量，二是引入非线性，让模块能学到通道之间的组合关系，而不是简单地按通道自身的均值排序。ReLU 保证了权重是非负的稀疏表达，Sigmoid 则负责把输出压到 0~1，方便当作乘性系数。

第三步是 Reweight（重标定）。把(B, C, 1, 1)的权重广播乘回原特征图。注意这里用的是乘法而不是加法或者拼接，好处是不改变特征的数值尺度，也不增加通道数，后续层的接口完全不用动。

有两个实现细节新手经常忽略。一个是两层 FC 都不加 bias，因为后面紧跟着 BN 和归一化性质的 Sigmoid，加 bias 属于冗余参数，原论文实现里也是bias=False。另一个是 ReLU 要用inplace=True，省一点显存，不过在需要梯度检查或者做可视化的时候要小心，inplace 操作会覆盖输入张量，可能影响反向传播中间变量的读取。

SE 的效果在原始报告里是很扎实的：ResNet-50 在 ImageNet 上 top-1 提升大致在 1 个点上下，代价是参数量增加约 10%、计算量几乎不变（因为池化和 FC 的开销相对卷积可以忽略）。它的局限也很明显：两次全连接引入了2*C*C/r的参数量，通道数大的时候（比如 2048）这部分开销不小；而且降维操作会损失一部分通道信息。

2.2 ECA：把降维全连接换成自适应一维卷积

ECA（Efficient Channel Attention）的核心洞察很有意思：作者做了一组对比实验，发现 SE 里那个降维步骤对最终的通道注意力效果是负面的。维数降下去再升回来，虽然省了参数，但把通道之间的部分关联信息也一并压掉了。于是 ECA 的做法是：干脆不降维，直接在通道维度上做一维卷积。

流程是这样：全局平均池化得到(B, C, 1, 1)，reshape 成(B, 1, C)，用一个长度为k的一维卷积在这条通道序列上滑动，输出还是(B, 1, C)，再过 Sigmoid，最后乘回原特征。每个通道的权重由它自己加上左右各(k-1)/2个邻居通道共同决定——这就是所谓的局部跨通道交互。

关键问题是k取多少。ECA 没有把它设成固定值，而是设计了一个和通道数挂钩的自适应公式：

k = | (log2(C) + b) / gamma |_odd

其中gamma = 2、b = 1，| |_odd表示取最近的奇数。用 ResNet-50 的各个 stage 算一下就很直观了。stage2 输出通道 C=256，log2(256)=8，(8+1)/2=4.5，取整为 4 是偶数，向上取到 5，所以 k=5；stage3 的 C=512，log2=9，(9+1)/2=5，本身就是奇数，k=5；stage4 的 C=1024，log2=10，(10+1)/2=5.5，取整 5，k=5；stage5 的 C=2048，log2=11，(11+1)/2=6，偶数取 7，k=7。

看出来了吗？通道数从 256 涨到 2048，卷积核只从 5 变到 7。这就是 ECA 的聪明之处：高层语义的通道数翻了好几倍，但真正需要交互的邻居通道数并不需要等比例增长，用对数关系描述足够了。整个模块的参数量就是k个，ResNet-50 上总共几千个参数，和 SE 的两百多万完全不在一个量级。

注意：实现一维卷积时，padding必须设为kernel_size // 2，这样输出长度才等于输入长度。由于 k 一定取奇数，这个整除是精确的，不会出现长度对不齐的问题。另外卷积核要用bias=False，因为后面接 Sigmoid，偏置项没有意义。

2.3 CBAM：通道与空间串行组合，为什么不是并行

CBAM（Convolutional Block Attention Module）把注意力拆成两个子模块串行处理：先通道注意力，再空间注意力。

通道注意力部分和 SE 长得像，但有个重要区别：SE 只用平均池化，CBAM 同时用平均池化和最大池化，两者各自过一个共享权重的 MLP（两层 1×1 卷积，先降维到C/r再升回来），结果相加后过 Sigmoid。用最大池化的理由很实在：平均池化会把特征图上的显著响应"平均掉"，如果某个通道只有一小块区域有强响应，平均之后这个通道的权重会被拉低；最大池化能把这个峰值保留下来，两种统计量互补。

空间注意力部分则换了思路：在通道维度上做平均池化和最大池化，各得到一张(B, 1, H, W)的单通道图，把两张图拼接成(B, 2, H, W)，再用一个 7×7 卷积把 2 通道压成 1 通道，过 Sigmoid，得到每个空间位置的权重图，广播乘回原特征。这里用 7×7 而不是 3×3，是因为空间注意力需要看到足够大的邻域才能判断"这块区域是不是目标"，感受野太小会退化成逐像素的局部操作。

**为什么串行而不是并行？**这个问题我在读论文时也纠结过。原论文做过消融，串行（通道在前、空间在后）的效果最好。我的理解是：通道注意力做的是"选哪类特征"的粗筛，它会先改变每个通道的整体强度；空间注意力在这个基础上再问"这个特征图上哪块位置值得保留"。反过来先做空间再做通道，相当于在还没筛选语义的情况下先划位置，两个阶段的判断会互相干扰。另外通道注意力输出仍是(B, C, H, W)，可以直接喂给空间注意力，接口天然对齐，不需要做任何 reshape。

CBAM 的参数量主要在通道注意力的 MLP 上。由于用的是 1×1 卷积实现，且两层共享权重（avg 和 max 走同一个 MLP），参数量约等于2*C*C/r，和 SE 同量级但略小，因为它的空间部分只有 49 个参数（7×7×2→1，bias=False）。

3. PyTorch 完整实现与逐行注释

原理讲完，接下来是可运行的代码。我把三个模块都写成独立类，接口统一为"输入输出同形状"，这样你可以在任何地方插拔。所有代码都在 PyTorch 1.x/2.x 上实测通过，不需要额外依赖。

3.1 SEBlock 实现

import torch import torch.nn as nn class SEBlock(nn.Module): """Squeeze-and-Excitation 通道注意力""" def __init__(self, channels, reduction=16): super().__init__() # 全局平均池化，把 (B, C, H, W) 压成 (B, C, 1, 1) self.avg_pool = nn.AdaptiveAvgPool2d(1) # 瓶颈结构：C -> C/r -> C self.fc = nn.Sequential( nn.Linear(channels, channels // reduction, bias=False), nn.ReLU(inplace=True), nn.Linear(channels // reduction, channels, bias=False), nn.Sigmoid() ) def forward(self, x): b, c, _, _ = x.size() # Squeeze y = self.avg_pool(x).view(b, c) # Excitation y = self.fc(y).view(b, c, 1, 1) # Reweight，expand_as 保证广播形状和输入一致 return x * y.expand_as(x)

用Linear而不是Conv2d(1x1)实现全连接，是因为AdaptiveAvgPool2d(1)之后特征图已经退化成一个向量，用Linear语义更清楚、写法更短。expand_as是个小技巧，它在(B, C, 1, 1)和(B, C, H, W)之间做广播乘法，不会真的复制内存，比手写repeat更省。

reduction参数默认 16，这是原论文在 ResNet 上搜索出来的结果。如果你用的是 MobileNet 这类通道数本来就很少的网络，比如某个 block 只有 16 个通道，那16 // 16 = 1，中间层只有一个神经元，信息几乎被压没了，这时候应该把 reduction 调成 4 或者 8。这是个很常见的坑，后面还会提到。

3.2 ECABlock 实现

import math class ECABlock(nn.Module): """Efficient Channel Attention，用一维卷积做局部跨通道交互""" def __init__(self, channels, gamma=2, b=1): super().__init__() # 自适应卷积核大小 t = int(abs((math.log(channels, 2) + b) / gamma)) k = t if t % 2 else t + 1 self.k = k self.avg_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): # (B, C, H, W) -> (B, C, 1, 1) y = self.avg_pool(x) # (B, C, 1, 1) -> (B, 1, C)，把通道当成序列长度 y = y.squeeze(-1).transpose(-1, -2) # 一维卷积，(B, 1, C) -> (B, 1, C) y = self.conv(y) # 变回 (B, C, 1, 1) y = y.transpose(-1, -2).unsqueeze(-1) return x * self.sigmoid(y)

这里transpose(-1, -2)配合squeeze(-1)完成形状变换，比view更安全，因为它在处理非连续张量时不会报错。有几个细节必须留心：

• int()是截断取整不是四舍五入，当(log2(C)+b)/gamma落在 4.5 这种位置时，int(4.5)得到 4，然后因为 4 是偶数再加 1 变成 5。这个行为和论文公式里的取整方式一致。
• padding=k // 2保证了输出长度不变。由于 k 必然是奇数，k//2在二维意义上是对称 padding，两端正好对齐。
• 卷积核的值在训练前是随机初始化的，代码里没有对它做特殊初始化。原论文是这样做的，不必额外处理。

关于k的一个实用建议：如果你的通道数在训练过程中会有变化，或者你打算把这个模块塞进一个通道数很小的网络，最好在__init__里打印一下算出来的k，确认它是合理的奇数（一般落在 3~9 之间）。我见过有人手抖把gamma写成 1，结果 k 变成 11 甚至更大，一维卷积核长过通道数，padding 之后就相当于在常数 0 上做卷积，输出完全失真。

3.3 CBAM 实现

CBAM 拆成两个类写会更清晰，便于单独使用或者替换其中一个子模块。

class ChannelAttention(nn.Module): """CBAM 的通道注意力分支，平均池化 + 最大池化共享 MLP""" def __init__(self, channels, reduction=16): super().__init__() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.max_pool = nn.AdaptiveMaxPool2d(1) # 用 1x1 卷积实现 MLP，方便在两个分支间共享权重 self.mlp = nn.Sequential( nn.Conv2d(channels, channels // reduction, 1, bias=False), nn.ReLU(inplace=True), nn.Conv2d(channels // reduction, channels, 1, bias=False) ) self.sigmoid = nn.Sigmoid() def forward(self, x): avg_out = self.mlp(self.avg_pool(x)) max_out = self.mlp(self.max_pool(x)) return x * self.sigmoid(avg_out + max_out) class SpatialAttention(nn.Module): """CBAM 的空间注意力分支，通道维池化 + 7x7 卷积""" def __init__(self, kernel_size=7): super().__init__() assert kernel_size in (3, 7), "kernel_size 建议取 3 或 7" self.conv = nn.Conv2d(2, 1, kernel_size, padding=kernel_size // 2, bias=False) self.sigmoid = nn.Sigmoid() def forward(self, x): avg_out = torch.mean(x, dim=1, keepdim=True) # (B,1,H,W) max_out, _ = torch.max(x, dim=1, keepdim=True) # (B,1,H,W) y = torch.cat([avg_out, max_out], dim=1) # (B,2,H,W) return x * self.sigmoid(self.conv(y)) class CBAM(nn.Module): """通道注意力在前，空间注意力在后，串行组合""" def __init__(self, channels, reduction=16, kernel_size=7): super().__init__() self.ca = ChannelAttention(channels, reduction) self.sa = SpatialAttention(kernel_size) def forward(self, x): x = self.ca(x) x = self.sa(x) return x

几点说明。第一，通道注意力里 MLP 用Conv2d而不是Linear实现，好处是输入输出都是 4D 张量，avg 分支和 max 分支直接复用同一个self.mlp对象，权重天然共享，不用手动做参数绑定。第二，torch.max返回的是(values, indices)的元组，只取第一个值，所以必须写max_out, _ = ...，这个细节写错的话会得到一个 tuple，后面cat直接报类型错误。第三，空间注意力用torch.mean和torch.max在dim=1上做池化，注意keepdim=True，否则维度会被压掉，cat的时候对不上。

kernel_size参数我加了个断言，限制只能取 3 或 7。理论上任意奇数都能跑，但论文里只做过这两个的消融，7 的效果略好。如果你在检测任务的小目标分支上用，可以试试 3，感受野小一些可能对小目标更友好，这算是我自己做检测时的一个经验。

3.4 插进 ResNet Bottleneck：位置、代码与参数量核算

模块写好了，接下来是最关键的一步：插在哪。以 ResNet-50 的 Bottleneck 为例，它的结构是1x1 降维 -> 3x3 卷积 -> 1x1 升维，然后加残差。注意力模块应该加在升维之后、残差相加之前。

原因有两层。一是通道数问题：SE 和 CBAM 都需要知道通道数来构建 FC，如果在 1x1 升维之前插，通道数是planes，升维后是planes*4，两次插就没意义了；放在最后，通道数是确定的planes*4。二是残差结构的语义：残差分支输出的是"要叠加到主干上的增量"，在这个增量进入加法之前做重标定，等于是在告诉网络"这一层的这 4 倍通道里，哪部分对当前样本更重要"，然后再和恒等映射相加。如果加在加法之后，重标定就会同时作用到恒等路径上，破坏了残差"无阻碍直连"的设计初衷。

class Bottleneck(nn.Module): expansion = 4 def __init__(self, inplanes, planes, stride=1, downsample=None, norm_layer=None, attn="se", reduction=16): super().__init__() if norm_layer is None: norm_layer = nn.BatchNorm2d width = planes self.conv1 = nn.Conv2d(inplanes, width, 1, bias=False) self.bn1 = norm_layer(width) self.conv2 = nn.Conv2d(width, width, 3, stride=stride, padding=1, bias=False) self.bn2 = norm_layer(width) self.conv3 = nn.Conv2d(width, planes * self.expansion, 1, bias=False) self.bn3 = norm_layer(planes * self.expansion) self.relu = nn.ReLU(inplace=True) self.downsample = downsample self.stride = stride out_ch = planes * self.expansion if attn == "se": self.attn = SEBlock(out_ch, reduction) elif attn == "eca": self.attn = ECABlock(out_ch) elif attn == "cbam": self.attn = CBAM(out_ch, reduction) else: self.attn = nn.Identity() # 关闭注意力，做消融对比用 def forward(self, x): identity = x out = self.relu(self.bn1(self.conv1(x))) out = self.relu(self.bn2(self.conv2(out))) out = self.bn3(self.conv3(out)) out = self.attn(out) # 注意力在残差相加之前 if self.downsample is not None: identity = self.downsample(x) out += identity return self.relu(out)

这个attn参数设计成字符串开关，好处是同一份代码可以通过改一个参数在四种配置之间切换，做消融实验时特别省事。nn.Identity()是个空操作，直接返回输入，等价于不加注意力，用它做基线最干净。

接下来算参数量，这是很多人关心的实际问题。ResNet-50 的四个 stage 输出通道分别是 256、512、1024、2048，每个 stage 的 block 数分别是 3、4、6、3。

以 SE 为例，单个 block 的额外参数是两层 FC，C -> C/16 -> C，都无 bias，所以是2*C*(C/16) = C²/8。逐 stage 计算：

加起来约 2.51M，而 ResNet-50 本身约 25.6M，所以增幅接近 10%。FLOPs 几乎没变化，因为全局池化和 FC 的计算量相对卷积可以忽略。这个"参数量涨 10%、精度涨 1 个点"的性价比，在当年是相当划算的。

ECA 就没什么好算的了，每个 block 的额外参数只有k个（k 取值 5 或 7），16 个 block 加起来不到 100 个参数。CBAM 的通道分支约2*C*C/16，和 SE 同量级，空间分支固定 98 个参数（7×7×2，无 bias），整体比 SE 略小。

提示：如果你要做严格的对比实验，记得把基线也重新训练一遍。注意力模块带来的提升有时候和训练轮数、数据增强策略有交互，直接拿论文里的基线数字对比自己的实验，结论很容易失真。

4. 训练实测、超参选择与排错清单

代码能跑通只是第一步，真正决定效果的是插入位置、超参和训练策略。这部分我按自己踩坑的顺序来讲。

4.1 模块怎么选、插在哪一层

先说选型。如果你不确定用哪个，我的建议顺序是：先试 ECA，再试 SE，最后试 CBAM。理由很实际：ECA 几乎不增加参数和显存，对训练稳定性影响最小，能快速验证"这个任务到底吃不吃注意力"；如果 ECA 有提升，说明通道维度确实存在冗余，再换 SE 看能不能拿到更多；如果通道注意力效果一般，但你的任务是检测、分割这类对位置敏感的任务，那 CBAM 的空间分支值得一试。

再说插入位置。这里有个反直觉的经验：不是插得越多越好。SE 原论文其实做过对比，只在每个 stage 的最后一个 block 插入，或者全部 block 都插入，两者差距不大，但全部插入的参数量和显存占用明显更高。我在自己的数据集上做过一轮消融，结论是：

高层（stage4、stage5）的通道数大、语义强，注意力能发挥的空间也大；低层（stage2）的特征还比较底层，加了注意力收益有限，反而增加参数量。所以预算有限时优先保证高层。

最后提醒一点关于 reduction ratio 的设置。如果某个 block 的通道数是 256，256/16=16，中间层 16 维，是合理的；但如果你的网络比较轻量，某个 block 输出只有 32 通道，32/16=2，中间层只剩 2 维，信息压缩过度，效果可能反而变差。这种情况下把 reduction 改成 4（中间层 8 维）或者 8（中间层 4 维）更稳妥。判断标准很简单：中间层维度不要低于 8。

4.2 常见问题速查表

下面这些坑我在不同项目里基本都踩过一遍，整理成表方便你对照排查。

关于第一行"loss 震荡"这个现象，多说两句。SE 的 Sigmoid 输出在极端情况下会非常接近 0，这时候对应的通道在前向传播里几乎被"关掉"，反向传播时梯度也接近 0。训练早期权重是随机的，如果某一批数据让某些通道被判为不重要，这些通道就学不动了，表现出来就是 loss 忽上忽下。我的处理方式是把注意力模块的输出和原特征做一个带系数的加权，也就是out = x * (1 + alpha * attn)，用一个小的alpha（比如 0.1）做残差式的注意力。这样即使注意力全为 0，也不至于把通道直接关死。这个方法不是标准做法，属于工程上的小修补，但在小数据集上确实更稳。

4.3 我自己的几条实操心得

实验做多了，有些经验是文档里不会写的，这里一并交代。

第一，注意力的收益和数据规模强相关。在小数据集（比如几万张）上，SE 带来的提升可能只有零点几个点甚至不显著，而且容易过拟合——因为注意力模块本身也是要学的参数。数据量足够大（十万张以上）时，它的价值才比较明显。如果你手上数据不多，我建议先用 ECA 这种参数极少的模块试水，别一上来就上 SE 或者 CBAM。

第二，先验证基线，再加模块。我见过太多人拿一个没调好的基线去加注意力，结果模块成了背锅侠。正确的做法是先把基线训练到收敛、确认超参合理，然后只改动一处（加注意力），其他条件完全不变，这样才能得到干净的对比结论。如果一次改了三四个地方，涨了不知道是谁的功劳，掉了也不知道该回退哪个。

第三，可视化注意力权重来判断模块是否真的在起作用。方法很直接：在 forward 里把 SE 的y或者 CBAM 的通道权重存下来，对验证集的一批图片做平均，画成柱状图看分布。如果所有通道的权重都挤在 0.5 附近，说明模块没学到东西，基本等价于恒等映射；如果分布明显分化，有高有低，说明它确实在做筛选。空间注意力可以上采样成热力图叠加到原图上，看它关注的区域是否落在目标上。这个检查花不了十分钟，但能省下几轮无效训练。

第四，注意 BN 和注意力的顺序。在 Bottleneck 里，注意力模块接在bn3之后、残差相加之前，也就是说它作用在已经归一化过的特征上。如果在 BN 之前插入，特征的数值尺度还没统一，全局池化的统计量会受到 batch 内样本差异的影响，效果不稳定。这个顺序尽量不要改。

第五，迁移学习场景下要留意预训练权重。如果你加载的是官方 ResNet 的预训练权重，插入注意力模块后，新增的层是随机初始化的，其余层是预训练的。这时候不要立刻用大学习率全局微调，容易把预训练特征冲掉。我的做法是分两段训练：先冻结 backbone 只训练新增的注意力层和分类头几个 epoch，再解冻全局用小学习率微调。这样收敛更稳，最终精度也更高一些。

最后再补一个关于推理部署的提醒。ECA 用了一维卷积，CBAM 用了 7×7 卷积，SE 用了一维池化加 FC，这些算子在常见推理框架里的支持情况不一样。导出的时候建议先跑一遍计算图，确认没有算子被拆成不支持的组合；如果某个分支导出失败，可以把 SE 的全连接换成等价的 1×1 卷积，两者在数学上完全等价，但卷积算子的兼容性通常更好。

我在实际使用中的体会是，注意力模块本身并不神秘，它就是个参数很少的小网络，学的是一组动态权重。真正花时间的地方在于：选哪个模块、插在哪、reduction 和 kernel_size 怎么定、以及怎么设计一组能说明问题的对比实验。把这几件事做扎实，比反复换模块带来的收益大得多。