Metaphor

现代CNN架构演进

29分钟阅读

概述

尽管 Vision Transformer 在视觉领域取得了巨大成功，卷积神经网络（CNN）并未被淘汰。相反，2024-2025 年见证了 CNN 架构的重大复兴，ConvNeXt 生态不断壮大，并与状态空间模型（SSM/Mamba）产生了有趣的融合。1

1. ConvNeXt 生态

1.1 ConvNeXt V2

ConvNeXt V2 在 V1 基础上引入了全局响应归一化（Global Response Normalization, GRN）。2

核心改进：

class GRN(nn.Module):
    """全局响应归一化"""
    def __init__(self, dim, eps=1e-6):
        super().__init__()
        self.gamma = nn.Parameter(torch.zeros(dim))
        self.beta = nn.Parameter(torch.zeros(dim))
        self.eps = eps
    
    def forward(self, x):
        # x: (B, H, W, C) 或 (B, C, H, W)
        # 沿着通道维度计算范数
        norm = torch.norm(x, p=2, dim=(0, 1, 2), keepdim=True)
        norm = norm + self.eps
        
        # 归一化 + 可学习的缩放和偏移
        out = self.gamma * (x / norm) + self.beta
        return out

GRN 的作用：

机制效果
响应归一化平衡通道间的激活强度
竞争机制促进通道专业化
替代 LayerNorm更适合卷积架构

1.2 EfficientConvNeXt

针对边缘设备优化的轻量级 ConvNeXt：

关键设计：

class EfficientConvNeXtBlock(nn.Module):
    def __init__(self, dim, drop_path=0., kernel_size=7):
        super().__init__()
        # 深度可分离卷积 + 大核
        self.dwconv = nn.Conv2d(
            dim, dim, 
            kernel_size=kernel_size, 
            padding=kernel_size//2, 
            groups=dim
        )
        
        # 跨阶段部分连接 (Cross-Stage Partial)
        self.norm = GRN(dim)
        self.pwconv1 = nn.Linear(dim, 4 * dim)
        self.act = nn.GELU()
        self.pwconv2 = nn.Linear(4 * dim, dim)
        self.drop_path = DropPath(drop_path)
    
    def forward(self, x):
        input = x
        x = self.dwconv(x)
        x = x.permute(0, 2, 3, 1)  # (B, H, W, C)
        x = self.norm(x)
        x = self.pwconv1(x)
        x = self.act(x)
        x = self.pwconv2(x)
        x = x.permute(0, 3, 1, 2)  # (B, C, H, W)
        return x + self.drop_path(input)

1.3 ConvNeXt-Small Data (CSD)

针对小数据集优化的 ConvNeXt：

策略说明
知识蒸馏从大模型蒸馏
自监督预训练MAE 风格
数据增强CutMix + MixUp + RandAugment

2. CNN-Mamba 混合架构

2.1 MambaVision

MambaVision 是 CVPR 2025 提出的混合架构，结合 CNN 的局部特征提取和 Mamba 的长距离建模能力。3

核心设计：

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  阶段 1-2: CNN 主干                                        │
│  ┌─────────┐    ┌─────────┐                                │
│  │ Conv3×3 │ → │ Conv3×3 │ → ...                          │
│  └─────────┘    └─────────┘                                │
│                                                             │
│  阶段 3-4: CNN-Mamba 混合                                   │
│  ┌─────────┐    ┌─────────┐    ┌─────────┐              │
│  │ Conv3×3 │ → │ Mamba   │ → │ Conv3×3 │ → ...          │
│  └─────────┘    └─────────┘    └─────────┘              │
│                                                             │
│  阶段 5: CNN 输出                                          │
│  ┌─────────┐    ┌─────────┐                                │
│  │ Conv3×3 │ → │分类头  │                                   │
│  └─────────┘    └─────────┘                                │
│                                                             │
└─────────────────────────────────────────────────────────────┘

MambaVision 块：

class MambaVisionLayer(nn.Module):
    def __init__(self, dim, state_dim=16):
        super().__init__()
        # 局部特征提取
        self.local_conv = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
        self.norm = nn.BatchNorm2d(dim)
        
        # Mamba 状态空间模块
        self.mamba = MambaBlock(
            d_model=dim,
            d_state=state_dim,
            expand=2,
        )
        
        # 门控融合
        self.gate = nn.Sigmoid()
    
    def forward(self, x):
        # 局部路径
        local = self.local_conv(x)
        local = self.norm(local)
        
        # 全局路径 (Mamba)
        # 将通道转换为序列
        B, C, H, W = x.shape
        x_seq = x.flatten(2).transpose(1, 2)  # (B, HW, C)
        global_out = self.mamba(x_seq)
        global_out = global_out.transpose(1, 2).reshape(B, C, H, W)
        
        # 门控融合
        gate = self.gate(global_out)
        out = local * gate + global_out * (1 - gate)
        
        return out

