多模态：把世界变成 token

0. 本讲导读

这门课到目前为止，讲的一直是同一件事的不同侧面：怎么把一个「文本 ⇒ 文本」的函数训练得又快又好。分词（Lecture 1）、资源核算（Lecture 2）、架构与注意力变体（Lecture 3–4）、GPU 与内核（Lecture 5–6）、并行（Lecture 7–8）、缩放定律（Lecture 9、11）、推理（Lecture 10）、评测（Lecture 12）、数据（Lecture 13–14）、对齐与后训练（Lecture 15–16）。中间那个箭头一直是纯文本的。

但现实世界不是纯文本的。

Percy 在开场把终极目标说得很直白：omni model（全模态模型）。

今天我们站在哪里

Percy 给出的现状判断是一条非常「工程」的推理链，值得逐句读：

1. Transformer 工作得非常好，所以我们必须用它。这不是审美选择，而是经济选择：过去八年整个硬件栈（Tensor Core、FlashAttention、TP/PP/EP、推理引擎）都是围绕 Transformer 优化的，任何新架构要挑战它都得先补上这个几百亿美元的生态差距。
2. Transformer 说的语言是 token（可以是离散的、也可以是连续的向量），一个 token 大致代表一个语义单元的信息。
3. 因此，我们必须把一切都转换成 token。
4. 注意：文本也是这样处理的——回想 Lecture 1 的分词部分，字节流本身也不是 token，BPE 是我们人为设计的「把连续字节流切成语义单元」的过程。
5. 但对非文本模态，这件事难得多。

本讲要回答的两个问题

Percy 把整讲组织成两个问题：

1. 怎么输入非文本数据？（例如：怎么让模型理解图像）
2. 怎么输出非文本数据？（例如：怎么让模型生成音频）

本讲的绝大部分内容在回答第一个问题，因为它已经被研究得比较透彻、也有清晰的技术谱系。第二个问题（生成）目前还没有共识答案，我们会在第 7 节讨论。

1. 为什么要多模态

在跳进技术细节之前，先把动机说清楚。做多模态有三个层次的理由，从弱到强。

1.1 数据来源扩容：文本快用完了

回忆 Lecture 9/11 的缩放定律：Chinchilla 最优要求参数量 $N$ 和数据量 $D$ 同步增长，$D \approx 20N$。而 Lecture 13–14 讲数据时提到的现实是：高质量文本 token 的总量大约在 $10^{13}$–$10^{14}$ 量级，且增速远低于算力增速。

图像和视频是一个数量级完全不同的池子。粗略估算：

1.2 真实应用需要看图

这是最直接、也最无可争辩的理由。你想让模型做的很多事情，本质上就是视觉任务：

• 读一张财报截图里的表格并回答问题（OCR + 表格理解）；
• 看一段 GUI 录屏，操作一个 App（GUI agent，这是 Lecture 16 讲的 agent 能力的视觉版本）；
• 看医学影像、看电路图、看手写数学；
• 为盲人描述周围环境。

这些任务里，「把图转成文字描述再喂给纯文本模型」这条捷径是走不通的：描述的过程本身就丢掉了你需要的信息，而且你事先不知道下游会问什么，无法决定该描述什么。

1.3 跨模态迁移：真的有收益吗

最有野心的说法是：学习视觉能让模型的语言能力也变强——因为视觉数据里蕴含了大量文本中「不言自明」而从不写出来的常识（物体的相对大小、遮挡关系、物理直觉）。

这个说法在直觉上很吸引人，但证据是混合的。诚实的现状是：

所以更准确的表述是：多模态训练的收益主要来自能力覆盖面和模态内的组合泛化，而不是「看图让模型更聪明」这种玄学。

2. 图像表示路线一：连续表示（ViT）

这是今天绝对的主流路线，CLIP、SigLIP、LLaVA、Qwen-VL 全都基于它。核心思想极其简单：把图像切成固定大小的方块（patch），每个方块拉平成向量，用一个线性层投影到模型维度，再加上位置编码——这就得到了一串「视觉 token」，然后原封不动地丢进标准 Transformer。

2.1 完整的形状推演

以 CLIP 最好的模型 ViT-L/14@336px 为例，把每一步的张量形状写清楚。命名规则：L = Large，14 = patch 边长 14 像素，@336px = 输入分辨率 336×336。

几个值得注意的数字：

• 压缩比：输入 $336\times336\times3 = 338{,}688$ 个标量 → 576 个 token。每个 token 「代表」588 个像素值。对比文本：一个 BPE token 大约代表 4 个字符。所以一张图 ≈ 576 token ≈ 2300 个英文字符 ≈ 400 个单词的上下文开销。图很贵。
• 参数量：ViT-L 约 3.03 亿参数。主体是 24 层 × ($4d^2$ 注意力 + $8d^2$ FFN) $= 24 \times 12 \times 1024^2 \approx 3.0\times10^8$。
• 注意力开销：序列长度 577，注意力矩阵 $577^2 \approx 3.3\times10^5$，完全可以接受。但如果分辨率翻倍到 672×672，token 数变成 $48^2=2304$，注意力开销变成 $5.3\times10^6$，是 16 倍——分辨率的平方项是 VLM 成本的主要来源，这解释了为什么第 6 节要花那么大力气做动态分辨率。

2.2 最小实现

patch 切分有一个漂亮的实现技巧：「切 patch + 展平 + 线性投影」三步等价于一个 stride 等于 kernel size 的卷积。因为卷积核在不重叠地滑动时，每次做的就是「取一个 14×14×3 的块，与权重做内积」。

import torch
import torch.nn as nn

class PatchEmbed(nn.Module):
    """把 (B, 3, H, W) 图像变成 (B, N, D) 的视觉 token 序列。"""
    def __init__(self, img_size=336, patch=14, in_ch=3, d_model=1024):
        super().__init__()
        assert img_size % patch == 0
        self.grid = img_size // patch          # 24
        self.n_patches = self.grid ** 2        # 576
        # 关键技巧：kernel_size == stride == patch，等价于「切块 + 展平 + Linear」
        self.proj = nn.Conv2d(in_ch, d_model, kernel_size=patch, stride=patch)
        self.cls = nn.Parameter(torch.zeros(1, 1, d_model))
        self.pos = nn.Parameter(torch.zeros(1, self.n_patches + 1, d_model))

    def forward(self, x):                      # x: (B, 3, 336, 336)
        B = x.shape[0]
        x = self.proj(x)                       # (B, 1024, 24, 24)
        x = x.flatten(2).transpose(1, 2)       # (B, 576, 1024)
        cls = self.cls.expand(B, -1, -1)       # (B, 1, 1024)
        x = torch.cat([cls, x], dim=1)         # (B, 577, 1024)
        return x + self.pos                    # 加绝对位置编码

