SK Attention：多尺度感受野选择机制与PyTorch实现

图片分类任务做多了，会发现一个现象：模型对“这到底是纹理还是形状”的判断，往往不取决于训练多久，而取决于卷积核的尺寸。3x3 的核盯着局部边缘，5x5 能扫到一小片纹理，7x7 已经能看到部件级结构。传统做法是拍脑袋定一个尺寸，或者堆多列不同尺寸的卷积再 concat 起来——这就是 Inception 系列的思路。但 concat 的问题很直白：它只是把不同感受野的特征并排放着，后面的层要自己去学“该听谁的”。SK Attention 就是冲着这个“该听谁的”去的。它属于通道注意力大类里一个相当特别的分支：不是给通道打分，而是给“卷积核尺寸”打分。这篇内容我会把 SK Attention 的 Split-Fuse-Select 结构完整拆开，给出可直接跑的 PyTorch 实现，把维度变换一步步走一遍，再把踩过的坑、参数怎么选、哪些层该加哪些不该加全倒出来。适合已经能写基本 Conv-BN-ReLU、想搞明白注意力模块底层逻辑的人，也适合手里有现成骨干网、想低成本试一把多尺度选择的人。

1. 先把 SK Attention 的定位搞清楚

1.1 它做的是“选择题”，不是“加权和题”

很多人第一次看 SK 的公式，会把它归类成普通的通道注意力，觉得无非是 SE 的变体。这个理解偏了，而且会导致后面调参完全找不着北。SE 的输入只有一条特征流，它对这条流的每个通道算一个 0 到 1 的门控值，本质是通道维度的重标定。SK 的输入不是一个，而是 M 条并行分支，每条分支用不同尺寸的卷积核处理同一份输入，最后它算出来的权重是每个通道上、跨分支归一化的一组概率，且这组概率在 M 个分支上求和恒等于 1。

这个区别带来的后果很实际。SE 的权重是独立的 sigmoid 门控，理论上所有通道可以同时被放大到接近 1，也可以同时被压到接近 0；而 SK 的 softmax 是竞争性的，分支 A 拿到的权重多了，分支 B 必然少。也就是说 SK 学到的语义是“这个通道更适合用 5x5 看”或者“这个通道更适合用 3x3 看”，是一种二选一或多选一的分配，而不是全局的强弱判断。你如果拿 SE 的直觉去调 SK，比如期望它能把某些通道整体压掉，会发现它做不到，因为 softmax 的和是固定的。

我把这个模块理解成“带参数的感受野路由”。每个输出通道的最终特征，是 M 个不同尺度视角的加权混合，混合比例由全局上下文动态决定。这个设计在语义分割、细粒度分类这类“同一张图里既有大目标又有小目标”的任务上收益最明显，因为不同空间位置的通道组合偏好确实不一样。

1.2 和 SE、CBAM 摆在一起比，代价和收益都对不上

把几个主流注意力模块放一张表里看，很容易看清 SK 的位置。下面的对比是按常见 C=256、瓶颈通道、单次插入来估的量级，不是绝对基准：

关键差别在最后两列。SK 的参数量其实控制得不错，因为它把每条分支都做成了分组卷积（groups=G），C=256、G=32 时每条 5x5 分支只有 256×8×25 个权重，比一条普通全通道 3x3 便宜得多。但它的 FLOPs 是另一回事：M 条分支都要在大特征图上跑一遍卷积，成本跟特征图面积成正比。这就引出一个非常实用的判断——SK 千万别加在浅层。以 224 输入为例，stage1 的特征图是 56×56，面积是 stage4 的 64 倍，同样一个 SK 模块放在 stage1 的开销可能是 stage4 的几十倍，而浅层特征本身还没形成稳定的语义通道，选择权重的意义也不大。

还有一个工程上的硬伤必须提前说清楚：SK 的权重依赖输入，属于动态卷积，推理期没法像 RepVGG 或 DBB 那样把多分支折叠成单个卷积核。想靠“训练时多分支、部署时合并”来白嫖性能的路子，在 SK 上走不通。如果你的场景对推理延迟卡得极死，这一点要在选型阶段就想明白。

