CNN与Transformer结合实战：如何解决视觉序列建模中的长程依赖问题

1次阅读

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

在视频理解、医学图像分割等任务中，模型需要同时处理局部细节和全局关系。传统 CNN 通过堆叠卷积层扩大感受野，但计算量呈平方增长（如空洞卷积）。而 Vision Transformer 虽然能直接建模全局关系，但需要大量数据弥补其缺乏的平移不变性，且对高分辨率输入的计算复杂度为 O(n²)。

纯 CNN 优势：
内置平移等方差性，小数据友好
层次化特征天然适合分割等密集预测任务
计算效率高（FLOPs 可控）
纯 Transformer 劣势：
需要预训练或大规模数据
处理 512×512 图像时，注意力矩阵消耗 16GB 显存
忽略局部纹理连续性假设
混合架构折中方案：
CNN 前端（如 ResNet-50）提取多尺度特征
Transformer 在后阶段建模远程关系
典型计算分配比 4:1（CNN 占 80% FLOPs）

import torch
from torchvision.models import resnet50

class HybridBackbone(nn.Module):
    def __init__(self):
        super().__init__()
        # 截取 ResNet 到 stage4
        resnet = resnet50(pretrained=True)
        self.stem = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu)
        self.stages = nn.ModuleList([
            resnet.layer1,  # stride4
            resnet.layer2,  # stride8
            resnet.layer3   # stride16（输出特征图）])

    def forward(self, x):
        # 输入: [B,3,H,W]
        x = self.stem(x)
        for stage in self.stages:
            x = stage(x)
        return x  # [B,C,H/16,W/16]

class PatchEmbed(nn.Module):
    def __init__(self, in_c=1024, embed_dim=768):
        super().__init__()
        # 将特征图拆分为 16x16 的 patch
        self.proj = nn.Conv2d(in_c, embed_dim, kernel_size=1)

    def forward(self, x):
        # 输入: [B,C,H,W]
        x = self.proj(x)
        B,C,H,W = x.shape
        x = x.flatten(2).transpose(1,2)  # [B,H*W,C]
        return x

相对位置编码 优于绝对编码（尤其处理可变尺寸输入时）

实现示例：

class RelPosEmbed(nn.Module):
    def __init__(self, max_len=256, dim=768):
        super().__init__()
        self.rel_h = nn.Parameter(torch.randn(dim//2, max_len))
        self.rel_w = nn.Parameter(torch.randn(dim//2, max_len))

    def forward(self, x):
        # x: [B,N,C]
        B,N,C = x.shape
        h = w = int(N**0.5)

        # 行列相对位置
        rel_h = self.rel_h[:, :h].unsqueeze(1).expand(-1,w,-1)
        rel_w = self.rel_w[:, :w].unsqueeze(0).expand(h,-1,-1)
        pos = torch.cat([rel_h, rel_w], dim=-1).flatten(0,1)  # [N,C]

        return x + pos.unsqueeze(0)

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)

with autocast():
    loss = model(inputs)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()