class ViT(nn.Module):
    def __init__(self, depth=24, d_model=1024, n_heads=16, **kw):
        super().__init__()
        self.embed = PatchEmbed(d_model=d_model, **kw)
        layer = nn.TransformerEncoderLayer(
            d_model, n_heads, dim_feedforward=4 * d_model,
            activation="gelu", norm_first=True, batch_first=True)
        self.blocks = nn.TransformerEncoder(layer, depth)
        self.norm = nn.LayerNorm(d_model)

    def forward(self, x):
        h = self.blocks(self.embed(x))         # (B, 577, 1024)
        return self.norm(h)                    # 全部 577 个位置的表示都保留

2.3 池化：CLS token 还是注意力池化

ViT 编码完得到 577 个向量，但 CLIP 需要一个单一向量来代表整张图。有三种做法：

1. CLS token：取第 0 个位置的输出。这是原始 ViT 分类的做法。
2. 平均池化：对 576 个 patch 输出取平均。简单，但把所有 patch 等权对待。
3. 注意力池化（attention pooling）：CLIP 采用的做法。Percy 的原话是「做一次 QKV，其中 query 取激活的全局平均」。

注意力池化的意思是：先算全局平均 $\bar{h} = \frac{1}{N}\sum_i h_i$ 作为唯一的 query，然后让它对所有 patch 做一次标准的单 query 注意力：

class AttentionPool(nn.Module):
    """CLIP 的注意力池化：query = 全局平均，key/value = 各 patch。"""
    def __init__(self, d_model, d_out, n_heads=16):
        super().__init__()
        self.attn = nn.MultiheadAttention(d_model, n_heads, batch_first=True)
        self.out = nn.Linear(d_model, d_out)

    def forward(self, h):                      # h: (B, N, D)
        q = h.mean(dim=1, keepdim=True)        # (B, 1, D)  全局平均作为 query
        pooled, _ = self.attn(q, h, h)         # (B, 1, D)  单 query 注意力
        return self.out(pooled.squeeze(1))     # (B, d_out)

相比朴素平均，它多了一步内容相关的重新加权：模型可以学会「看猫的时候，多看猫所在的那几个 patch」。相比 CLS token，它不需要额外训练一个从零开始的特殊向量，收敛更快。

2.4 图像预处理：被裁掉的信息

Percy 特意讲了 CLIP 的数据处理流程，因为这里藏着后面所有分辨率问题的根源：

1. 互联网图像是任意分辨率的（任意 $W \times H$）；
2. 用双三次插值（bicubic interpolation）缩放，使较短边变成 336 像素；
3. 中心裁剪（center crop）到 336×336——即把长边的两侧边缘直接切掉。

# CLIP 官方预处理（简化自 openai/CLIP clip.py）
from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize
from PIL import Image

preprocess = Compose([
    Resize(336, interpolation=Image.BICUBIC),   # 短边 -> 336，保持长宽比
    CenterCrop(336),                            # 裁成正方形，长边两侧被丢弃
    ToTensor(),
    Normalize(mean=(0.4815, 0.4578, 0.4082),    # CLIP 数据集统计量
              std=(0.2686, 0.2613, 0.2758)),
])

3. 图像表示路线二：离散 token（VQ-VAE / VQ-GAN）

ViT 给出的是连续向量。这对「理解」够用——把向量塞进 LLM 的输入端就行。但它有一个致命缺陷：你没法生成它。

回忆语言模型是怎么生成的：在词表 $V$ 上算 softmax，采样一个离散 token，把它喂回去，重复。这套机制的前提是输出空间是有限离散集合。如果图像表示是 $\R^{1024}$ 里的连续向量，模型该怎么「采样」下一个视觉 token？在 1024 维连续空间上做自回归生成，既没有归一化的概率分布，也没有可用的采样算子。

所以如果你想要一个能画图的自回归 Transformer，就必须先把图像变成离散符号。这就是 VQ-VAE 的任务，也是 Chameleon 走的路。

3.1 量化：把向量变成整数

设编码器（一个卷积网络）把图像 $x$ 映射为一个特征网格

码本是一组可学习的向量 $\{e_1, \dots, e_K\}$，$e_k \in \R^d$。对网格上每个位置 $(i,j)$，找最近的码本项：

然后用这个码本向量替换原向量：$z_q(x)_{ij} = e_{k_{ij}}$。

整数网格 $\{k_{ij}\}$ 就是图像的离散 token 序列（按光栅顺序展平）。Chameleon 用的配置是：512×512 的图像 → 1024 个 token，码本大小 $K = 8192$。

3.2 三项损失

VQ-VAE 的训练目标由三部分组成：

其中 $\operatorname{sg}[\cdot]$ 是 stop-gradient（PyTorch 里的 .detach()），$D$ 是解码器，$\beta$ 通常取 0.25。逐项解释：

1. 重建损失：把量化后的表示解码回图像，要求像原图。这是唯一逼迫表示「保留信息」的项。
2. 码本损失（codebook loss）：只更新码本向量 $e$，把它拉向编码器输出的那些向量。因为编码器输出被 sg 冻住了，这一项只对 $e$ 有梯度。直觉：码本要做被分配给它的那些向量的聚类中心——这实际上是在线的 $k$-means。
3. 承诺损失（commitment loss）：反过来，只更新编码器，把编码器输出拉向它选中的码本向量。为什么需要它？如果没有这一项，编码器可以让输出的模长任意增长、在空间里到处乱跑，因为量化会把一切都吸附到码本上，编码器感受不到任何约束。结果是码本永远追不上编码器，训练发散。承诺损失强制编码器「承诺」自己的输出会待在某个码本项附近。$\beta$ 控制这个约束的强度。

3.3 直通估计器

最关键的技术难点：$\argmin$ 是不可导的。$z_q$ 对 $z_e$ 的梯度处处为 0（分段常数函数）。如果照实算，重建损失的梯度根本传不到编码器，编码器永远学不到东西。

直通估计器（straight-through estimator, STE）的做法简单粗暴：前向传播时做量化，反向传播时假装量化不存在，把 $z_q$ 处收到的梯度原样复制给 $z_e$：

这在 PyTorch 里有一个非常漂亮的一行实现：