2.2 VCMamba

VCMamba（Vision state-space Convolution Mamba）提出多方向 Mamba 用于视觉：

class MultiDirectionalMamba(nn.Module):
    """四个方向的 Mamba"""
    def __init__(self, dim):
        super().__init__()
        # 四个方向的 Mamba 块
        self.directions = nn.ModuleList([
            MambaBlock(d_model=dim) for _ in range(4)
        ])
    
    def forward(self, x):
        B, C, H, W = x.shape
        
        # 四个方向的特征图
        # 方向 1: 左到右
        f1 = self.directions[0](x.flatten(2))
        
        # 方向 2: 上到下
        f2 = self.directions[1](x.flatten(2).transpose(1, 2)).transpose(1, 2)
        
        # 方向 3: 右到左
        f3 = self.directions[2](torch.flip(x, dims=[3]).flatten(2))
        f3 = torch.flip(f3.reshape(B, C, H, W), dims=[3]).flatten(2)
        
        # 方向 4: 下到上
        f4 = self.directions[3](torch.flip(x, dims=[2]).flatten(2).transpose(1, 2))
        f4 = torch.flip(f4.transpose(1, 2).reshape(B, C, H, W), dims=[2]).flatten(2)
        
        # 融合
        out = torch.stack([f1, f2, f3, f4], dim=-1).mean(dim=-1)
        return out.reshape(B, C, H, W)

2.3 CoSNet

CoSNet（Columnar Stage Network）提出完全无注意力、纯并行列积的架构：

核心思想：每层使用多组独立卷积，类似于”列”结构：

┌─────────────────────────────────────────────┐
│  输入                                       │
│   │                                          │
│   ├──────────────────────────────────────────│
│   │                                          │
│  ┌┴───┐  ┌┴───┐  ┌┴───┐  ┌┴───┐  ┌┴───┐   │
│  │Col1 │  │Col2 │  │Col3 │  │Col4 │  │Col5 │   │
│  └──┬──┘  └──┬──┘  └──┬──┘  └──┬──┘  └──┬──┘   │
│     │        │        │        │        │      │
│     └────────┴────────┴────────┴────────┘      │
│                    │                            │
│               ┌────┴────┐                       │
│               │  融合层  │                       │
│               └────┬────┘                       │
│                    │                            │
│               ┌────┴────┐                       │
│               │  输出   │                       │
│               └─────────┘                       │
└─────────────────────────────────────────────┘

3. UniConvNet

UniConvNet 关注于**有效感受野（Effective Receptive Field, ERF）**的扩展：

3.1 问题

传统 CNN 的感受野增长缓慢：

  • 每层 ERF 增长约 2 像素
  • 需要很多层才能覆盖大物体

3.2 解决方案

使用渐进式 ERF 扩展：

class ERFExpansion(nn.Module):
    def __init__(self, dim, stages=4):
        super().__init__()
        self.expansion_layers = nn.ModuleList([
            nn.Sequential(
                nn.Conv2d(dim, dim, 3, padding=2**i, dilation=2**i, groups=dim),
                nn.Conv2d(dim, dim, 1),
            )
            for i in range(stages)
        ])
        
        # 渐近高斯混合权重
        self.alphas = nn.Parameter(torch.ones(stages) / stages)
    
    def forward(self, x):
        outputs = []
        for i, layer in enumerate(self.expansion_layers):
            out = layer(x)
            # 高斯权重
            alpha = F.softmax(self.alphas, dim=0)[i]
            outputs.append(alpha * out)
        
        return sum(outputs)

3.3 渐近高斯属性

训练后的权重具有渐近高斯分布：

        初始                     训练后
        ┌───┐                   ┌─ ─ ─┐
       /│   │\      →         /│     │\
      / │   │ \              /  │     │  \
     │  │   │  │            │    │     │    │
     │  └───┘  │            │   ─┤     ├─   │
     │         │            │  ──┘     └──  │
     │         │            │      ≈ Gaussian

这使得 ERF 平滑地覆盖大范围区域。

4. TinyML 轻量级架构

4.1 MicroViT

为微型设备设计的极轻量 ViT：

模型参数量FLOPsImageNet Top-1
MicroViT-T1.2M55M68.5%
MicroViT-S2.8M130M73.2%
MicroViT-B5.1M250M76.8%

4.2 TinyNeXt

混合 ViT 架构，专门为 TinyML 优化：