1.3 什么任务值得上 SK，什么任务别碰

从我这边的实践看，SK 收益比较稳的场景有三类。第一类是同一类别内尺度差异大的，比如工业缺陷检测里划痕和脏污尺寸能差十倍，或者遥感图像里既有大片地块又有小目标建筑。第二类是纹理与形状线索并存的分类任务，比如材质分类，粗纹理需要大核、边缘细节需要小核，SK 能让网络按样本自适应。第三类是作为骨干网的即插即用升级，你手上已经有一个能跑的 ResNet 或 ResNeXt，想在不改整体结构的前提下试一把涨点，替换 3x3 是最省事的做法。

不适合的场景也很明确。小数据集、小分辨率（比如 32×32 的输入）上，7x7 的核 padding 都要 3，实际有效感受野已经覆盖半张图，多尺度分支之间的差异被抹平了，SK 退化成两个几乎一样的卷积分支在做平均，涨点很难看到。极度轻量的骨干网（通道数 32、64 这个量级）上，G=32 会让每组只剩 1 到 2 个通道，分组卷积直接退化，这时候必须把 G 调小，否则不仅没收益，精度还会掉。最后一类是对吞吐要求极高的在线服务，SK 带来的额外分支会让显存占用和延迟明显上升，除非你的模型本来就很闲。

2. 结构拆解：Split、Fuse、Select 三步怎么走

2.1 Split：多分支大核卷积与分组卷积的配合

Split 阶段的动作很简单：把输入 x 复制成 M 份，分别送进 M 个卷积核尺寸不同的分支。第 i 条分支的核尺寸通常取 3+2i，M=2 时就是 3x3 和 5x5，M=3 时是 3x3、5x5、7x7。每个分支内部是 Conv2d + BatchNorm2d + ReLU 的标准三件套。

这里有个容易被忽略的设计：每条分支都用 groups=G 的分组卷积。为什么要分组？两个原因。一是参数量和计算量，如果 M 条分支都是全通道卷积，5x5 和 7x7 的开销会直接把预算打穿；二是分组卷积本身就带来了通道维度的稀疏连接，相当于在每个尺度内部再做了一次子空间划分，论文里把它类比成 ResNeXt 的 cardinality 思想。分组数和分支数是两个独立的超参，不要混。

padding 的取值必须保证所有分支输出尺寸一致，公式是 padding = (kernel_size − 1) // 2，配合 stride 使用。3x3 取 1、5x5 取 2、7x7 取 3，这样在 stride=1 时尺寸不变，stride=2 时各分支的降采样结果也一致。我特意验算过奇数输入的情况，比如 H=15、stride=2：3x3 分支输出 floor((15+2−3)/2)+1 = 8，5x5 分支 floor((15+4−5)/2)+1 = 8，7x7 分支 floor((15+6−7)/2)+1 = 8，三者对齐。这个对齐是后面能直接相加和相乘的前提，一旦尺寸错一个像素，后面 cat 就会报错。

2.2 Fuse：从全局池化到 d 维瓶颈的计算链

M 条分支跑完之后，先做一个逐元素求和，得到融合特征 U，形状还是 [B, C, H, W]。注意这里是求和而不是 concat，求和的意义是“先把多尺度的信息混在一起，作为一个整体去感知全局上下文”，后面的门控再决定每个通道该偏向哪个尺度。如果这里用 concat，通道数变成 M·C，后面的 FC 参数会翻 M 倍，而且失去了“同一通道跨尺度比较”的语义。

接着对 U 做全局平均池化，得到 [B, C] 的通道描述符 s。然后是一条瓶颈结构：先用一个 Linear 把 C 压到 d 维，再过 BN 和 ReLU（部分实现里 BN 在 ReLU 之后，顺序略有差异，实测影响不大但建议按 BN→ReLU 走），得到 z，形状 [B, d]。