class VectorQuantizer(nn.Module):
    def __init__(self, K=8192, d=256, beta=0.25):
        super().__init__()
        self.codebook = nn.Embedding(K, d)
        self.codebook.weight.data.uniform_(-1.0 / K, 1.0 / K)
        self.beta = beta

    def forward(self, z_e):                    # z_e: (B, h, w, d)
        B, h, w, d = z_e.shape
        flat = z_e.reshape(-1, d)              # (B*h*w, d)

        # 最近邻查找：||a-b||^2 = ||a||^2 - 2a·b + ||b||^2
        dist = (flat.pow(2).sum(1, keepdim=True)
                - 2 * flat @ self.codebook.weight.t()
                + self.codebook.weight.pow(2).sum(1))       # (B*h*w, K)
        idx = dist.argmin(dim=1)                            # (B*h*w,)  <- 这就是「图像 token」
        z_q = self.codebook(idx).view(B, h, w, d)

        # 码本损失（只更新码本） + 承诺损失（只更新编码器）
        loss = ((z_q - z_e.detach()).pow(2).mean()
                + self.beta * (z_e - z_q.detach()).pow(2).mean())

        # 直通估计：前向值 = z_q，反向梯度 = 恒等映射回 z_e
        z_q = z_e + (z_q - z_e).detach()
        return z_q, idx.view(B, h, w), loss

3.4 从 VQ-VAE 到 VQ-GAN：重建质量的关键升级

纯 VQ-VAE 用 $\ell_2$ 重建损失，会产生一个众所周知的问题：输出模糊。原因是 $\ell_2$ 损失在给定编码下的最优解是条件期望，而对于「这块区域是什么纹理」这种存在多个合理答案的情况，期望就是把所有可能性平均掉——平均的结果就是糊。

VQ-GAN（Taming Transformers）的改进是在重建损失上再加两项：

• 感知损失（perceptual / LPIPS loss）：不在像素空间比对，而在一个预训练 VGG 的中间特征空间比对。它衡量的是「看起来像不像」而非「逐像素等不等」。
• 对抗损失（adversarial loss）：加一个 patch 级判别器，逼迫解码器输出落在真实图像的流形上。判别器不接受「平均出来的糊图」，因为糊图一眼就能被判为假。

Chameleon 使用的正是 VQ-GAN 系的图像 tokenizer（它引用的是 Make-A-Scene 的 tokenizer 设计，其中还专门加大了人脸区域的重建权重，因为人脸的重建瑕疵对人眼特别刺目）。

3.5 图像 token 与文本 token 的合并

拿到 8192 个图像 token 后，还有一步：怎么和文本词表共存。Percy 提到 Chameleon「训练了一个新的 BPE tokenizer」。具体做法是：

• 文本侧训一个 65,536 词的 BPE；
• 图像侧的 8192 个码本索引直接追加到词表末尾，成为 id 65536–73727；
• 用特殊 token <image_start> / <image_end> 标记图像片段的边界；
• 整个序列（文本 token 和图像 token 交错）用完全相同的自回归交叉熵损失训练。

这就是 Chameleon 「优雅」的地方——训练代码里根本不需要区分模态，就是一个词表 73,728 的普通 LM。但优雅的代价我们会在第 7 节看到。

4. 图像表示路线三：直接喂像素（Fuyu 式）与三条路线对比

还有第三条路：干脆不要视觉编码器。

Adept 的 Fuyu-8B 提出了一个极简主张：既然 ViT 的第一层不过是「把 patch 展平后过一个线性层」，那为什么还要一个单独预训练的、把整个图像重新编码一遍的视觉塔？直接把这个线性层接到语言模型自己身上就好了。

# Fuyu 式：没有视觉编码器，只有一个线性层，直接进 LM
class FuyuPatchInput(nn.Module):
    def __init__(self, patch=30, in_ch=3, d_model=4096):
        super().__init__()
        # 直接投影到 LM 的隐藏维度，而不是某个视觉塔的维度
        self.proj = nn.Linear(patch * patch * in_ch, d_model)
        self.newline = nn.Parameter(torch.zeros(d_model))   # 行结束标记

    def forward(self, img):                # img: (3, H, W)，任意 H、W
        p = 30
        # 切成 (h_grid, w_grid) 个 patch，注意不需要 resize 到固定尺寸
        patches = img.unfold(1, p, p).unfold(2, p, p)       # (3, hg, wg, p, p)
        hg, wg = patches.shape[1], patches.shape[2]
        patches = patches.permute(1, 2, 0, 3, 4).reshape(hg, wg, -1)
        tokens = self.proj(patches)        # (hg, wg, 4096)
        # 每一行末尾插入一个 newline 嵌入，让 LM 知道二维布局
        rows = [torch.cat([tokens[i], self.newline[None]], dim=0) for i in range(hg)]
        return torch.cat(rows, dim=0)      # (hg * (wg+1), 4096)

代价也很明确：你放弃了视觉预训练。CLIP/SigLIP 的编码器是在几十亿图文对上专门训过的，已经把「什么是猫、什么是文字、什么是边缘」这些视觉概念内化了。Fuyu 要求 LM 从原始像素开始，自己在多模态训练中把这些全部重新学一遍——这需要多得多的多模态数据，也是为什么这条路线在开源社区没有成为主流。

4.1 三条路线对比

5. 对比学习：CLIP 与 SigLIP

上一节讲的是「图像怎么切成 token」，但还有一个更重要的问题没回答：这个视觉编码器的权重从哪来？随机初始化的 ViT 输出的是垃圾。你需要一个预训练目标，让编码器学会「看懂」图像。

5.1 CLIP 的问题设定

CLIP（Contrastive Language-Image Pretraining）解决的正是这个问题。Percy 讲的背景（context）是：

• 当时的计算机视觉模型都是在人工标注的图像上训练的——ImageNet 是 120 万张图，每张一个人工标签，标注成本极高，类别数被锁死在 1000。
• 问题是：能不能利用数量远远更多的（图像, 说明文字）对？互联网上每张图旁边几乎都有 alt text、标题、周围段落。这些「标注」是免费的、无限量的，代价是噪声大。

5.2 方法：在 batch 里认出配对项

Percy 用四句话概括了方法：

1. 取一批 (图像, 文本) 样本（例如 32768 对）；
2. 分别编码每张图和每段文本；
3. 对每张图，相比其他所有文本，更偏好它配对的那段文本；
4. 对每段文本，相比其他所有图，更偏好它配对的那张图。

5.3 InfoNCE 损失的完整公式

设 batch 里有 $N$ 对样本。图像编码器 $f$、文本编码器 $g$，各自后接一个线性投影到共享的 $d$ 维空间，然后 $\ell_2$ 归一化：

归一化之后，内积 $u_i^\top v_j$ 就是余弦相似度，取值范围 $[-1, 1]$。相似度矩阵为

