# 视觉 Transformer（ViT） > 把图像切成 patch，把每个 patch 当成一个词，跑一个标准 transformer。别回头看。 **类型：** Build **语言：** Python **前置要求：** 阶段 7 第 02 课（自注意力）、阶段 4 第 04 课（图像分类） **预计时间：** ~45 分钟 ## 学习目标 - 从零实现 patch 嵌入、学习式位置嵌入、class token 和 transformer 编码器块，搭一个极简 ViT - 解释为什么 ViT 曾被认为需要海量预训练数据，直到 DeiT 和 MAE 证明并非如此 - 在架构先验上对比 ViT、Swin、ConvNeXt（无先验、局部窗口注意力、卷积骨干） - 用 `timm` 和标准的线性探针 / 微调配方，在一个小数据集上微调预训练 ViT ## 问题背景 十年里，卷积几乎就是计算机视觉的同义词。CNN 有强归纳偏置——局部性、平移等变性——没人觉得你能替换掉它们。然后 Dosovitskiy 等人（2020）证明：一个朴素 transformer，作用于展平的图像 patch，完全不用卷积机制，在规模上能匹敌甚至击败最好的 CNN。 陷阱在于"在规模上"。ViT 在 ImageNet-1k 上输给 ResNet。在 ImageNet-21k 或 JFT-300M 上预训练、再在 ImageNet-1k 上微调的 ViT 赢了它。结论是 transformer 缺少有用的先验，但能从足够多的数据里学到它们。后续工作（DeiT、MAE、DINO）表明：有了对的训练配方——强增广、自监督预训练、蒸馏——ViT 在小数据上也训得很好。 到 2026 年，纯 CNN 在边缘设备上仍有竞争力（ConvNeXt 最强），但 transformer 称霸其余一切：分割（Mask2Former、SegFormer）、检测（DETR、RT-DETR）、多模态（CLIP、SigLIP）、视频（VideoMAE、VJEPA）。ViT 的块结构就是那个该掌握的。 ## 核心概念 ### Pipeline ```mermaid flowchart LR IMG["图像
(3, 224, 224)"] --> PATCH["patch 嵌入
conv 16x16 s=16
-> (768, 14, 14)"] PATCH --> FLAT["展平为
(196, 768) token"] FLAT --> CAT["在前面拼
[CLS] token"] CAT --> POS["加学习式
位置嵌入"] POS --> ENC["N 个 transformer
编码器块"] ENC --> CLS["取 [CLS]
token 输出"] CLS --> HEAD["MLP 分类器"] style PATCH fill:#dbeafe,stroke:#2563eb style ENC fill:#fef3c7,stroke:#d97706 style HEAD fill:#dcfce7,stroke:#16a34a ``` 七步。patch -> token -> 注意力 -> 分类器。每个变体（DeiT、Swin、ConvNeXt、MAE 预训练）改其中一两步，其余照旧。 ### Patch 嵌入 第一个卷积是诀窍。核大小 16、stride 16，于是一张 224x224 图像变成一个 14x14 的 16x16 patch 网格，每个被投影成一个 768 维嵌入。那一个卷积既切 patch 又做线性投影。 ``` 输入: (3, 224, 224) 卷积 (3 -> 768, k=16, s=16, 无 padding): 输出: (768, 14, 14) 展平空间: (196, 768) ``` 196 个 patch = 196 个 token。每个 token 的特征维度是 768（ViT-B）、1024（ViT-L）或 1280（ViT-H）。 ### Class token 一个学习出来的向量，拼在序列前面： ``` tokens = [CLS; patch_1; patch_2; ...; patch_196] shape (197, 768) ``` 经过 N 个 transformer 块后，`[CLS]` 的输出是全局图像表示。分类头只读这一个向量。 ### 位置嵌入 Transformer 没有内建的空间位置概念。给每个 token 加一个学习出来的向量： ``` tokens = tokens + learned_pos_embedding (同样是 shape (197, 768)) ``` 这个嵌入是模型的一个参数；基于梯度的训练让它适应 2D 图像结构。有正弦式 2D 替代方案，但实践中很少用。 ### Transformer 编码器块 标准的。多头自注意力、MLP、残差连接、pre-LayerNorm。 ``` x = x + MSA(LN(x)) x = x + MLP(LN(x)) MLP 是带 GELU 的两层：Linear(d -> 4d) -> GELU -> Linear(4d -> d) ``` ViT-B/16 堆 12 个这样的块，每个 12 个注意力头，共 8600 万参数。 ### 为什么用 pre-LN 早期 transformer 用 post-LN（`x = LN(x + sublayer(x))`），不带 warmup 很难训过 6-8 层。Pre-LN（`x = x + sublayer(LN(x))`）不带 warmup 也能稳定训练更深的网络。每个 ViT 和每个现代 LLM 都用 pre-LN。 ### Patch 大小的权衡 - 16x16 patch -> 196 token，标准。 - 32x32 patch -> 49 token，更快但分辨率更低。 - 8x8 patch -> 784 token，更细但 O(n^2) 注意力成本缩放很差。 patch 越大 = token 越少 = 越快但空间细节越少。SwinV2 在层级窗口里用 4x4 patch。 ### DeiT 在 ImageNet-1k 上训练 ViT 的配方 原始 ViT 需要 JFT-300M 才能击败 CNN。DeiT（Touvron 等人，2020）仅靠 ImageNet-1k 就把 ViT-B 训到 81.8% top-1，靠四个改动： 1. 重度增广：RandAugment、Mixup、CutMix、Random Erasing。 2. 随机深度（训练时随机丢掉整个块）。 3. 重复增广（同一图像每个 batch 采 3 次）。 4. 从一个 CNN 教师蒸馏（可选，进一步提升准确率）。 每个现代 ViT 训练配方都源自 DeiT。 ### Swin vs ConvNeXt - **Swin**（Liu 等人，2021）—— 基于窗口的注意力。每个块在一个局部窗口内做注意力；交替的块移动窗口，跨窗口混合信息。在保留注意力算子的同时找回了类 CNN 的局部性先验。 - **ConvNeXt**（Liu 等人，2022）—— 重新设计的 CNN，匹配了 Swin 的架构选择（深度可分卷积、LayerNorm、GELU、倒置瓶颈）。它表明差距不是"注意力 vs 卷积"，而是"现代训练配方 + 架构"。 2026 年，ConvNeXt-V2 和 Swin-V2 都是生产级；正确的选择取决于你的推理栈（ConvNeXt 在边缘上编译得更好）和预训练语料。 ### MAE 预训练 掩码自编码器（He 等人，2022）：随机掩码 75% 的 patch，训练编码器只处理可见的 25%，训练一个小解码器从编码器输出重建被掩码的 patch。预训练后丢掉解码器，微调编码器。 MAE 让 ViT 仅靠 ImageNet-1k 就可训练、达到 SOTA，是当前默认的自监督配方。 ```figure batchnorm-inference ``` ## 动手构建 ### 第 1 步：Patch 嵌入 ```python import torch import torch.nn as nn class PatchEmbedding(nn.Module): def __init__(self, in_channels=3, patch_size=16, dim=192, image_size=64): super().__init__() assert image_size % patch_size == 0 self.proj = nn.Conv2d(in_channels, dim, kernel_size=patch_size, stride=patch_size) num_patches = (image_size // patch_size) ** 2 self.num_patches = num_patches def forward(self, x): x = self.proj(x) return x.flatten(2).transpose(1, 2) ``` 一个卷积、一个 flatten、一个 transpose。这就是整个"图像到 token"步骤。 ### 第 2 步：Transformer 块 Pre-LN、多头自注意力、带 GELU 的 MLP、残差连接。 ```python class Block(nn.Module): def __init__(self, dim, num_heads, mlp_ratio=4, dropout=0.0): super().__init__() self.ln1 = nn.LayerNorm(dim) self.attn = nn.MultiheadAttention(dim, num_heads, dropout=dropout, batch_first=True) self.ln2 = nn.LayerNorm(dim) self.mlp = nn.Sequential( nn.Linear(dim, dim * mlp_ratio), nn.GELU(), nn.Dropout(dropout), nn.Linear(dim * mlp_ratio, dim), nn.Dropout(dropout), ) def forward(self, x): a, _ = self.attn(self.ln1(x), self.ln1(x), self.ln1(x), need_weights=False) x = x + a x = x + self.mlp(self.ln2(x)) return x ``` `nn.MultiheadAttention` 处理拆头、缩放点积和输出投影。`batch_first=True`，所以形状是 `(N, seq, dim)`。 ### 第 3 步：ViT ```python class ViT(nn.Module): def __init__(self, image_size=64, patch_size=16, in_channels=3, num_classes=10, dim=192, depth=6, num_heads=3, mlp_ratio=4): super().__init__() self.patch = PatchEmbedding(in_channels, patch_size, dim, image_size) num_patches = self.patch.num_patches self.cls_token = nn.Parameter(torch.zeros(1, 1, dim)) self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, dim)) self.blocks = nn.ModuleList([ Block(dim, num_heads, mlp_ratio) for _ in range(depth) ]) self.ln = nn.LayerNorm(dim) self.head = nn.Linear(dim, num_classes) nn.init.trunc_normal_(self.pos_embed, std=0.02) nn.init.trunc_normal_(self.cls_token, std=0.02) def forward(self, x): x = self.patch(x) cls = self.cls_token.expand(x.size(0), -1, -1) x = torch.cat([cls, x], dim=1) x = x + self.pos_embed for blk in self.blocks: x = blk(x) x = self.ln(x[:, 0]) return self.head(x) vit = ViT(image_size=64, patch_size=16, num_classes=10, dim=192, depth=6, num_heads=3) x = torch.randn(2, 3, 64, 64) print(f"output: {vit(x).shape}") print(f"params: {sum(p.numel() for p in vit.parameters()):,}") ``` 约 280 万参数——一个在 CPU 上跑得动的小 ViT。真正的 ViT-B 是 8600 万；同一个类定义，用 `dim=768, depth=12, num_heads=12`。 ### 第 4 步：合理性检查 —— 单图推理 ```python logits = vit(torch.randn(1, 3, 64, 64)) print(f"logits: {logits}") print(f"probs: {logits.softmax(-1)}") ``` 应该无错运行。概率之和为 1。 ## 实际使用 `timm` 提供每个 ViT 变体的 ImageNet 预训练权重。一行： ```python import timm model = timm.create_model("vit_base_patch16_224", pretrained=True, num_classes=10) ``` 2026 年 `timm` 是视觉 transformer 的生产默认。在同一套 API 下支持 ViT、DeiT、Swin、Swin-V2、ConvNeXt、ConvNeXt-V2、MaxViT、MViT、EfficientFormer，以及几十个其他模型。 做多模态（图像 + 文本）时，`transformers` 提供 CLIP、SigLIP、BLIP-2、LLaVA。这些里面的图像编码器都是某个 ViT 变体。 ## 拿去用 这一课产出： - `outputs/prompt-vit-vs-cnn-picker.md` —— 一个 prompt，根据数据集规模、算力和推理栈，在 ViT、ConvNeXt、Swin 之间挑选。 - `outputs/skill-vit-patch-and-pos-embed-inspector.md` —— 一个 skill，验证 ViT 的 patch 嵌入和位置嵌入形状是否匹配模型期望的序列长度，抓出最常见的移植 bug。 ## 练习 1. **（简单）** 打印上面那个小 ViT 一次前向里每个中间张量的形状。确认：输入 `(N, 3, 64, 64)` -> patch `(N, 16, 192)` -> 带 CLS `(N, 17, 192)` -> 分类器输入 `(N, 192)` -> 输出 `(N, num_classes)`。 2. **（中等）** 在第 4 课的合成 CIFAR 数据集上微调一个预训练的 `timm` ViT-S/16。和在同样数据上微调 ResNet-18 对比。报告训练时间和最终准确率。 3. **（困难）** 为这个小 ViT 实现 MAE 预训练：掩码 75% 的 patch，训练编码器 + 一个小解码器去重建被掩码的 patch。评估预训练前后在合成数据上的线性探针准确率。 ## 关键术语 | 术语 | 大家嘴上怎么说 | 它实际是什么 | |------|----------------|----------------------| | Patch 嵌入 | "第一个卷积" | 核大小 = stride = patch 大小的卷积；把图像变成 token 嵌入的网格 | | Class token | "[CLS]" | 拼在 token 序列前面的学习出来的向量；它的最终输出是全局图像表示 | | 位置嵌入 | "学习式位置" | 加到每个 token 上的学习出来的向量，让 transformer 知道每个 patch 来自哪 | | Pre-LN | "子层前做 LayerNorm" | 稳定的 transformer 变体：`x + sublayer(LN(x))` 而非 `LN(x + sublayer(x))` | | 多头注意力 | "并行注意力" | 标准 transformer 注意力，拆成 num_heads 个独立子空间，之后拼接 | | ViT-B/16 | "Base，patch 16" | 经典尺寸：dim=768、depth=12、heads=12、patch_size=16、image=224；约 8600 万参数 | | DeiT | "数据高效 ViT" | 仅在 ImageNet-1k 上配强增广训练的 ViT；证明海量预训练数据并非严格必需 | | MAE | "掩码自编码器" | 自监督预训练：掩码 75% 的 patch，重建；主导的 ViT 预训练配方 | ## 延伸阅读 - [An Image is Worth 16x16 Words (Dosovitskiy et al., 2020)](https://arxiv.org/abs/2010.11929) —— ViT 论文 - [DeiT: Data-efficient Image Transformers (Touvron et al., 2020)](https://arxiv.org/abs/2012.12877) —— 如何仅靠 ImageNet-1k 训练 ViT - [Masked Autoencoders are Scalable Vision Learners (He et al., 2022)](https://arxiv.org/abs/2111.06377) —— MAE 预训练 - [timm documentation](https://huggingface.co/docs/timm) —— 你在生产中会用到的每个视觉 transformer 的参考