d 的取值是第一个需要算的参数，公式是d = max(C / r, L)，r 是压缩比，L 是最小维度下限，论文默认 r=16、L=32。为什么要设 L？因为当 C 很小的时候，C/r 会小到离谱。比如 C=64、r=16 算出 d=4，4 维的瓶颈要承载 64 个通道的选择信息，信息瓶颈太窄，训练会明显不稳。加个下限 32 相当于给瓶颈兜底。我在 C=128 的层上实测过 d=8 和 d=32 的差别，后者收敛曲线明显更平滑，验证集也略好，所以除非你极度在意那点参数，建议保留 L=32。

2.3 Select：跨分支 softmax 与特征重加权

Select 是整套机制的核心。对 z 做 M 次独立的升维 Linear，每次输出 C 维，得到 M 个 [B, C] 的向量，堆成 [B, M, C]。然后沿着M 这一维做 softmax，得到注意力矩阵 a，形状 [B, M, C]，满足对任意 (b, c)，Σ_i a[b, i, c] = 1。

这里就是全篇最容易写错的一行。nn.Softmax(dim=1)里的 1 指的是 M 维，不是通道维。如果你顺手写成 dim=2 或者 dim=-1，softmax 就跑到通道上去了，语义变成“每个分支内部通道之间竞争”，跟设计意图完全相反，而且代码不会报错，训练也能跑，只是精度上不去——这种静默错误最难查。我建议在 forward 里把 attention_vectors 的 shape 打印一次确认，[B, M, C] 是对的。

最后把 a 扩两维成 [B, M, C, 1, 1]，跟 Split 阶段堆好的 [B, M, C, H, W] 逐元素相乘，再沿 M 维求和，得到 [B, C, H, W] 的输出。整个模块输入输出形状完全一致，这才使它可以直接替换任何一个卷积层。

2.4 参数量和 FLOPs 到底花在哪

把公式落到具体数字上会更有感觉。取 C=512、M=2、G=32、r=16、L=32，则 d=32：

对比一条普通全通道 3x3 卷积的 2,359,296 个参数，SK 只有它的 14% 左右。但 FLOPs 要看特征图面积：在 14×14 的 stage4 上，两条分支的卷积 FLOPs 约 1.09×10⁸，而普通 3x3 约 9.25×10⁸，还是便宜。换个场景，C=128、在 56×56 上：SK 参数约 24,600，FLOPs 约 3.1×10⁸；普通 3x3 参数 147,456，FLOPs 约 9.25×10⁸。参数量省了八成，但 FLOPs 只省了六成多，绝对值的差距远没有参数量看起来那么大——这就是为什么我说浅层加 SK 很贵，参数看着不多，算力是真的花出去了。

3. PyTorch 逐行实现与关键注释

3.1 完整的 SKConv 模块

下面的实现按通用实践整理，去掉了一些针对特定骨干网的适配，保留最核心的逻辑，可以直接拿去做替换实验。