其中 $\tau > 0$ 是温度（temperature）。损失是行方向和列方向两个交叉熵的平均：

第一项是「给定图 $i$，在 $N$ 段文本里选出正确的那段」；第二项是「给定文本 $i$，在 $N$ 张图里选出正确的那张」。这就是 InfoNCE 损失的对称双向版本。

import torch, torch.nn.functional as F

def clip_loss(img_emb, txt_emb, logit_scale):
    """img_emb, txt_emb: (N, d) 未归一化；logit_scale: 标量 = exp(t)"""
    u = F.normalize(img_emb, dim=-1)             # (N, d)
    v = F.normalize(txt_emb, dim=-1)             # (N, d)

    logits = logit_scale * u @ v.t()             # (N, N)  = 相似度 / tau
    labels = torch.arange(len(u), device=u.device)   # 对角线是正样本

    loss_i2t = F.cross_entropy(logits, labels)       # 每行 softmax：图 -> 文
    loss_t2i = F.cross_entropy(logits.t(), labels)   # 每列 softmax：文 -> 图
    return (loss_i2t + loss_t2i) / 2

# 温度以 log 形式作为可学习参数，并 clamp 防止爆炸
logit_scale = torch.nn.Parameter(torch.log(torch.tensor(1 / 0.07)))
scale = logit_scale.exp().clamp(max=100.0)

5.4 数据与预处理

Percy 讲的 CLIP 数据构造流程：

• 构造 50 万个查询词（来自维基百科高频词、bi-gram、词条名等）；
• 对每个查询，搜集约 2 万对（图像, 文本）；
• 最终训练集：4 亿对图文（WIT，WebImageText）；
• 数据集没有公开。

最后一点在当时是社区的痛点。复现工作是 OpenCLIP，使用 LAION-5B 数据集。这里有一个值得玩味的循环：LAION-5B 本身是用 CLIP 做过滤的——从 Common Crawl 抓出图文对后，用 OpenAI 的 CLIP 算图文相似度，只保留分数高于阈值的。所以「开源复现」在数据层面仍然依赖闭源模型，这是 Lecture 13–14 讲数据时提到的模型-数据循环依赖在多模态领域的翻版。

预处理细节（第 2.4 节已详细讨论）：任意 $W\times H$ → 双三次插值使短边 = 336 → 中心裁剪到 336×336。

5.5 编码器配置

注意一个不对称：视觉塔（3 亿参数）比文本塔（6300 万参数）大 5 倍。这是刻意的——CLIP 的产出物主要是视觉编码器，文本塔只是提供监督信号的「教练」，训完之后大多数下游用法（比如 LLaVA）只用视觉塔。

5.6 头条结果与关键消融

头条结果：在 ImageNet 上，零样本的 CLIP 超过了在 120 万张 ImageNet 图像上训练的 ResNet-50。

零样本分类的具体做法（对应上面配图的中、右两幅）：

@torch.no_grad()
def zero_shot_classify(model, image, class_names, templates=("a photo of a {}.",)):
    # 1) 把每个类别名填入提示模板，编码成「分类器权重」
    weights = []
    for name in class_names:                       # 例如 1000 个 ImageNet 类别
        texts = [t.format(name) for t in templates]    # prompt ensembling
        e = F.normalize(model.encode_text(texts), dim=-1)   # (T, d)
        weights.append(F.normalize(e.mean(0), dim=-1))      # 多模板取平均再归一化
    W = torch.stack(weights)                       # (C, d)  <- 这就是分类头，凭空造出来的

    # 2) 图像嵌入与所有类别向量算余弦相似度
    u = F.normalize(model.encode_image(image), dim=-1)      # (B, d)
    return (u @ W.t()).argmax(dim=-1)              # (B,)

关键消融：Percy 强调了一个对比实验。另一种自然的做法是直接从图像预测文本（即训练一个 image captioning 模型，用生成式损失）。

CLIP 小结（Percy 的三条）：

• 图像的编码捕捉的是由（含噪的）文本给出的语义——文本写什么，编码器就学什么；文本从不描述的东西（精确空间位置、小字），编码器就学不到。
• 设计决策是围绕图像分类选的，不是很细粒度的任务。
• 技术上：需要非常大的 batch size，且要在整个 batch 上做 softmax。

5.7 SigLIP：把 softmax 换成 sigmoid

最后一条正是 SigLIP 要解决的问题。

Percy 把两者的目标函数差异讲得很清楚：

• CLIP：多类分类——(文本, 图像) 对 vs (文本, 图像′) 对，对所有 图像′ 做归一化。
• SigLIP：二分类——给定 (文本, 图像)，问「它们配不配？」就这么简单。

其中 $\sigma(x) = 1/(1+e^{-x})$，$t$ 是可学习的温度倒数，$b$ 是可学习的偏置。

def siglip_loss(img_emb, txt_emb, t, b):
    """t: 可学习温度（正数）；b: 可学习偏置，通常初始化为 -10"""
    u = F.normalize(img_emb, dim=-1)
    v = F.normalize(txt_emb, dim=-1)
    logits = t * (u @ v.t()) + b                 # (N, N)
    # 对角线 +1（正样本），其余 -1（负样本）
    labels = 2 * torch.eye(len(u), device=u.device) - 1
    return -F.logsigmoid(labels * logits).sum() / len(u)

5.8 SigLIP 为什么快：batch size 与损失解耦

这是 SigLIP 最重要的工程收益。理解它需要回到 Lecture 7–8 的数据并行。

假设有 $D$ 张设备，每张持有 $N/D$ 个样本。

CLIP 需要什么：第 $i$ 行的 softmax 分母是 $\sum_{j=1}^{N}\exp(u_i^\top v_j)$——需要全部 $N$ 个文本嵌入。所以必须做一次 all_gather，把所有设备的 $u$ 和 $v$ 收集到每张卡上，构造完整的 $N\times N$ 矩阵。

• 通信量：每卡收发 $O(N d)$ 的嵌入。$N=32768$、$d=768$、bf16：$32768 \times 768 \times 2 \times 2 \approx 100$ MB 每步，还要反向再来一次。
• 显存：每卡都要存下 $N\times N$ 的 logits 矩阵：$32768^2 \times 2 \text{ bytes} = 2.1$ GB。这是硬墙——想把 batch 提到 $10^5$，矩阵就要 20 GB，单卡放不下。

SigLIP 需要什么：损失是逐对独立求和的，$\sum_{i}\sum_{j}$ 没有任何归一化耦合。因此可以分块计算：