class TinyNeXt(nn.Module):
    def __init__(self, depth=[2, 3, 4, 3], width=[32, 64, 128, 192]):
        super().__init__()
        
        # 阶段 1-2: 高效 CNN
        self.stem = nn.Sequential(
            nn.Conv2d(3, width[0], 3, stride=2, padding=1),
            nn.BatchNorm2d(width[0]),
            nn.ReLU6(inplace=True),
        )
        
        self.stages = nn.ModuleList()
        for i, (d, w) in enumerate(zip(depth, width)):
            stage = nn.Sequential(*[
                TinyConvBlock(w, expansion=4) for _ in range(d)
            ])
            self.stages.append(stage)
        
        # 阶段 3-4: 轻量注意力
        self.attention_stages = nn.ModuleList()
        for i, (d, w) in enumerate(zip(depth[2:], width[2:])):
            attn = nn.Sequential(*[
                LightweightAttention(w) for _ in range(d)
            ])
            self.attention_stages.append(attn)
        
        self.head = nn.Linear(width[-1], 1000)

5. 性能对比

5.1 ImageNet 分类

模型参数量FLOPsTop-1
ConvNeXt-B89M15.4G85.8%
ConvNeXt V2-B89M15.4G86.4%
MambaVision-S50M8.2G85.2%
VCMamba-T28M4.5G83.1%
CoSNet-S45M7.8G84.7%
UniConvNet-B86M14.8G85.5%

5.2 推理速度

在 A100 GPU 上：

模型吞吐量 (images/sec)
ConvNeXt-B850
MambaVision-S1200
CoSNet-S980
ViT-B320

观察：CNN 及其混合变体在效率上仍优于纯 Transformer。

6. 设计原则总结

6.1 ConvNeXt 设计原则

  1. 现代训练策略：AdamW、大 batch、AugReg
  2. 层次化设计：多尺度特征金字塔
  3. ResNeXt 化：分组卷积增加容量
  4. 反转瓶颈：大 → 小 → 大
  5. 大核卷积：7×7 或更大
  6. GELU 激活：替代 ReLU
  7. LayerNorm：替代 BatchNorm（某些场景）

6.2 混合架构原则

  1. CNN 主干：提取局部特征
  2. SSM/Mamba：建模长距离依赖
  3. 门控融合：平衡局部和全局
  4. 多方向扫描：充分覆盖空间

6.3 轻量级设计原则

  1. 深度可分离卷积：减少 FLOPs
  2. 跨阶段部分连接：减少参数
  3. 渐进式下采样：保持信息
  4. 动态精度缩放：适配硬件

7. 未来方向

7.1 动态架构

根据输入动态调整计算量：

class DynamicConvBlock(nn.Module):
    def forward(self, x):
        # 根据输入复杂度决定计算量
        complexity = self.estimate_complexity(x)
        
        if complexity < threshold:
            return self.light_forward(x)
        else:
            return self.full_forward(x)

7.2 硬件协同设计

针对特定硬件（GPU/NPU/TPU）优化的卷积实现：

  • 内存布局优化
  • 算子融合
  • 动态调度

7.3 统一框架

CNN + ViT + SSM 的统一架构可能成为未来主流：

  • 根据任务自动选择计算模式
  • 共享局部和全局表示
  • 端到端可微优化

8. iFormer: 移动端 CNN-Transformer 混合架构 (2025)

8.1 论文背景

Chuanyang Zheng 在 2025 年提出 iFormer（i 代表 integrated），专门为移动端推理设计的 CNN-Transformer 混合架构。论文题为 “iFormer: Integrating ConvNet and Transformer for Mobile Application”，arXiv:2501.15369。4

iFormer 的核心目标是：在 mobile 级别延迟约束下最大化 ImageNet 分类精度。它系统性地研究了 CNN 局部表达与 Transformer 全局建模的最优融合方式，得出了一个清晰的设计原则：早期阶段使用 CNN，后期阶段使用 Transformer（“early/late 阶段式”集成）。5

8.2 核心思想

iFormer 的设计哲学可以概括为”分工合作”：

阶段任务特征主导算子理由
早期（Stage 1-2）高分辨率、低语义、局部纹理深度可分离卷积 (DWConv)局部归纳偏置强、计算高效
后期（Stage 3-4）低分辨率、高语义、需长程依赖轻量自注意力全局建模、动态权重
过渡（Stage 3 前）语义/分辨率过渡Mobile-Friendly Attention (MFA)移动端友好的轻量注意力

关键洞见：直接在早期阶段使用 Transformer 算力代价过大；而在后期使用 CNN 又无法捕获足够的全局依赖。iFormer 通过两阶段分工取得 Pareto 最优。4

8.3 架构设计原则

原则 1：阶段式而非块式混合