import torch import torch.nn as nn class SKConv(nn.Module): def __init__(self, channels, M=2, G=16, r=16, stride=1, L=32): super().__init__() # 保证分组卷积能整除，G 不能超过通道数 G = min(G, channels) while channels % G != 0: G //= 2 assert channels % G == 0, "channels 必须能被 G 整除" self.channels = channels self.M = M self.stride = stride # 瓶颈维度，带下限 L，避免小通道时信息瓶颈过窄 self.d = max(channels // r, L) # Split：M 条不同核尺寸的分组卷积分支 self.branches = nn.ModuleList() for i in range(M): k = 3 + 2 * i self.branches.append( nn.Sequential( nn.Conv2d(channels, channels, kernel_size=k, stride=stride, padding=(k - 1) // 2, groups=G, bias=False), nn.BatchNorm2d(channels), nn.ReLU(inplace=False), # 不用 inplace，避免和后续张量共享内存 ) ) # Fuse：全局描述 -> 瓶颈 self.fc_reduce = nn.Linear(channels, self.d) self.bn_reduce = nn.BatchNorm1d(self.d) self.relu_reduce = nn.ReLU(inplace=True) # Select：M 个独立升维 self.fc_expand = nn.ModuleList( [nn.Linear(self.d, channels) for _ in range(M)] ) # 关键：dim=1，在分支维上归一化 self.softmax = nn.Softmax(dim=1) def forward(self, x): B, C, H, W = x.shape # ---------- Split ---------- feas = [] for branch in self.branches: fea = branch(x) # [B, C, H, W] feas.append(fea.unsqueeze(1)) # [B, 1, C, H, W] feas = torch.cat(feas, dim=1) # [B, M, C, H, W] # ---------- Fuse ---------- fea_u = feas.sum(dim=1) # [B, C, H, W] fea_s = fea_u.mean(dim=(2, 3)) # [B, C] fea_z = self.fc_reduce(fea_s) # [B, d] fea_z = self.relu_reduce(self.bn_reduce(fea_z)) # [B, d] # ---------- Select ---------- attn = [] for fc in self.fc_expand: attn.append(fc(fea_z).unsqueeze(1)) # [B, 1, C] attn = torch.cat(attn, dim=1) # [B, M, C] attn = self.softmax(attn) # 在 M 维归一化 attn = attn.unsqueeze(-1).unsqueeze(-1) # [B, M, C, 1, 1] out = (feas * attn).sum(dim=1) # [B, C, H, W] return out

有几处细节值得单独说。G = min(G, channels)加循环除二，是为了适配轻量骨干网里通道数很小的层，比如某个 stage 的通道是 48，你传 G=32 会直接崩，这段代码会自动退到 16、再不行退到 8。bias=False加 BN 是标准做法，因为 BN 的 beta 参数已经承担了偏置的角色，再留 conv bias 是冗余的。nn.BatchNorm1d(self.d)处理的是 [B, d] 的二维张量，这没问题，但要注意在 batch size 很小（比如 1 或 2）时 BN1d 的统计量极不稳定，训练会抖，这时候可以考虑换成 LayerNorm 或者干脆去掉这一层 BN，我后面会讲实测差别。

3.2 用一组具体数字把 forward 走一遍

光看代码容易糊，拿一个真实尺寸走一遍就清楚了。假设输入 x 是 [4, 256, 28, 28]，配置 channels=256、M=2、G=16、r=16、L=32。

第一步，d = max(256/16, 32) = max(16, 32) = 32。注意这里 C/r 算出来是 16，比 L 小，所以最终 d 被抬到了 32，这个下限生效了。

第二步，两条分支分别跑 3x3 和 5x5，都是 groups=16，输出依然是 [4, 256, 28, 28]。unsqueeze 后堆成 [4, 2, 256, 28, 28]。

第三步，沿 M 求和得到 fea_u [4, 256, 28, 28]，全局池化得 fea_s [4, 256]，过 fc_reduce 得 [4, 32]。

第四步，两个 fc_expand 各输出 [4, 256]，堆成 [4, 2, 256]，softmax 后每一对 (b, c) 的两个值加起来正好是 1。你可以加一行print(attn.sum(dim=1).min(), attn.sum(dim=1).max())验证，两个值都应该贴着 1.0。

第五步，两个 [4, 2, 256] 扩成 [4, 2, 256, 1, 1]，与 [4, 2, 256, 28, 28] 相乘后沿 dim=1 求和，输出 [4, 256, 28, 28]，形状与输入一致。

这套维度追踪我建议你在第一次集成时真的打印一遍，比对着公式空想快得多。特别是 M=3 的时候，中间那个 cat 的维度很容易写错位置。

3.3 把 SKConv 塞进 ResNet 的瓶颈块

最省事的集成方式是替换瓶颈结构里的 3x3 卷积。下面是一个简化版 Bottleneck，只保留关键部分：