# SigLIP 分块损失的核心思想（伪代码，单卡视角）
def siglip_chunked_loss(u_local, v_local, t, b, rank, world_size):
    loss = 0.0
    v = v_local                                       # (N/D, d)
    for step in range(world_size):
        # 第 0 步是自己的块，含正样本；之后都是纯负样本块
        is_diag_block = (step == 0)
        logits = t * (u_local @ v.t()) + b            # (N/D, N/D)  <- 小得多
        labels = (2 * torch.eye(len(u_local)) - 1) if is_diag_block \
                 else -torch.ones_like(logits)
        loss += -F.logsigmoid(labels * logits).sum()
        v = ring_shift(v)                             # 点对点传给右邻居
    return loss / len(u_local)

实测效率（Percy 给的数字）：

用1/8 的芯片数、更弱的单卡算力，训练时间还减半——总加速超过 16 倍。这不是模型变小了，而是通信和显存瓶颈被消除了。

batch size 的结论（Percy 的三条）：

• 损失函数与 batch size 解耦了；
• 在 16K 以下的 batch size 上，SigLIP 优于 CLIP（因为 CLIP 在小 batch 下负样本太少，信号弱；而 SigLIP 的逐对二分类不依赖负样本数量）；
• 作者把 batch 一路推到 100 万，但发现 32K 就够了——收益在 32K 之后基本饱和。

5.9 SigLIP 的数据：WebLI

SigLIP 使用的是 WebLI（Web Language-Image）数据集，Percy 列的要点：

• 规模：数十亿量级的（图像, 文本）对；
• 来源：从互联网抓取；
• 用自动 OCR 从图像中提取文字——这是与 CLIP 数据的重要区别。除了 alt text，还把图片里面的文字提取出来作为额外监督，显著提升了模型对文档、招牌、图表的理解能力；
• 过滤：只保留质量最高的 10%；
• 覆盖 100 种语言（CLIP 基本只有英语）。

「保留最高质量的 10%」这个比例值得注意——和 Lecture 13–14 讲文本数据过滤时的结论一致：激进过滤几乎总是划算的，因为在数据量不是瓶颈的情况下，质量的边际收益远大于数量。

6. 把视觉编码接进语言模型

有了 CLIP/SigLIP 这样的视觉编码器，还剩最后一步：怎么让语言模型用上这些向量？视觉编码器输出的是 $\R^{1024}$ 的向量，语言模型的嵌入空间是 $\R^{4096}$ 的、且有它自己的语义结构。这两个空间之间需要一座桥。

历史上有三种融合（fusion）方式：

Percy 在课上按时间顺序讲了第一类的演进：LLaVA → LLaVA-OneVision → Qwen-VL → Qwen2-VL → Qwen3-VL，最后讲 Chameleon 的第三类。我们跟着这条线走。

6.1 LLaVA：最简配方

LLaVA（Large Language and Vision Assistant）的贡献不在架构——它的架构简单到近乎朴素——而在于证明了一个极简配方就能得到不错的视觉助手，且指令数据可以由 GPT-4 合成。

• 视觉编码器：CLIP（ViT-L/14）
• 文本解码器：Vicuna（LLaMA 在 ShareGPT 对话上微调的产物）
• 连接器：一个线性投影矩阵 $W$

class LLaVA(nn.Module):
    def __init__(self, vision_tower, llm, d_v=1024, d_l=4096):
        super().__init__()
        self.vision = vision_tower          # CLIP ViT-L/14，冻结
        self.W = nn.Linear(d_v, d_l)        # 唯一的「多模态」参数：1024 x 4096 ≈ 4.2M
        self.llm = llm                      # Vicuna-7B/13B

    def forward(self, image, input_ids, image_pos):
        # 1) 编码图像：取 patch 特征（去掉 CLS），不是池化后的单向量
        z_v = self.vision(image)[:, 1:, :]          # (B, 576, 1024)
        h_v = self.W(z_v)                           # (B, 576, 4096)  「伪文本 token」

        # 2) 文本嵌入
        h_t = self.llm.get_input_embeddings()(input_ids)   # (B, T, 4096)

        # 3) 把 h_v 插到 <image> 占位符的位置上，拼成一条序列
        h = splice(h_t, h_v, at=image_pos)          # (B, T + 576, 4096)

        # 4) 之后就是完全标准的自回归语言模型，损失只算在回答 token 上
        return self.llm(inputs_embeds=h)

数据：用 GPT-4 造视觉指令

LLaVA 真正的创新在数据。当时没有「视觉对话」的训练数据，人工标注太贵。LLaVA 的做法是纯文本的 GPT-4 蒸馏：

1. MS COCO 的图像已经有人工标注的边界框和 Mechanical Turk 写的说明文字；
2. 把这些文字描述和检测到的物体列表（不是图像本身！）喂给 GPT-4，让它生成问题或多轮对话；
3. 把生成的对话与原始图像配对，就得到了 (图像, 指令, 回答) 三元组；
4. 共 15.8 万条样本。

训练：两阶段配方

Percy 给出的两阶段配方是后来所有 VLM 的模板：

6.2 LLaVA-OneVision：分辨率、多图与视频

LLaVA-OneVision 是 LLaVA 系列的最新版（在 LLaVA-1.5、LLaVA-NeXT 之后），目标是用一个模型同时处理单图、多图和视频。

AnyRes：分辨率问题的解法

Percy 把动机说得很直接：

• 保持高分辨率很重要（例如为了 OCR）；
• CLIP 把图缩放并裁剪到 336×336，丢失了信息（第 2.4 节详细分析过）；
• 解法：AnyRes，在 LLaVA-1.5 中引入。

AnyRes 的做法是：

1. 把图像切成 $a \times b$ 块，每块的尺寸恰好匹配视觉编码器的原生分辨率（336×336）；
2. 每块独立过一次视觉编码器；
3. 把所有块的特征拼接起来；
4. 如果 token 太多（原图分辨率过高），就用双线性插值把特征图降采样。

三种输入类型的 token 预算分配

Percy 强调了一个漂亮的设计原则：目标是让所有模态产生大致相同的序列长度。

数据与训练：质量优先，由易到难

Percy 用两句话概括了 LLaVA-OneVision 的方法论：数据的哲学是「质量胜过数量」，训练的哲学是「由易到难」。

模态间迁移：本讲最有价值的实证

Percy 展示了三组「任务迁移」的例子，这是 LLaVA-OneVision 论文最有说服力的部分——它证明能力可以在训练中未见过的模态组合上涌现。

LLaVA 系列小结（Percy 的三条）：

