概述
尽管 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 outGRN 的作用：
| 机制 | 效果 |
|---|---|
| 响应归一化 | 平衡通道间的激活强度 |
| 竞争机制 | 促进通道专业化 |
| 替代 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 out2.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：
| 模型 | 参数量 | FLOPs | ImageNet Top-1 |
|---|---|---|---|
| MicroViT-T | 1.2M | 55M | 68.5% |
| MicroViT-S | 2.8M | 130M | 73.2% |
| MicroViT-B | 5.1M | 250M | 76.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 分类
| 模型 | 参数量 | FLOPs | Top-1 |
|---|---|---|---|
| ConvNeXt-B | 89M | 15.4G | 85.8% |
| ConvNeXt V2-B | 89M | 15.4G | 86.4% |
| MambaVision-S | 50M | 8.2G | 85.2% |
| VCMamba-T | 28M | 4.5G | 83.1% |
| CoSNet-S | 45M | 7.8G | 84.7% |
| UniConvNet-B | 86M | 14.8G | 85.5% |
5.2 推理速度
在 A100 GPU 上：
| 模型 | 吞吐量 (images/sec) |
|---|---|
| ConvNeXt-B | 850 |
| MambaVision-S | 1200 |
| CoSNet-S | 980 |
| ViT-B | 320 |
观察：CNN 及其混合变体在效率上仍优于纯 Transformer。
6. 设计原则总结
6.1 ConvNeXt 设计原则
- 现代训练策略：AdamW、大 batch、AugReg
- 层次化设计：多尺度特征金字塔
- ResNeXt 化：分组卷积增加容量
- 反转瓶颈：大 → 小 → 大
- 大核卷积：7×7 或更大
- GELU 激活：替代 ReLU
- LayerNorm：替代 BatchNorm（某些场景）
6.2 混合架构原则
- CNN 主干：提取局部特征
- SSM/Mamba：建模长距离依赖
- 门控融合：平衡局部和全局
- 多方向扫描：充分覆盖空间
6.3 轻量级设计原则
- 深度可分离卷积：减少 FLOPs
- 跨阶段部分连接：减少参数
- 渐进式下采样：保持信息
- 动态精度缩放：适配硬件
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 的统一架构可能成为未来主流：
- 根据任务自动选择计算模式
- 共享局部和全局表示
- 端到端可微优化
参考
Footnotes
-
This document summarizes recent advances in modern CNN architectures from 2024-2025. ↩
-
Woo, S., et al. (2023). ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders. arXiv:2301.00808. ↩
-
MambaVision Authors. (2025). MambaVision: A Hybrid Mamba-Transformer Vision Backbone. CVPR 2025. ↩