class SKBottleneck(nn.Module): expansion = 4 def __init__(self, inplanes, planes, stride=1, downsample=None, M=2, G=16, r=16): super().__init__() width = planes # 瓶颈中间通道 self.conv1 = nn.Conv2d(inplanes, width, 1, bias=False) self.bn1 = nn.BatchNorm2d(width) # 原来的 3x3 换成 SK self.sk = SKConv(width, M=M, G=G, r=r, stride=stride) self.conv3 = nn.Conv2d(width, planes * self.expansion, 1, bias=False) self.bn3 = nn.BatchNorm2d(planes * self.expansion) self.relu = nn.ReLU(inplace=True) self.downsample = downsample self.stride = stride def forward(self, x): identity = x out = self.relu(self.bn1(self.conv1(x))) out = self.sk(out) out = self.bn3(self.conv3(out)) if self.downsample is not None: identity = self.downsample(x) return self.relu(out + identity)

这里有个必须提醒的点：SK 的 stride 和残差分支的 stride 要对齐。当 stride=2 时，SKConv 内部两条分支都做 stride=2 降采样，输出的空间尺寸减半，downsample 里的 1x1 卷积也必须用 stride=2，否则相加时尺寸对不上，报维度错误。这个问题在改造现成骨干网时非常常见，因为原来 3x3 卷积的 stride 是在 conv2 上设的，你替换之后要检查整条链路的 stride 传递。

另外，宽度 width 通常是 planes，也就是瓶颈的中间通道。ResNet-50 里 stage3 的 width 是 128，这个尺寸下 G=16 每组 8 通道，比较合适；如果 width 只有 64，G=16 每组 4 通道，勉强能跑，但建议降到 G=8。

3.4 代码里三个静默错误的坑

第一个是unsqueeze_的原地操作。官方实现里用的是fea = conv(x).unsqueeze_(dim=1)，因为 conv 的输出是个临时张量，原地改它安全。但如果你写成out = conv(x); fea = out.unsqueeze_(1)，后面又用到 out，就会发现 out 的维度莫名其妙变了。我习惯一律用非原地的unsqueeze，省得排查。

第二个是 BN 的输入维度。nn.BatchNorm1d接受 [N, C] 或 [N, C, L]，如果你把 [B, M, C] 直接喂给 BN1d 会报错或者行为异常，必须在升维之前、形状还是 [B, d] 的时候做。

第三个是 softmax 之后不要接 dropout 或者再乘一个可学习标量。有人喜欢在注意力上加温度系数，SK 这里加温度会破坏“权重和为 1”的语义，等于让总能量随样本变化，实测反而掉点。要加温度，只在推理导出时用 logits 代替概率，那是另一回事。

4. 训练与调参实操：跑起来才知道的事

4.1 初始化、学习率与 BN 的配合

SK 模块的初始状态其实挺温和的。因为 softmax 在 M=2 时初始输出接近 0.5/0.5，等于两条分支在平均，网络起步阶段相当于一个更大的混合卷积核，不会像某些注意力模块那样一上来就把特征打死。这也是它在小数据集上不容易崩的原因之一。

但fc_reduce和fc_expand的初始化要注意。如果按默认的 Kaiming 均匀分布初始化，fc_expand的输出方差偏大，softmax 会变得很尖锐，接近 one-hot，等于起步就锁死在某一个分支上，另一条分支拿不到梯度，长期处于“死”的状态。我的做法是把fc_expand的权重初始化为更小的值，比如用nn.init.normal_(w, std=0.001)，让初始 logits 接近 0，softmax 接近均匀。这个改动不大，但收敛曲线会明显稳一些。

学习率策略上，加了 SK 的模型我不建议用比原模型更高的初始学习率。多分支结构本身让梯度路径变多，前期梯度范数会偏大，用原模型的 lr 或者略低一点（比如乘 0.8）更稳。warmup 可以保留，前 3 到 5 个 epoch 线性升温，能显著减少前期 loss 尖刺。

