CBAM Transformer 入门指南：从模型结构到实战应用

1次阅读

共计 3133 个字符，预计需要花费 8 分钟才能阅读完成。

Transformer 模型在 NLP 领域大获成功后，很快被引入到计算机视觉领域。但直接将 Transformer 用于图像数据时，我们会发现几个明显的问题：

计算复杂度随图像尺寸呈平方级增长
缺乏对局部特征的关注能力
通道间关系没有得到充分建模

这就像用望远镜看报纸 – 虽然能看得很远，但却忽略了页面上的细节纹理。CBAM(Convolutional Block Attention Module)就是为了解决这些问题而提出的。

指标	Vanilla Transformer	Swin Transformer	CBAM Transformer
计算复杂度	O(n²)	O(nlogn)	O(n)
参数量	大	中等	小
准确率(ImageNet)	81.2%	83.3%	82.1%
显存占用	高	中	低

从表格可以看出，CBAM 在保持较好准确率的同时，显著降低了计算复杂度。

下面我们用 PyTorch 实现 CBAM 的核心模块：

import torch
import torch.nn as nn
import torch.nn.functional as F

class ChannelAttention(nn.Module):
    """通道注意力模块"""
    def __init__(self, in_channels, reduction_ratio=16):
        super(ChannelAttention, self).__init__()
        # 使用全局平均池和最大池来压缩空间维度
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)

        # 共享的全连接层
        self.fc = nn.Sequential(nn.Linear(in_channels, in_channels // reduction_ratio),
            nn.ReLU(),
            nn.Linear(in_channels // reduction_ratio, in_channels)
        )

    def forward(self, x):
        b, c, _, _ = x.size()
        # 计算平均池化特征
        avg_out = self.fc(self.avg_pool(x).view(b, c))
        # 计算最大池化特征
        max_out = self.fc(self.max_pool(x).view(b, c))
        # 合并两种特征
        out = avg_out + max_out
        # 生成通道注意力权重
        channel_att = torch.sigmoid(out).view(b, c, 1, 1)
        return x * channel_att

class SpatialAttention(nn.Module):
    """空间注意力模块"""
    def __init__(self, kernel_size=7):
        super(SpatialAttention, self).__init__()
        # 使用卷积层计算空间注意力
        self.conv = nn.Conv2d(2, 1, kernel_size, padding=kernel_size//2)

    def forward(self, x):
        # 沿通道维度计算平均值和最大值
        avg_out = torch.mean(x, dim=1, keepdim=True)
        max_out, _ = torch.max(x, dim=1, keepdim=True)
        # 拼接两种特征
        concat = torch.cat([avg_out, max_out], dim=1)
        # 生成空间注意力权重
        spatial_att = torch.sigmoid(self.conv(concat))
        return x * spatial_att

class CBAM(nn.Module):
    """完整的 CBAM 模块"""
    def __init__(self, in_channels, reduction_ratio=16, kernel_size=7):
        super(CBAM, self).__init__()
        self.channel_att = ChannelAttention(in_channels, reduction_ratio)
        self.spatial_att = SpatialAttention(kernel_size)

    def forward(self, x):
        # 先应用通道注意力，再应用空间注意力
        x = self.channel_att(x)
        x = self.spatial_att(x)
        return x

下面展示如何将 CBAM 集成到 ResNet 中：

class ResNetWithCBAM(nn.Module):
    def __init__(self, base_model):
        super(ResNetWithCBAM, self).__init__()
        # 使用预训练的 ResNet 作为基础模型
        self.base = base_model

        # 在每个残差块后添加 CBAM 模块
        self.cbam1 = CBAM(64)
        self.cbam2 = CBAM(128)
        self.cbam3 = CBAM(256)
        self.cbam4 = CBAM(512)

    def forward(self, x):
        x = self.base.conv1(x)
        x = self.base.bn1(x)
        x = self.base.relu(x)
        x = self.base.maxpool(x)

        x = self.base.layer1(x)
        x = self.cbam1(x)

        x = self.base.layer2(x)
        x = self.cbam2(x)

        x = self.base.layer3(x)
        x = self.cbam3(x)

        x = self.base.layer4(x)
        x = self.cbam4(x)

        x = self.base.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.base.fc(x)

        return x