即插即用系列 | CVPR 2026 | SCFM：双路并行调制！空间-通道协同增强，高频细节精准补偿，性能轻量兼得！ | 代码分享

# 空间-通道特征调制器（Spatial-Channel Feature Modulator, SCFM） # 核心设计：基于“归一化+双注意力并行调制”的架构， # 通过LayerNorm稳定特征分布，并行引入通道注意力（Channel Attention）与空间注意力（Spatial Attention）， # 分别强化关键通道特征与空间关键区域，再经独立卷积投影融合，实现特征的精准调制与增强， # 提升特征的辨识度与鲁棒性，且轻量化设计适配各类视觉模型

import torch import torch.nn as nn import numbers from einops import rearrange

def to_3d(x): """将4D特征(B,C,H,W)转换为3D序列格式(B, H*W, C)""" return rearrange(x, 'b c h w -> b (h w) c')

def to_4d(x, h, w): """将3D序列格式(B, H*W, C)转换回4D特征(B,C,H,W)""" return rearrange(x, 'b (h w) c -> b c h w', h=h, w=w)

class WithBias_LayerNorm(nn.Module): """带偏置的LayerNorm实现""" def __init__(self, normalized_shape): super(WithBias_LayerNorm, self).__init__() if isinstance(normalized_shape, numbers.Integral): normalized_shape = (normalized_shape,) normalized_shape = torch.Size(normalized_shape)

assert len(normalized_shape) == 1

self.weight = nn.Parameter(torch.ones(normalized_shape)) self.bias = nn.Parameter(torch.zeros(normalized_shape)) self.normalized_shape = normalized_shape

def forward(self, x): return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + 1e-6) * self.weight + self.bias

class LayerNorm(nn.Module): """2D特征的LayerNorm包装器""" def __init__(self, dim): super(LayerNorm, self).__init__() self.body = WithBias_LayerNorm(dim)

def forward(self, x): h, w = x.shape[-2:] return to_4d(self.body(to_3d(x)), h, w)

class ChannelAttention(nn.Module): """通道注意力模块，基于平均池化和最大池化的双池化融合""" def __init__(self, in_planes, ratio=16): super(ChannelAttention, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.max_pool = nn.AdaptiveMaxPool2d(1)

self.fc = nn.Sequential( nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False), nn.ReLU(), nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False) ) self.sigmoid = nn.Sigmoid()

def forward(self, x): avg_out = self.fc(self.avg_pool(x)) max_out = self.fc(self.max_pool(x)) out = avg_out + max_out return self.sigmoid(out)

class SpatialAttention(nn.Module): """空间注意力模块，基于通道维度的平均池化和最大池化拼接""" def __init__(self, kernel_size=7): super(SpatialAttention, self).__init__() self.conv1 = 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) max_out, _ = torch.max(x, dim=1, keepdim=True) x_cat = torch.cat([avg_out, max_out], dim=1) x_out = self.conv1(x_cat) return self.sigmoid(x_out)

class SCFM(nn.Module): """ 空间-通道特征调制器（Spatial-Channel Feature Modulator, SCFM）

功能：并行空间注意力与通道注意力，双路径调制特征，提升特征表达精准度

核心设计（严格遵循原始论文公式(14)）： - 归一化先行：LayerNorm稳定特征分布，为注意力调制打基础 - 双注意力并行：通道注意力强化关键通道，空间注意力强化关键区域，互补增强 - 独立投影融合：双注意力调制后的特征经独立1×1卷积投影，避免信息干扰，融合更高效 - 轻量化架构：无复杂组件，计算成本低，即插即用

原始论文公式： F_d = Conv(ReLU(Conv(F_in))) W_c = δ(Max(F_d) + Avg(F_d)) W_s = δ(Conv([Max(F_in); Mean(F_in)])) F_out = Conv(W_s·F_in) + Conv(W_c·F_in)

Args: feature_dim: 输入/输出特征通道数（需保持一致） reduction_ratio: 通道注意力的降维比率，默认16 kernel_size: 空间注意力的卷积核大小，默认7 """ def __init__(self, feature_dim, reduction_ratio=16, kernel_size=7): super().__init__() # 归一化层（对应论文Norm） self.norm = LayerNorm(feature_dim)

# 双注意力模块（并行设计） self.chan_attn = ChannelAttention(feature_dim, ratio=reduction_ratio) self.spat_attn = SpatialAttention(kernel_size=kernel_size)

# 独立投影层（对应论文中的Conv） self.conv_chan = nn.Conv2d(feature_dim, feature_dim, 1, 1, 0) self.conv_spat = nn.Conv2d(feature_dim, feature_dim, 1, 1, 0)

def forward(self, x): """ Args: x: 输入特征图，形状为 (B, C, H, W) Returns: 调制后的特征图，形状与输入相同 """ # Step 1: LayerNorm稳定特征分布 x_norm = self.norm(x)

# Step 2: 并行双注意力调制 + 独立投影 # 通道注意力分支：W_c·F_in x_chan = self.conv_chan(self.chan_attn(x_norm) * x_norm) # 空间注意力分支：W_s·F_in x_spat = self.conv_spat(self.spat_attn(x_norm) * x_norm)

# Step 3: 融合输出 return x_chan + x_spat

# 轻量化版本（减少计算量） class SCFMLight(nn.Module): """ SCFM轻量化版本，适用于资源受限场景

主要改动： - 通道注意力降维比率提升至32 - 空间注意力卷积核缩小至5 - 移除独立投影层的冗余计算（与注意力权重复用） """ def __init__(self, feature_dim, reduction_ratio=32, kernel_size=5): super().__init__() self.norm = LayerNorm(feature_dim) self.chan_attn = ChannelAttention(feature_dim, ratio=reduction_ratio) self.spat_attn = SpatialAttention(kernel_size=kernel_size)

# 使用单一融合卷积，进一步降低参数量 self.fusion_conv = nn.Conv2d(feature_dim * 2, feature_dim, 1, 1, 0)

def forward(self, x): x_norm = self.norm(x) x_chan = self.chan_attn(x_norm) * x_norm x_spat = self.spat_attn(x_norm) * x_norm return self.fusion_conv(torch.cat([x_chan, x_spat], dim=1))

if __name__ == "__main__": device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

# 测试标准SCFM x = torch.randn(1, 64, 32, 32).to(device) model = SCFM(64).to(device) y = model(x)

print("【SCFM 测试结果】") print(f"输入特征维度：{x.shape}") print(f"输出特征维度：{y.shape}") print(f"模型参数量：{sum(p.numel() for p in model.parameters()):,}") print("=" * 60)

# 测试轻量化版本 model_light = SCFMLight(64).to(device) y_light = model_light(x) print(f"【SCFMLight 测试结果】") print(f"输出特征维度：{y_light.shape}") print(f"轻量化模型参数量：{sum(p.numel() for p in model_light.parameters()):,}") print("=" * 60)