还有一点是关于 BN1d 的。batch size 小于 8 的时候，BN1d 的 running stats 会非常抖，因为它在 [B, d] 这么小的张量上统计。我遇到过验证集指标反复横跳的情况，把 BN1d 换成nn.LayerNorm(self.d)之后就平滑了。这个替换在检测、分割这类小 batch 的任务里几乎是必做的。

4.2 M、G、r、L 四个参数怎么定

这四个参数不是独立调的，按优先级从高到低是 M、G、r 和 L。

M 决定分支数。M=2（3x3 + 5x5）是性价比最高的配置，多尺度差异已经能覆盖大部分场景，参数和算力都在可接受范围。M=3 加上 7x7 分支后，在小目标密集的任务上确实有额外收益，但 7x7 的分组卷积在 GPU 上效率不高，实际延迟增长幅度往往超过 FLOPs 增长的比例，因为大核的访存模式不友好。我一般先用 M=2 跑基线，确认有收益再试 M=3，别一上来就 M=3。

G 决定分组数。经验值是让每组至少 8 个通道。C=256 时 G=32 刚好每组 8 个；C=128 时 G 应该降到 16；C=64 时 G=8 比较合适。G 太大会让每个分支退化成近乎逐通道的卷积，跨通道信息融合能力丧失；G 太小（比如 G=1）就退化成全通道卷积，参数量飙升。这个参数对精度的影响比很多人想象的大，我做过一组对照，同一网络 G=1 和 G=16 的验证精度能差出接近一个点，而参数量差了十几倍。

r 和 L 共同决定瓶颈宽度 d。r 默认 16，L 默认 32。当 C ≥ 512 时，C/r ≥ 32，L 不生效，d 由 r 决定；当 C < 512 时，L 生效，d 恒等于 32，r 实际上没用了。这意味着在中小通道的骨干网里，调 r 是无效的，要改就直接改 L。如果你的模型通道普遍在 128 到 256，想省参数可以把 L 降到 16，但我不建议低于 16。

4.3 实测对比与消融的观察

下面这组数字是常见的公开报告量级，不同任务差异很大，只能当方向参考，别当基准。任务是一个几百类的细粒度分类，输入 224，骨干是 ResNet-50 变体：

几个观察值得说。第一，全 stage 加 SK 反而比只在 stage3+4 加更差或持平，这跟前面算的 FLOPs 一致，浅层的选择权重没学到有用的东西，还引入了额外噪声，同时把训练时间拉长了一大截。第二，M=3 的收益比 M=2 高一点，但延迟涨得更多，性价比在多数场景下不如 M=2。第三，SK 和 SE 的收益量级接近，但 SK 的延迟代价大约是 SE 的 4 倍——如果你的任务对多尺度不敏感，SE 是更理性的选择。第四，SK 和 SE 叠加（先 SK 再 SE）我试过，没有叠加收益，反而略掉，两者的信息通道有重叠。

消融里还有一个容易被忽略的变量：把 SK 的分组卷积换成普通卷积（G=1），参数量暴涨但精度只多了 0.1 左右，完全不值。分组卷积这个设计在 SK 里不是可有可无的优化，是它能在可接受成本内成立的前提。

5. 常见问题与排查速查表

5.1 报错和维度类问题

这类问题基本都是形状没对齐，我把踩过的整理成表：

关于最后一条多说一句。SK 的显存开销比参数量体现出来的大得多，因为反向传播要保存 M 条分支的卷积输出，在 56×56 这种大特征图上 M=2 就是双份激活。我遇到过一次 OOM，把 SK 从 stage2 撤到 stage4 就解决了，代价是精度几乎没变。

5.2 精度和速度类问题