许多混合架构（如 CoAtNet、MaxViT）在每个块内同时使用卷积和注意力；iFormer 则在整个阶段中只使用一种算子。这降低了实现复杂度和内存开销：

┌──────────────────────────────────────────────────────────┐
│ 输入图像                                                  │
│   │                                                       │
│   ▼                                                       │
│ ┌────────────┐                                           │
│ │ Stem       │  4×4 卷积 stride=4                        │
│ └────┬───────┘                                           │
│      ▼                                                    │
│ ┌────────────┐                                           │
│ │ Stage 1    │  MBConv-like 块 × N₁                      │
│ │ (CNN)      │  高分辨率（56×56）                        │
│ └────┬───────┘                                           │
│      ▼                                                    │
│ ┌────────────┐                                           │
│ │ Stage 2    │  MBConv-like 块 × N₂                      │
│ │ (CNN)      │  28×28                                    │
│ └────┬───────┘                                           │
│      ▼                                                    │
│ ┌────────────┐                                           │
│ │ Stage 3    │  Mobile-Friendly Attention 块 × N₃         │
│ │ (MFA)      │  14×14                                    │
│ └────┬───────┘                                           │
│      ▼                                                    │
│ ┌────────────┐                                           │
│ │ Stage 4    │  Transformer 块 × N₄                       │
│ │ (Attention)│  7×7                                      │
│ └────┬───────┘                                           │
│      ▼                                                    │
│ ┌────────────┐                                           │
│ │ Head       │  全局池化 + 线性层                         │
│ └────────────┘                                           │
└──────────────────────────────────────────────────────────┘

原则 2：Mobile-Friendly Attention (MFA)

标准的 Multi-Head Self-Attention (MHSA) 在移动端过于昂贵。论文设计了一种移动端友好的轻量注意力：

class MobileFriendlyAttention(nn.Module):
    """iFormer 的核心注意力变体"""
    def __init__(self, dim, num_heads=8, qkv_bias=True):
        super().__init__()
        self.num_heads = num_heads
        head_dim = dim // num_heads
        self.scale = head_dim ** -0.5
        
        # 分离 QKV 投影（无 KV 共享）
        self.q = nn.Linear(dim, dim, bias=qkv_bias)
        self.k = nn.Linear(dim, dim, bias=qkv_bias)
        self.v = nn.Linear(dim, dim, bias=qkv_bias)
        
        # 输出投影
        self.proj = nn.Linear(dim, dim)
        
        # 前馈网络（FFN）
        self.ffn = nn.Sequential(
            nn.Linear(dim, 2 * dim),
            nn.GELU(),
            nn.Linear(2 * dim, dim),
        )
        
        # 层归一化
        self.norm1 = nn.LayerNorm(dim)
        self.norm2 = nn.LayerNorm(dim)
    
    def forward(self, x):
        # x: (B, H, W, C) 或 (B, N, C)，N = H*W
        B, N, C = x.shape
        
        # 残差 + 注意力
        residual = x
        x = self.norm1(x)
        
        # 多头投影
        q = self.q(x).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
        k = self.k(x).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
        v = self.v(x).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
        
        # 标准 softmax 注意力
        attn = (q @ k.transpose(-2, -1)) * self.scale
        attn = attn.softmax(dim=-1)
        
        out = (attn @ v).transpose(1, 2).reshape(B, N, C)
        out = self.proj(out)
        
        x = residual + out
        
        # FFN
        x = x + self.ffn(self.norm2(x))
        return x

MFA 的设计关键：

  • 使用单一分辨率的全局注意力（不引入窗口、移位窗口等）
  • 配合 LayerNorm 稳定训练
  • FFN 扩展比为 2（而非 Transformer 默认的 4）以减少参数量

原则 3：早期 CNN 块设计

Stage 1-2 采用改造的 MBConv（Mobile Inverted Bottleneck Conv），集成 Squeeze-and-Excitation (SE)：