• 标准 VLM 模板：视觉编码器 + 投影器 + 语言模型。这个模板已经稳定下来了。
• 绝大部分工作量在数据整理，且高度依赖合成的、任务特定的数据。
• 开源：模型权重和数据都放出来了——这在 VLM 领域相当难得，后面的 Qwen3-VL 就没有公布多少数据细节。

7. Qwen-VL 三代：把模板推到 SOTA

如果说 LLaVA 定义了模板，那么 Qwen-VL 系列展示了把这个模板推到极致会得到什么。三代模型的演进路线非常清晰，每一代解决前一代的一个具体瓶颈。

7.1 Qwen-VL：交叉注意力 adapter 与三阶段训练

Qwen-VL 的架构：

• 视觉编码器：OpenCLIP 的 ViT-bigG（14×14 patch）——比 LLaVA 用的 ViT-L 大得多（约 19 亿参数）；
• Adapter：一层交叉注意力，融入 2D 位置编码，把任意数量的视觉特征映射到固定的 256 长度；
• 特殊 token：<img>、<box>、<ref>。

这里的 adapter 是第 6 节表格里的第二类融合方式（交叉注意力）的一个轻量版本，思想来自 Flamingo 的 Perceiver Resampler：

class CrossAttentionResampler(nn.Module):
    """把可变长度的视觉特征压缩成固定 256 个 token（Flamingo / Qwen-VL adapter 思路）。"""
    def __init__(self, n_query=256, d_model=4096, d_vision=1664, n_heads=32):
        super().__init__()
        # 256 个可学习的 query 向量 —— 这是「固定长度」的来源
        self.query = nn.Parameter(torch.randn(n_query, d_model) * 0.02)
        self.kv_proj = nn.Linear(d_vision, d_model)
        self.attn = nn.MultiheadAttention(d_model, n_heads, batch_first=True)

    def forward(self, vis_feat, pos_2d):        # vis_feat: (B, N, 1664)，N 随分辨率变化
        kv = self.kv_proj(vis_feat) + pos_2d    # (B, N, 4096)，加入 2D 位置编码
        q = self.query.unsqueeze(0).expand(vis_feat.size(0), -1, -1)   # (B, 256, 4096)
        out, _ = self.attn(q, kv, kv)           # (B, 256, 4096)  <- 与 N 无关！
        return out

三阶段训练

与 LLaVA 最大的区别：Qwen-VL 训练视觉编码器。LLaVA 全程冻结 ViT，因为它只有 15.8 万条指令数据；Qwen-VL 的 Stage 1 有十亿量级的图文对，足以在不破坏表示的前提下让 ViT 适应新任务（尤其是中文 OCR，这是原版 CLIP 完全不会的）。

用户：图中的狗在哪里？
模型：<ref>狗</ref><box>(342,551),(658,891)</box>

7.2 Qwen2-VL：动态分辨率与 MRoPE

Qwen2-VL 的核心创新是 Percy 强调的那个词：dynamic resolution（动态分辨率）。

Percy 给的具体数字：

• 视觉编码器是更大的 ViT（6.75 亿参数）；
• 每个 224×224 的区域用 ViT/14 编码，然后每 2×2 个 patch 压缩成 1 个 ⇒ 66 个 token；
• 视频：每秒采样 2 帧，最多 16384 个 token。

MRoPE：多模态旋转位置编码

def mrope_position_ids(seq_spec):
    """为混合序列生成 (t, h, w) 三维位置索引。"""
    ids, t_offset = [], 0
    for item in seq_spec:
        if item.kind == "text":
            for _ in range(item.length):                 # 文本：三轴同步递增
                ids.append((t_offset, t_offset, t_offset)); t_offset += 1
        elif item.kind == "image":
            for h in range(item.grid_h):                 # 图像：t 固定，h/w 是网格坐标
                for w in range(item.grid_w):
                    ids.append((t_offset, t_offset + h, t_offset + w))
            t_offset += max(item.grid_h, item.grid_w)     # 图像之后时间轴跳过整块
        elif item.kind == "video":
            for f in range(item.n_frames):               # 视频：t 随帧递增
                for h in range(item.grid_h):
                    for w in range(item.grid_w):
                        ids.append((t_offset + f, t_offset + h, t_offset + w))
            t_offset += item.n_frames
    return ids   # 每个元素是三元组，RoPE 的三段维度分别用其中一个分量

其余配置：语言模型用 Qwen2 初始化，视觉编码器用 DFN（Data Filtering Networks）的权重初始化。训练仍是三阶段，与 Qwen-VL 类似：(1) 只训视觉编码器；(2) 训全部参数；(3) 在指令跟随数据上训语言模型。

7.3 Qwen3-VL：规模化与细节打磨

Qwen3-VL 代表了当前的前沿状态。

Qwen3-VL 小结（Percy 的四条，很坦率）：

• SOTA 性能；
• 大量数据工作，但没有多少细节——这是当前前沿模型论文的通病，最重要的部分恰恰是最不透明的；
• 微小但可能重要的架构改进（Interleaved MRoPE、DeepStack、$\sqrt{L}$ 损失）；
• 扩大规模。

8. 走向 omni：Chameleon 与早融合

到目前为止，第 6–7 节讲的所有 VLM 都有同一个结构性缺陷。Percy 说得很直接：

目前为止：VLM 用 CLIP 或 SigLIP 编码图像，注入 LM。
缺点：它们不能生成图像（要生成得靠扩散模型）。

这是第 3 节讨论过的问题：连续向量没法自回归采样。所以 GPT-4V 这类模型「画图」时，实际上是写一段提示词，调用一个外部的扩散模型——两个模型之间只通过一串文本通信，图像理解和图像生成完全不共享表示。你没法让它「把这张图里的猫改成狗，其他一模一样」，因为提示词这个瓶颈丢掉了原图的所有细节。

8.1 Chameleon：把一切都变成离散 token

Chameleon 的主张是：把所有东西都映射成离散 token。好处是可以用完全统一的方式分析和生成图像。

8.2 视觉 tokenizer 的角色转变

Percy 点出了关键差异：编码器必须映射到离散 token，这样我们才能生成它们。

这就把我们带回了第 3 节的 VQ-VAE。Chameleon 的配置（引用自 Make-A-Scene 的 tokenizer）：

• 512×512 的图像编码成 1024 个 token；
• 码本大小 8192；
• 为文本训练了一个新的 BPE tokenizer，与图像 token 合并成统一词表。

8.3 训练：两阶段与数据配比

• Stage 1（占 80%）：大规模无监督数据 —— 2.9T 纯文本 token、1.5T 文本/图像 token、400B 文本/图像交错 token；
• Stage 2（占 20%）：50% 是 Stage 1 的数据，50% 是高质量数据。