精度上最常见的抱怨是“加了 SK 反而不涨点”。按可能性排序，我建议这样排查。先确认插入位置，如果是浅层，先挪到 stage3+4 再看。再确认 G，如果通道数小 G 还大，每组只剩 1 到 2 个通道，这时候 SK 基本失效，把 G 调到每组 8 通道以上。然后看初始化，fc_expand的输出太大导致 softmax 早期就饱和，改小初始化。最后看数据集规模，如果训练集只有几千张，SK 的额外参数就是负担，老老实实用 SE 或者干脆不加。

速度上的问题主要是两个。一是 7x7 分支的访存效率，在 GPU 上 7x7 的 grouped conv 往往跑不满算力，实测延迟增长比例高于 FLOPs 增长比例。二是多分支带来的 kernel launch 开销，在 batch 很小（比如 1）的时候尤其明显，这时候瓶颈不在算力而在调度。缓解办法一个是 M 控制到 2，另一个是把大核拆成 1x3 和 3x1 的级联，形状上凑出 5x5 或 7x7 的感受野但访存更友好，代价是表达能力和原版不完全等价，我试过在分类任务上掉 0.1 左右，可以接受。

5.3 交流时容易被追问的几个点

“SK 的注意力为什么用 softmax 而不是 sigmoid？”——因为设计目标是分支间的竞争性分配，softmax 强制权重归一，保证输出特征的量级稳定；如果用 sigmoid，M 条分支可能同时被放大，输出幅度会随样本剧烈波动，训练不稳。

“它算通道注意力还是空间注意力？”——都不是严格的。它的权重维度是 [分支, 通道]，跳过了空间维，所以不是空间注意力；但它又不是通道重标定，因为每个通道的权重是分给不同感受野的。叫“分支注意力”或者“感受野注意力”更准确。

“能不能和空间注意力组合？”——可以，但要注意顺序和成本。常见做法是 SK 之后接一个轻量的空间注意力，用 7x7 或 3x3 卷积生成 [B, 1, H, W] 的图。我试过组合，收益不稳定，在检测任务上有一点点，在分类上基本没有，而且延迟又涨了一截。不推荐作为默认配置。

“为什么不做成可微的核尺寸搜索？”——这就变成 NAS 的范畴了，SK 是它的离散简化版，用固定的几个候选核加上软选择，训练成本低得多，效果也够用，工程上更实际。

6. 我在集成 SK 时会先做的三件事

集成一个新模块，最怕的是改完跑起来 loss 正常但指标不动，然后花两天排查发现是某个维度写错了。我现在的流程固定成三步，能省不少时间。

第一步是单元测试形状和权重和。随便造一个torch.randn(2, 64, 16, 16)的输入，跑一遍 SKConv，断言输出形状等于输入形状，再断言 softmax 后的权重沿 M 维求和全为 1。这两个断言覆盖了绝大部分低级错误。

第二步是对比随机初始化下的输出统计量。把 SKConv 和一个普通 3x3 卷积分别作用在同一份输入上，比较输出的均值和方差。SK 在初始状态下是两条分支的平均，方差应该和单条分支接近，如果差出好几倍，说明初始化或者 BN 有问题，这时候往下训练大概率会崩。

第三步是先用小分辨率快速验证收敛。拿一个 64×64 输入的小任务跑 20 个 epoch，看 loss 能不能正常下降。这一步很快，能在正式训练之前就暴露 BN1d 抖动、softmax 饱和这类问题。等这一关过了再去跑完整训练，返工成本低很多。

最后提一个我个人的偏好：如果骨干网是现成的、不方便改结构，我会把 SK 做成一个独立的后置模块，接在某个 stage 的输出后面，而不是替换卷积。这样做的好处是完全不动原网络，出问题好回退；缺点是它不在残差路径内部，梯度回传的路径变长，收益通常会比替换卷积低三到五成。所以优先级上，能替换卷积就替换，实在不能动再考虑后置。

这个模块本身不复杂，真正费时间的是把它放到对的位置、配对参数，以及在速度和精度之间找到你项目能接受的那个点。先把 M=2、G 按每组 8 通道、只在 stage3+4 插入这一套基线跑通，后面所有尝试都是在它上面做加减法。