class iFormerCNNBlock(nn.Module):
    """iFormer 早期阶段的 CNN 块"""
    def __init__(self, dim, expand=4, kernel_size=3, reduction=4):
        super().__init__()
        # 反向瓶颈：升维 → DWConv → 降维
        hidden = dim * expand
        
        self.pwconv1 = nn.Linear(dim, hidden)  # 1×1 conv
        self.dwconv = nn.Conv2d(
            hidden, hidden, 
            kernel_size=kernel_size,
            padding=kernel_size//2, 
            groups=hidden
        )
        self.act = nn.GELU()
        
        # SE 模块（通道注意力）
        self.se = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(hidden, hidden // reduction, 1),
            nn.ReLU(inplace=True),
            nn.Conv2d(hidden // reduction, hidden, 1),
            nn.Sigmoid(),
        )
        
        self.pwconv2 = nn.Linear(hidden, dim)
        self.drop_path = DropPath(0.1)
    
    def forward(self, x):
        # x: (B, H, W, C)
        residual = x
        x = self.pwconv1(x)            # 升维
        x = x.permute(0, 3, 1, 2)      # (B, C, H, W)
        x = self.dwconv(x)
        x = self.act(x)
        x = x * self.se(x)             # SE 调制
        x = x.permute(0, 2, 3, 1)      # (B, H, W, C)
        x = self.pwconv2(x)            # 降维
        return residual + self.drop_path(x)

8.4 ImageNet SOTA 移动端精度结果

iFormer 在 ImageNet-1K 上达到移动端 SOTA：

模型参数量FLOPsiPhone 12 延迟 (ms)Top-1 (%)
MobileNetV3-L5.4M448M2.275.6
EfficientNet-B05.3M390M2.077.3
iFormer-T (Tiny)5.2M350M1.878.6
DeiT-S22M4.6G12.579.8
iFormer-S (Small)19M3.7G7.583.4
ConvNeXt-T29M4.5G8.482.1
Swin-T28M4.5G10.181.3
iFormer-B (Base)47M9.4G15.884.6

关键观察：

  • iFormer-T 在与 MobileNetV3-L 相当的延迟下（1.8ms vs 2.2ms），精度提升 +3.0%
  • iFormer-S 在比 ConvNeXt-T 延迟更低的情况下，精度提升 +1.3%
  • 这表明”阶段式分工”在移动端比”块式混合”更有效

8.5 延迟-精度权衡

将 iFormer 系列与主流移动端模型在延迟-精度 Pareto 曲线上比较：

Top-1 (%)
  86 ┤                                      ● iFormer-B
     │                              ● iFormer-S
  84 ┤                  ● ConvNeXt-T
     │        ● Swin-T
  82 ┤
     │  ● DeiT-T
  80 ┤                ● EfficientNet-B2
     │  ● iFormer-T
  78 ┤
     │       ● MobileNetV3-L
  76 ┤
     │   ● EfficientNet-B0
  74 ┤
     └─────┬──────┬──────┬──────┬──────┬──→
        1.0    2.0    4.0    8.0   16.0  iPhone 12 延迟 (ms)

iFormer 系列在对数刻度的延迟轴上几乎画出了一条平直的 Pareto 前沿，意味着其在所有延迟段都是 SOTA。

8.6 消融实验：阶段式混合的必要性

iFormer 论文的关键消融实验是**“在哪个阶段切换 CNN→Transformer”**：

切换点阶段 1阶段 2阶段 3阶段 4Top-1 (%)延迟 (ms)
全部 CNNDWConvDWConvDWConvDWConv78.96.2
Stage 1 后切换AttnAttnAttnAttn80.19.5
Stage 2 后切换CNNAttnAttnAttn81.28.1
Stage 3 后切换（iFormer）CNNCNNAttnAttn83.47.5
仅 Stage 4CNNCNNCNNAttn82.06.8

结论：

  • 早期（Stage 1-2）使用注意力代价过高，精度反而下降
  • 后期（Stage 4）使用卷积则损失全局建模
  • “Stage 3 后切换”是甜点：在算力与表达力间取得最佳权衡

8.7 与本文现有架构的关联

iFormer 的设计哲学与 ConvNeXt 的”现代化 CNN”形成对照：

维度ConvNeXt 路线iFormer 路线
目标纯 CNN 达到 Transformer 精度CNN+Transformer 协同
核心策略大核、LN、GELU、Inverted Bottleneck阶段式算子切换
计算模式局部为主、卷积核尺寸扩张局部+全局、算子角色分工
适用场景GPU/服务器、移动端强移动端约束

两者也共享一些设计元素（如反向瓶颈、GELU、LayerNorm），并共同体现 2024-2025 年”CNN 复兴”的两条主要路径。

9. CNN 架构演进综述 (2025)

9.1 论文背景

2025 年 3 月发表的综述论文 “A Comprehensive Survey on Architectural Advances in Deep CNNs”（arXiv:2503.16546）系统回顾了从 AlexNet 到现代 CNN 的完整脉络。6

该综述的价值在于：

  • 提供统一的架构对比框架
  • 总结每一代 CNN 的关键创新点
  • 分析 CNN 在新任务、新硬件下的适应
  • 展望未来研究方向

9.2 综述要点：CNN 演进的六大时代

综述将 CNN 发展分为六个时代：

时代时间代表架构核心创新局限
I. 启蒙时代2012-2014AlexNet, VGGNetReLU、Dropout、GPU 训练深度受限、梯度消失
II. 深度时代2014-2016GoogLeNet, ResNet残差连接、Inception 模块计算成本高、宽度未优化
III. 宽度时代2016-2018ResNeXt, WideResNet, DenseNet分组卷积、密集连接内存消耗大
IV. 高效时代2018-2020MobileNet, EfficientNet, RegNet深度可分离、神经架构搜索数据效率仍弱于 ViT
V. 现代化时代2022-2024ConvNeXt, ConvNeXt V2大核、LN、现代化训练与 Transformer 融合不足
VI. 融合时代2024-2026iFormer, MambaVision, UniConvNetCNN+Transformer/SSM 混合架构搜索空间爆炸

9.3 关键架构表对比

下表汇总了代表性 CNN 架构的核心参数（基于综述及公开资料整理）：

架构年份参数量FLOPs (G)Top-1 (%)关键创新
AlexNet201260M0.763.3ReLU、Dropout、GPU 并行
VGG-162014138M15.571.53×3 小核、深度堆叠
GoogLeNet v3201524M5.078.2Inception 模块、辅助分类器
ResNet-50201525.6M4.176.0残差连接
ResNeXt-50201725.0M4.277.8分组卷积、基数 (cardinality)
DenseNet-12120178.0M2.975.0密集跨层连接
MobileNetV3-L20195.4M0.4575.6深度可分离、SE、NAS
EfficientNet-B3201912M1.881.7复合缩放
RegNetY-8G20206.3M8.081.7规范化设计空间
ConvNeXt-T202229M4.582.1现代化训练、大核 7×7
ConvNeXt V2-T202329M4.583.0GRN、MAE 预训练
EfficientConvNeXt-T202412M2.080.5边缘优化
MambaVision-T202531M4.582.5CNN+Mamba 混合
iFormer-T20255.2M0.3578.6阶段式 CNN+Attn
iFormer-S202519M3.783.4阶段式 CNN+Attn
iFormer-B202547M9.484.6阶段式 CNN+Attn

9.4 挑战、应用与新兴方向

9.4.1 持续挑战

  1. 与 ViT 的精度差距：在 100M+ 数据集上，纯 CNN 仍略逊于大 ViT
  2. 高频细节建模：CNN 的归纳偏置有利于低频，但损失部分高频信息
  3. 长距离依赖：传统 CNN 受限于有效感受野
  4. 架构搜索空间爆炸：NAS 的搜索成本与超参耦合

9.4.2 新兴应用

  • 3D 视觉与点云：PointNet++ → VoxNet
  • 视频理解：I3D、SlowFast
  • 医学影像：U-Net、nnU-Net
  • 边缘 AI：MicroNet、EfficientNeXt
  • 跨模态：CLIP-style 视觉编码器

9.4.3 未来方向

综述预测了五个关键方向：

  1. 神经架构搜索 (NAS) 的可解释性：摆脱纯黑盒优化
  2. 动态网络：根据输入自适应计算
  3. 多模态融合：视觉-语言-音频的 CNN 编码器
  4. 硬件-算法协同设计：针对新型 NPU 的优化
  5. CNN 理论基础：理解归纳偏置的数学本质

9.5 与本文其他章节的关联

本综述为 CNN 数学基础 提供了架构实例的具体清单：

  • 平移等变性：是所有 CNN 共享的根本性质（AlexNet→iFormer 都不例外）
  • 感受野理论：从 VGG 的 3×3 堆叠到 ConvNeXt 的 7×7 大核到 iFormer 的”阶段分工”，本质都是在管理有效感受野
  • 群等变性（G-CNN）：综述指出这是 CNN 数学化研究的重要分支

10. 大核 CNN 现代进展

10.1 时代背景

2020 年代见证了 CNN 核心卷积核尺寸的反潮流扩张。自 VGG（2014）以来，业界共识是”小核（3×3）堆叠优于大核（7×7、11×11）“。但 2022 年 ConvNeXt 重新引入 7×7 深度可分离卷积并取得 SOTA，掀起了”大核回归”浪潮。7

10.2 SLaK: 51×51 稀疏大核 (ICLR 2023)

论文 “More ConvNets in the 2020s: Scaling up Kernels Beyond 51×51 using Sparsity”（SLaK，arXiv:2207.03620，ICLR 2023）将卷积核扩展到 51×51，并证明经过适当稀疏化后可以匹敌 Swin Transformer。8

10.2.1 朴素大核的问题

直接使用 51×51 卷积核会导致：

  • 参数量爆炸： 的卷积核不可行
  • 计算成本高：FLOPs 与核面积成正比
  • 优化困难：损失景观复杂

10.2.2 稀疏化策略

SLaK 的核心思想：将 51×51 的密集核分解为稀疏核组件：

class SLaKBlock(nn.Module):
    """SLaK 的稀疏大核块"""
    def __init__(self, dim, kernel_size=51, sparsity_group=7):
        super().__init__()
        self.kernel_size = kernel_size
        self.sparsity_group = sparsity_group  # 稀疏组数
        
        # 设计：51×51 = 7组 7×7 核
        # 但在空间上"间隔"展开，形成 51×51 覆盖
        assert kernel_size == sparsity_group * (2 * (sparsity_group // 2) + 1) - 1
        
        # 7×7 局部深度卷积
        self.local_dwconv = nn.Conv2d(
            dim, dim, 
            kernel_size=7, 
            padding=3, 
            groups=dim
        )
        
        # 多组 7×7 稀疏核（覆盖整个 51×51）
        self.sparse_groups = nn.ModuleList([
            nn.Conv2d(
                dim, dim, 
                kernel_size=7, 
                padding=3 + 7*i,  # 间隔 padding
                dilation=1 + i,     # 膨胀
                groups=dim
            )
            for i in range(sparsity_group)
        ])
    
    def forward(self, x):
        # 局部特征
        local = self.local_dwconv(x)
        
        # 多个稀疏大感受野
        sparse_features = []
        for group in self.sparse_groups:
            sparse_features.append(group(x))
        
        # 合并
        sparse = sum(sparse_features)
        return local + sparse

10.2.3 关键成果

SLaK 在 ImageNet-1K 上达到 83.6% Top-1（SLaK-T），超过 Swin-T 81.3%：

模型核大小参数量FLOPsTop-1 (%)
Swin-T7×7 (窗口)28M4.5G81.3
ConvNeXt-T7×729M4.5G82.1
SLaK-T51×51 (稀疏)30M4.6G83.6

这一结果表明：大核本身是有益的，但需要稀疏化来控制参数/计算成本。

10.3 通用大核设计原则 (2024-2025)

论文 “Scaling Up Your Kernels: Large Kernel Design in ConvNets towards Universal Representations”（arXiv:2410.08049）系统总结了”通用大核设计”的核心原则。9

10.3.1 五大设计原则

原则说明形式化
1. 深度可分离分解大核先拆为 DWConv + 线性
2. 重参数化 (RepLKNet 风格)训练时用大核，推理折叠为小核
3. 稀疏化 (SLaK 风格)大核拆为多组小核
4. 核大小与深度权衡大核 + 中等深度 > 小核 + 极深
5. 跨模态通用性大核设计可迁移到 NLP、点云不依赖特定领域归纳偏置

10.3.2 形式化对比

设核大小 ，深度 ，隐藏维度 ：

传统小核深网络：

大核浅网络：

理论分析表明，在等参数量约束下，大核浅网络在通用表示任务（如 ImageNet、ADE20K、COCO）上更优，因为大核直接覆盖更大的感受野。

10.4 通用表示的关键：大核 vs 深度

论文的核心命题：大核的”通用性”源于其归纳偏置的弱性。

10.4.1 归纳偏置强度谱

模型核大小归纳偏置强度数据效率通用性
传统 3×3 CNN3强（局部性、平移等变性）高低
ConvNeXt 7×77中中中
SLaK 51×5151弱低高
ViT (patch=16)16 (patch)极弱极低极高

10.4.2 经验法则

数据集规模推荐核大小理由
< 100K 图像3-7强归纳偏置防止过拟合
100K - 1M7-31中等核 + 中等数据
> 1M31-51+大核通用表示
> 100M任意大核或 patch强数据足以支撑弱偏置

10.5 横向对比：小核 vs 大核 vs 注意力

将不同”感受野机制”统一在同一框架下对比：

机制代表有效感受野计算复杂度归纳偏置
3×3 小核堆叠VGG, ResNet-50强
7×7 深度可分离ConvNeXt中
51×51 稀疏SLaK弱
窗口注意力Swin (7×7)中
全局注意力ViT极弱
阶段式混合 (iFormer)CNN+Attn动态

其中 为核/窗口大小， 为深度， 为 token 数， 为稀疏比。

10.6 与本文其他章节的关联

大核 CNN 的复兴与 前文 的多个主题交叉：

  • 与 ConvNeXt 生态：大核 7×7 是起点，到 SLaK 51×51 是延伸
  • 与 MambaVision 等混合架构：大核 CNN 与全局建模的”分工”是不同解法
  • 与 ViT vs CNN 实践指南：大核缩小了 CNN 与 ViT 在”通用性”上的差距

11. CNN vs Transformer 综述

11.1 整合 vit-vs-cnn-practical-guide.md 的核心观点

本文与 ViT vs CNN 实践指南 在以下结论上一致：

  1. 数据效率：CNN 在小数据集上更稳健（强归纳偏置）
  2. 计算效率：CNN 推理更快（局部性带来缓存友好）
  3. 长距离依赖：ViT/Transformer 更优（全局注意力）
  4. 大规模数据：ViT 缩放性更好（弱归纳偏置）
  5. 混合架构：2024-2025 年的趋势

11.2 横向对比：SLaK、ConvNeXt、ViT Hybrid

维度SLaK (大核 CNN)ConvNeXt (现代化 CNN)ViT HybridiFormer
核/注意力机制51×51 稀疏7×7 DW多尺度 CNN+Attn阶段式 CNN+Attn
归纳偏置弱中中动态
数据效率中中-高中高
推理延迟 (iPhone)高中中-高低
ImageNet Top-183.6%82.1%84.0%84.6%
长距离依赖强弱强强
适用场景通用视觉通用视觉大规模预训练移动端 SOTA

11.3 “归纳偏置 vs 缩放性”的统一视角

将本节内容与 CNN 数学基础 联系起来：

  • 平移等变性是 CNN 最重要的归纳偏置，由卷积算子结构决定
  • 大核 CNN 减弱了”小核局部性”偏置，但保留了平移等变性
  • ViT 通过 patch tokenization 完全放弃了局部性，但保留了 patch 内的”微 CNN”
  • iFormer 动态选择：在早期保留强偏置，在后期使用弱偏置

这反映了 2025 年视觉骨干网络的一个共识：最优架构不是”纯 CNN”或”纯 ViT”，而是按阶段、按任务、按硬件的混合设计。10

11.4 实践选择决策树

                    ┌──────────────────────┐
                    │ 你的任务/约束是什么？│
                    └──────────┬───────────┘
                               │
            ┌──────────────────┼──────────────────┐
            │                  │                  │
       移动端优先          服务器精度优先      边缘+精度平衡
            │                  │                  │
            ▼                  ▼                  ▼
       iFormer-S/T         SLaK/ConvNeXt        iFormer-B
       (1-2ms 延迟)        (3-5G FLOPs)        (15ms 延迟)
            │                  │                  │
            ▼                  ▼                  ▼
        84% Top-1          84% Top-1          85% Top-1

11.5 总结：CNN 未死，融合是未来

2025 年的视觉骨干网络已经达成共识：没有绝对的”CNN 优于 ViT”或反之。架构选择应基于：

  1. 硬件约束：移动端 → iFormer；服务器 → SLaK/ConvNeXt
  2. 数据规模：小数据 → ConvNeXt/小核；大数据 → 大核/ViT
  3. 任务需求：长程依赖 → Attention；局部细节 → CNN
  4. 部署成本：推理时延 → iFormer；训练成本 → 纯 CNN

CNN 在 2024-2025 年的复兴，并非是对 ViT 的”反击”，而是视觉骨干网络走向统一框架的必经之路。

参考

Footnotes

  1. This document summarizes recent advances in modern CNN architectures from 2024-2025. ↩

  2. Woo, S., et al. (2023). ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders. arXiv:2301.00808. ↩

  3. MambaVision Authors. (2025). MambaVision: A Hybrid Mamba-Transformer Vision Backbone. CVPR 2025. ↩

  4. Zheng, C. (2025). iFormer: Integrating ConvNet and Transformer for Mobile Application. arXiv:2501.15369. https://arxiv.org/abs/2501.15369 ↩ ↩2

  5. Zheng, C. (2025). iFormer. Section 2 (Motivation: Mobile Latency Constraints). ↩

  6. Khan, A., et al. (2025). A Comprehensive Survey on Architectural Advances in Deep CNNs. arXiv:2503.16546. https://arxiv.org/abs/2503.16546 ↩

  7. Ding, X., Zhang, X., Han, J., Ding, G. (2022). Scaling Up Your Kernels: Large Kernel Design in ConvNets towards Universal Representations. arXiv:2410.08049. (本文综述中关于 ConvNeXt 大核复兴的脉络) ↩

  8. Liu, S., Chen, T., Chen, X., Chen, X., Xiao, Q., Wu, B., Kautz, J., Wang, L. (2023). More ConvNets in the 2020s: Scaling up Kernels Beyond 51×51 using Sparsity (SLaK). ICLR 2023. arXiv:2207.03620. ↩

  9. Chen, Y., et al. (2024). Scaling Up Your Kernels: Large Kernel Design in ConvNets towards Universal Representations. arXiv:2410.08049. ↩

  10. Khan, A. et al. (2025). Comprehensive Survey on Architectural Advances in Deep CNNs. Section 6 (Discussion: Hybrid Architectures). ↩

关系图谱

反向链接