注意这个配比：纯文本 token（2.9T）比图文 token（1.5T + 0.4T）还多。图像并没有「取代」文本，而是作为补充。这与第 1.3 节说的 modality tax 一致——保住语言能力需要大量纯文本数据兜底。

8.4 训练稳定性：本节最有工程价值的部分

Percy 专门讲了 Chameleon 遇到的训练不稳定问题，这是把不同模态混在一个词表里的直接后果：

文本 token 熵低，图像 token 熵高，导致 norm 增长、logit 漂移（logit drift）问题。
修复：QK norm、z-loss 正则化。

修复方案一：QK norm。在计算注意力分数之前，对 query 和 key 各做一次 LayerNorm（或 RMSNorm）：

class AttentionWithQKNorm(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.n_heads, self.d_head = n_heads, d_model // n_heads
        self.qkv = nn.Linear(d_model, 3 * d_model, bias=False)
        self.o = nn.Linear(d_model, d_model, bias=False)
        # 关键：对 q 和 k 分别归一化，切断 norm 增长 -> 注意力饱和 的链条
        self.q_norm = nn.RMSNorm(self.d_head)
        self.k_norm = nn.RMSNorm(self.d_head)

    def forward(self, x):                       # x: (B, T, D)
        q, k, v = self.qkv(x).chunk(3, dim=-1)
        q, k, v = (t.view(*x.shape[:2], self.n_heads, self.d_head).transpose(1, 2)
                   for t in (q, k, v))
        q, k = self.q_norm(q), self.k_norm(k)   # <== QK norm
        out = F.scaled_dot_product_attention(q, k, v, is_causal=True)
        return self.o(out.transpose(1, 2).flatten(2))

效果：归一化之后 $\|q\| = \|k\| = \sqrt{d_\text{head}}$ 是常数，注意力 logit 的量级被硬性钳制，与激活的 norm 完全解耦。无论隐状态怎么增长，注意力都不会饱和。

修复方案二：z-loss。直接惩罚输出层 softmax 的配分函数（partition function）的对数：

def loss_with_z_loss(logits, targets, lambda_z=1e-5):
    """logits: (B, T, V)"""
    logZ = torch.logsumexp(logits, dim=-1)              # (B, T)
    ce = F.cross_entropy(logits.flatten(0, 1), targets.flatten())
    z_loss = lambda_z * logZ.pow(2).mean()              # 把 logZ 拉向 0
    return ce + z_loss

Chameleon 小结（Percy 的三条）：

• 优雅——就是对离散 token 做自回归建模，没有任何特殊处理；
• 性能不如 VLM——离散化丢信息，想想 OCR；
• 多模态混合训练很棘手。

9. 生成、音频、视频，以及数据与评测

9.1 图像生成的两条路线

Percy 在最后的总结里给出了他的判断，我们先把两条路线的对比摆出来。

目前统一「理解 + 生成」的尝试主要有三类：

1. 纯离散统一（Chameleon）：优雅但理解能力打折；
2. 双 tokenizer（如 Janus 系列）：理解走 CLIP 连续编码器，生成走 VQ 离散 tokenizer，两条路共享同一个 LM 主干。承认「理解和生成需要不同表示」这个事实，不强行统一；
3. LM + 扩散头（当前主流，也是 Percy 看好的）：LM 负责理解和规划，输出一组连续的条件向量，由一个扩散解码器渲染成图像。关键在于条件是连续高维向量而不是一段提示词文本，因此不存在文本瓶颈，可以传递精确的空间和身份信息。

9.2 音频与视频

Percy 在课上只是简要带过，但核心逻辑与图像完全平行：先解决 tokenization，其余照搬。

音频同样有三条路线，与第 2–4 节一一对应：

residual = z_e
tokens = []
for quantizer in self.quantizers:      # 例如 8 层
    q, idx, _ = quantizer(residual)
    tokens.append(idx)
    residual = residual - q            # 下一层只需编码「还差多少」
z_q = sum_of_all_quantized_parts

视频的核心矛盾在第 1.1 节已经点明：token 数极多但信息密度极低。主流做法：

• 降低时间采样率：Qwen2-VL 用 2 帧/秒，而不是原始的 24–30 帧/秒；
• 降低每帧分辨率：LLaVA-OneVision 给视频帧分配最低的分辨率预算；
• 时空联合压缩：把 2×2 的空间合并扩展成 2×2×2 的时空合并，利用帧间冗余；
• 显式时间戳 token：Qwen3-VL 的做法，让模型能精确回答「事件发生在第几秒」。

9.3 多模态训练数据与评测

把本讲提到的数据集汇总起来，可以看出多模态数据的完整谱系：

一个清晰的模式：预训练数据几乎全部闭源，指令数据往往开源。原因很现实——指令数据规模小、多为合成，公开的边际成本低；预训练数据涉及版权、成本高昂，且是最核心的竞争壁垒。这与 Lecture 13–14 讲文本数据时观察到的现象完全一致。

评测方面，主流多模态基准可以按能力维度分组（这正是本讲第 6.2 节说的「按能力清单组织数据」的镜像）：

9.4 Percy 对未来的判断

Percy 的总结部分给出了五条判断，逐条解读：

1. 「前沿模型被期待是多模态的（原生多模态、omni）」 —— 多模态已经从加分项变成了入场券。注意「原生（natively）」这个词：不是训完文本模型再贴一个视觉编码器，而是从预训练一开始就混合模态。
2. 「根本挑战是：如何编码非文本模态？」 —— 这是全讲的中心。架构问题基本解决了（Transformer + 投影器），表示问题还没有。
3. 「理解与生成可能要求不同的东西（语义 vs 更细粒度的细节）」 —— 这是对「统一表示」这一美好愿景的一记警钟，也是第 8 节的核心教训。
4. 「平衡图像 + 视频（信息密度更低）与文本，以保证训练稳定」 —— 数据配比不是按 token 数配，而是按信息量配。Qwen3-VL 的 $\sqrt{L}$ 归一化和 Chameleon 的 QK norm + z-loss 都是这个问题的技术表现。
5. 「连续编码器 + Transformer + 扩散模型做生成」 —— 这是 Percy 押注的技术栈。值得注意的是它不追求形式上的统一：理解用连续编码器（保语义、无量化损失），主干用 Transformer（复用整个生态），生成用扩散（质量最高）。工程上的务实压过了架构上的优雅。

10. 全课程回顾：17 讲串成一条线

这是最后一讲正课。回头看，这门课其实只讲了一件事：在给定的算力预算下，把尽可能多的有用信息压进一个模型里。

所有 17 讲都可以挂在三个词上：数据 × 算力 × 效率。

10.1 贯穿全课的四条主线

10.2 如果你要动手做一个多模态模型

把本讲的所有结论浓缩成一份可执行的配方：

1. 不要从头训视觉编码器。拿一个现成的 SigLIP / SigLIP-2。你没有几十亿图文对，也没有 32 块 TPU。
2. 不要从头训语言模型。拿一个 Qwen / Llama 基座。
3. 连接器用 2 层 MLP。不要一上来就用 Q-Former、Perceiver 或 DeepStack——先把简单版本跑通再说。
4. 严格执行两阶段训练：先冻结两侧只训投影器（对齐），再解冻 LM（指令微调）。跳过第一阶段大概率会灾难性遗忘。
5. 分辨率按任务定。通用问答：单块 384×384 就够。文档/OCR/GUI：必须上 AnyRes 或动态分辨率，否则再多数据也救不回来。
6. 混入 20–30% 纯文本数据，防止语言能力退化。
7. 如果混合模态训练发散：先加 QK norm，再加 z-loss（$\lambda_z = 10^{-5}$），再考虑按 $\sqrt{L}$ 归一化损失。
8. 把 80% 的时间花在数据上，不是架构上。这是本讲、也是这门课最重要的一条经验。

本讲小结

一页速查表

要点清单

• omni model = 任意模态输入（理解）+ 任意模态输出（生成）。今天大多数模型只做到了前一半。
• 图像的根本难点是信息密度低且无天然语义边界：33 万个像素值可能只值 8 个文本 token 的语义。
• 理解要语义，生成要细节——这两个目标在表示空间上互相拉扯，是「统一模型」至今未能落地的核心原因。
• CLIP 的设计决策是围绕图像分类做的，把它当 VLM 前端时就继承了它对细粒度任务不友好的取舍（336 中心裁剪）。
• 对比学习的 batch size 存在饱和点（约 32K），不是越大越好。
• LLaVA 证明了一个线性矩阵就能连接视觉与语言，复杂的重采样器不是必需的。
• LLaVA-OneVision 证明了能力可以跨模态组合泛化：单图 OCR + 多图关系推理 → GUI agent（训练集里没有 GUI 数据）。
• 让不同模态产生大致相同的 token 长度，既解决工程负载均衡，也是跨模态迁移的机制基础。
• Qwen-VL 三代的主线是从「压缩视觉信息」转向「保留视觉信息」——长上下文技术成熟后，压缩的代价变得不可接受。
• 多模态预训练数据几乎全部闭源，指令数据往往开源——数据是最后的护城河。
• 架构的优雅性不能抵消表示层的信息损失（Chameleon 的教训）。

延伸阅读

图像表示：从 ViT 到量化

• An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale (ViT, 2020) — 本讲第 2 节的基础。读它是为了看清「去掉所有视觉归纳偏置之后，纯 Transformer 在多大数据量上开始反超 CNN」这条曲线。
• Neural Discrete Representation Learning (VQ-VAE, 2017) — 直通估计和承诺损失的原始出处，第 3 节所有公式的来源。篇幅短，值得逐行读。
• Taming Transformers for High-Resolution Image Synthesis (VQ-GAN, 2020) — 说明为什么纯 $\ell_2$ 重建会糊，以及感知损失 + 对抗损失如何救回细节。
• Make-A-Scene (2022) — Chameleon 采用的图像 tokenizer 的直接来源，含人脸区域加权重建等实用技巧。

对比学习：视觉编码器怎么练出来

• Learning Transferable Visual Models From Natural Language Supervision (CLIP, 2021) — 必读。重点看 Figure 2（对比 vs 生成的效率曲线）和零样本迁移的那 27 个数据集，理解「用语言当监督信号」这个范式转换。
• Sigmoid Loss for Language Image Pre-Training (SigLIP, 2023) — 一个损失函数的小改动如何带来 16 倍的系统级加速。分块并行那一节是分布式训练设计的教科书案例。
• SigLIP-2 (2025) — Qwen3-VL 使用的视觉编码器，在多语言和细粒度定位上的改进。
• Reproducible scaling laws for contrastive language-image learning (OpenCLIP, 2022) — CLIP 的开源复现 + 对比学习的缩放定律，把 Lecture 9/11 的方法论应用到了多模态。
• Data Filtering Networks (DFN, 2023) — Qwen2-VL 视觉编码器的初始化来源；核心观点是「用一个专门训练的小网络来过滤预训练数据」，与 Lecture 14 的数据过滤直接呼应。

视觉-语言模型：怎么接进 LLM

• Visual Instruction Tuning (LLaVA, 2023) — 必读。用纯文本 GPT-4 + COCO 标注合成视觉指令数据的那一节，是「用现有模型撬动新能力」的经典范例。
• Improved Baselines with Visual Instruction Tuning (LLaVA-1.5, 2023) — AnyRes 的出处，以及一系列朴素但有效的改进（MLP 投影器、学术任务数据）。
• LLaVA-OneVision (2024) — 读它主要是为了那三组跨模态迁移的实证，这是本讲关于「多模态到底有没有额外收益」最扎实的证据。
• Flamingo (2022) — 交叉注意力融合路线的代表作，Perceiver Resampler 和 gated cross-attention 的出处。理解它才能明白 LLaVA 的「一个矩阵就够了」有多反直觉。
• Qwen-VL (2023) — 三阶段训练配方，以及用 <box> / <ref> 把坐标序列化成 token 的做法。
• Qwen2-VL (2024) — 原生动态分辨率与 MRoPE，本讲第 7.2 节的全部内容。
• Qwen3-VL (2025) — 当前的开源 SOTA。Interleaved MRoPE 和 $\sqrt{L}$ 归一化损失是两个小而实用的技巧。
• DeepStack (2024) — 把视觉特征注入 LM 多个层而非仅输入端，几乎零成本地缓解深层信息稀释。

走向 omni：统一理解与生成

• Chameleon: Mixed-Modal Early-Fusion Foundation Models (2024) — 必读，尤其是训练稳定性那一节。它是「多模态混训为什么会崩」这个问题目前最详细的公开分析，QK norm 与 z-loss 的实证在这里。
• Fuyu-8B (2023) — 第 4 节的原始出处。极简主义的另一个极端：完全没有视觉编码器。
• High-Resolution Image Synthesis with Latent Diffusion Models (Stable Diffusion, 2021) — Percy 押注的「扩散做生成」那一环的基础，也是理解为什么扩散在图像上赢过自回归的入口。