VLM / Multimodal 面试 Cheat Sheet

§0 TL;DR Cheat Sheet

1. 视觉 encoder = ViT 主导：Dosovitskiy et al. 2021 (ICLR) 把图像切 $P\times P$ patch（一般 $P=14$ 或 $16$）做线性投影 + 可学习 positional embedding + 可选 [CLS] token，输入 Transformer encoder。CLIP / SigLIP / LLaVA 的视觉端都是 ViT 变体。
2. CLIP 对称 InfoNCE（必推）：Radford et al. 2021 (ICML) 让 image embedding $\mathbf{u}_i$ 和 text embedding $\mathbf{v}_i$ 在共享空间里做对比学习，loss 为 行 softmax + 列 softmax 平均：$\mathcal{L} = \tfrac{1}{2}(\mathcal{L}_{i\to t} + \mathcal{L}_{t\to i})$。温度 $\tau$ 可学习（log-parameterize，clip 到 $[0,100]$）。
3. SigLIP 用 sigmoid 替 softmax：Zhai et al. 2023 (ICCV) 把 N×N 相似度矩阵的每一项独立做 binary CE，摆脱 batch-wise softmax 归一化，因此对 batch size 不再线性敏感，单机能用 32k+ batch 训；引入 learnable bias $b$ 修正初期 negative dominance。SigLIP-2 (Google 2025) 加入 caption + self-distillation + dense local objectives 并扩展多语言。
4. LLaVA = projector + 2-stage train：Liu et al. 2023 (NeurIPS) 用一个 轻量 MLP projector 把 frozen CLIP 视觉特征投到 LLM token 空间。Stage 1 只训 projector 做 feature alignment（caption 数据），Stage 2 解冻 LLM 做 visual instruction tuning（GPT-4 生成的 158K instructions）。
5. Q-Former vs Projector 是 BLIP-2 的核心 trade-off：Li et al. 2023 (ICML) 用 32 个 learnable query token 在 frozen image encoder 上做 cross-attention，把任意分辨率/数量的 patch 压成固定 32 token——计算预算稳定但信息有损 + 训练复杂。LLaVA 的 MLP 简单但 token 数随分辨率二次增长。
6. Flamingo / Llama-3.2-Vision = gated cross-attn：Alayrac et al. 2022 (NeurIPS) 用 Perceiver Resampler（64 latent query）把 visual feature 压成固定数 token，再在 LLM 每隔几层插入 gated cross-attention 层（$\tanh$ 门控初始化为 0，保留 frozen LLM 的 text-only 能力）。
7. Qwen2-VL 的 M-RoPE 必考：Wang et al. 2024 把 RoPE 沿 head_dim 分成 6 段，按 axis 序列 $(t, h, w, t, h, w)$ 分配 (t / h / w 三组位置 id)；典型配置 mrope_section=[16,24,24]（单位是半 head_dim 的对数，$\sum \times 2 = $ head_dim=128，全部 128 维都旋转）。这样每个 token 同时携带 (t, h, w) 三维位置而不需要扁平化。配合 native dynamic resolution（不再 padding 到固定 224×224）。
8. 训练三段式 + 偏好优化：(1) alignment 训 projector / Q-Former；(2) visual instruction tune 解冻部分 LLM；(3) preference（LLaVA-RLHF, RLAIF-V, VLM-R1, DPO/PPO）治理幻觉、对齐 long-tail。VLM-R1 (2025) 用 GRPO + verifiable reward 把推理能力迁到视觉-语言任务。

§1 直觉：VLM 在做什么？

把一张图看作 "另一种语言"。VLM 的工作可以拆成三件事：

• 视觉 tokenizer：把像素压成离散或连续的 token 序列（ViT patch → embedding）
• 跨模态对齐：让相同语义的 image / text 在同一空间靠近——这是 CLIP / SigLIP 干的事，本质是 学一个共享 embedding space
• 跨模态生成：让 LLM 在 prompt 里"看见"图片——LLaVA / Qwen-VL / Flamingo 干的事，本质是 把 image token 作为前缀塞进 LLM 的 context

• 早期融合（dual-encoder + contrastive）：CLIP / SigLIP，没有 cross-modal attention，只在 embedding 空间靠近 / 远离
• Projector 融合（visual tokens → LLM context）：LLaVA / Qwen-VL，把 image embedding 投到 LLM 的 token 空间，作为输入 token 拼接，自回归解码
• Cross-attn 融合（image as KV, text as Q）：Flamingo / BLIP-2 / Llama-3.2-V，新增 cross-attention 层，LLM 的 text token 主动 query 视觉 KV

对比 Q/K/V 视角：projector 范式下 image 是 LLM 输入序列的一部分（self-attention 内全交互）；cross-attn 范式下 image 永远是 KV，只被 query——这导致 inference 时 KV cache 处理方式不同。

§2 ViT：把图像变 token 序列

2.1　Patch tokenize

输入图像 $\mathbf{x} \in \mathbb{R}^{H \times W \times C}$，切成 $N = HW/P^2$ 个 $P\times P$ patch，每个 patch flatten 成 $P^2 C$ 维向量，过线性层投到 $D$ 维：

$$\mathbf{z}_0 = [\mathbf{x}_\text{class};\ \mathbf{x}^1_p \mathbf{E};\ \mathbf{x}^2_p \mathbf{E};\ \dots;\ \mathbf{x}^N_p \mathbf{E}] + \mathbf{E}_\text{pos}$$

• $\mathbf{E} \in \mathbb{R}^{P^2 C \times D}$ 是 patch embedding 矩阵（等价于 stride=$P$, kernel=$P$ 的 Conv2D）
• $\mathbf{x}_\text{class} \in \mathbb{R}^D$ 是 learnable [CLS] token，用于聚合全局信息（分类时取 $\mathbf{z}_L^0$）
• $\mathbf{E}_\text{pos} \in \mathbb{R}^{(N+1) \times D}$ 是 learnable 1D positional embedding——原版 ViT 用 1D learned，没有用 2D sinusoidal（论文 Appendix D.4 报告 1D learned 与 2D sinusoidal 性能差异在误差范围内）

2.2　Transformer 主干

$$\mathbf{z}'_\ell = \text{MHA}(\text{LN}(\mathbf{z}_{\ell-1})) + \mathbf{z}_{\ell-1}, \quad \mathbf{z}_\ell = \text{MLP}(\text{LN}(\mathbf{z}'_\ell)) + \mathbf{z}'_\ell$$

Pre-norm（LN 在 sub-layer 输入端），MLP 用 GELU。注意 ViT 原版的 patch 数固定（$224/16=14 \Rightarrow N=196$），positional embedding 表大小固定——这是 dynamic resolution 要解决的痛点（§10）。

2.3　ViT 规格梳理

2.4　Code: ViT patch embed + 主干（核心 60 行）

import torch
import torch.nn as nn
import torch.nn.functional as F

class PatchEmbed(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
        super().__init__()
        self.img_size, self.patch_size = img_size, patch_size
        self.num_patches = (img_size // patch_size) ** 2
        # 用 stride=P, kernel=P 的 Conv2d 等价于线性投影
        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)

    def forward(self, x):                                   # x: [B, C, H, W]
        x = self.proj(x)                                    # [B, D, H/P, W/P]
        x = x.flatten(2).transpose(1, 2)                    # [B, N, D]
        return x

class ViTBlock(nn.Module):
    def __init__(self, dim, num_heads, mlp_ratio=4.0, 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)
        hidden = int(dim * mlp_ratio)
        self.mlp = nn.Sequential(
            nn.Linear(dim, hidden), nn.GELU(), nn.Dropout(dropout),
            nn.Linear(hidden, dim), nn.Dropout(dropout),
        )

    def forward(self, x):
        h = self.ln1(x)
        a, _ = self.attn(h, h, h, need_weights=False)       # self-attention
        x = x + a
        x = x + self.mlp(self.ln2(x))
        return x

class ViT(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768,
                 depth=12, num_heads=12, num_classes=1000, use_cls=True):
        super().__init__()
        self.patch_embed = PatchEmbed(img_size, patch_size, in_chans, embed_dim)
        N = self.patch_embed.num_patches
        self.use_cls = use_cls
        if use_cls:
            self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
            self.pos_embed = nn.Parameter(torch.zeros(1, N + 1, embed_dim))
        else:
            self.pos_embed = nn.Parameter(torch.zeros(1, N, embed_dim))
        nn.init.trunc_normal_(self.pos_embed, std=0.02)
        if use_cls:
            nn.init.trunc_normal_(self.cls_token, std=0.02)
        self.blocks = nn.ModuleList([ViTBlock(embed_dim, num_heads) for _ in range(depth)])
        self.ln = nn.LayerNorm(embed_dim)
        self.head = nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity()

    def forward(self, x):
        B = x.size(0)
        x = self.patch_embed(x)                             # [B, N, D]
        if self.use_cls:
            cls = self.cls_token.expand(B, -1, -1)
            x = torch.cat([cls, x], dim=1)                  # [B, N+1, D]
        x = x + self.pos_embed                              # broadcast over batch
        for blk in self.blocks:
            x = blk(x)
        x = self.ln(x)
        feat = x[:, 0] if self.use_cls else x.mean(dim=1)   # CLS or mean-pool
        return self.head(feat)

§3 CLIP：对称 InfoNCE（必推导）

3.1　形式化目标

CLIP（Radford et al. 2021, ICML）训练时一个 batch 有 $N$ 个 (image, text) pair。两个 encoder $f_\theta$（image）、$g_\phi$（text）分别产出 $\ell_2$-normalized embedding：

$$\mathbf{u}_i = \frac{f_\theta(I_i)}{\|f_\theta(I_i)\|_2}, \quad \mathbf{v}_j = \frac{g_\phi(T_j)}{\|g_\phi(T_j)\|_2}, \quad \mathbf{u}_i, \mathbf{v}_j \in S^{D-1}$$

定义相似度矩阵 $\mathbf{S} \in \mathbb{R}^{N\times N}$（"logit"）：

$$S_{ij} = \frac{\mathbf{u}_i^\top \mathbf{v}_j}{\tau}$$

其中 $\tau > 0$ 是可学习温度（实际工程化为 logit_scale = log(1/τ)，反向传播更稳定，clamp 在 $[\log 1, \log 100]$）。

3.2　对称 InfoNCE Loss（行 + 列 softmax 平均）

Image → Text 方向（对每个 image $i$，正样本是 $T_i$，负样本是 $\{T_j\}_{j\neq i}$）：

$$\mathcal{L}_{i\to t} = -\frac{1}{N}\sum_{i=1}^{N} \log \frac{\exp(S_{ii})}{\sum_{j=1}^{N} \exp(S_{ij})}$$

Text → Image 方向：

$$\mathcal{L}_{t\to i} = -\frac{1}{N}\sum_{j=1}^{N} \log \frac{\exp(S_{jj})}{\sum_{i=1}^{N} \exp(S_{ij})}$$

对称总 loss：

$$\boxed{\;\mathcal{L}_\text{CLIP} = \frac{1}{2}\left(\mathcal{L}_{i\to t} + \mathcal{L}_{t\to i}\right)\;}$$

3.3　梯度推导（为什么对称很重要）

固定 $\tau=1$，对 $\mathcal{L}_{i\to t}$ 中第 $i$ 行的 logits $\mathbf{s}_i = (S_{i1},\dots,S_{iN})^\top$ 做 softmax，记 $p_{ij} = \text{softmax}(\mathbf{s}_i)_j$。则：

$$\frac{\partial \mathcal{L}_{i\to t}}{\partial S_{ij}} = \frac{1}{N}\left(p_{ij} - \mathbb{1}[j=i]\right)$$

• $j=i$（正样本）：梯度 $\propto p_{ii} - 1 < 0$，拉近 $\mathbf{u}_i, \mathbf{v}_i$
• $j \neq i$（负样本）：梯度 $\propto p_{ij} > 0$，推远 $\mathbf{u}_i, \mathbf{v}_j$

如果只用单向 $\mathcal{L}_{i\to t}$，$\mathbf{v}_j$ 收到的梯度来自所有 $\mathbf{u}_i$，但不能反过来约束 $\mathbf{u}_i$ 被其他 $\mathbf{v}_k$ 检索时的行为。对称化补齐了 text→image 检索方向的约束，避免 embedding space 出现"单向坍塌"（image 端集中但 text 端松散）。

3.4　Temperature 的作用

$$\mathcal{L}_{i\to t} = -\frac{1}{N}\sum_i \log\frac{\exp(\mathbf{u}_i^\top \mathbf{v}_i / \tau)}{\sum_j \exp(\mathbf{u}_i^\top \mathbf{v}_j / \tau)}$$

• $\tau \to 0^+$（很小）：softmax 接近 one-hot，只关心 hardest negative（最像但不对的那个 text）；梯度被一两个负样本主导，训练不稳
• $\tau \to \infty$（很大）：softmax 均匀，正负样本几乎不可分，loss 接近 $\log N$ 常数，几乎无梯度
• OpenAI CLIP 学到的稳态：$\tau \approx 0.01$（logit_scale ≈ log(100)），并 clamp 上界防止崩

3.5　Code: CLIP 对称 InfoNCE（核心 50 行）

import torch
import torch.nn as nn
import torch.nn.functional as F

class CLIPLoss(nn.Module):
    """Symmetric InfoNCE used by OpenAI CLIP (Radford et al. 2021)."""
    def __init__(self, init_tau=0.07, max_logit_scale=4.6052):
        super().__init__()
        # 等价于 logit_scale = log(1/τ); 初始 ~ log(1/0.07) ≈ 2.659
        self.logit_scale = nn.Parameter(torch.tensor(1.0 / init_tau).log())
        self.max_logit_scale = max_logit_scale            # log(100), clamp 防爆炸

    def forward(self, image_feats, text_feats):
        """
        image_feats: [N, D]   (unnormalized)
        text_feats:  [N, D]
        """
        # L2 normalize 到单位球面
        u = F.normalize(image_feats, dim=-1)              # [N, D]
        v = F.normalize(text_feats, dim=-1)               # [N, D]

        # clamp logit_scale 上界 (训练后期会涨到 ~log(100))
        logit_scale = self.logit_scale.clamp(max=self.max_logit_scale).exp()

        # 相似度矩阵
        logits_i2t = logit_scale * u @ v.t()              # [N, N]
        logits_t2i = logits_i2t.t()                       # [N, N]

        # 对角线是正样本对
        N = u.size(0)
        labels = torch.arange(N, device=u.device)

        loss_i2t = F.cross_entropy(logits_i2t, labels)    # 行 softmax NLL
        loss_t2i = F.cross_entropy(logits_t2i, labels)    # 列 softmax NLL

        return 0.5 * (loss_i2t + loss_t2i), logit_scale

# 用法示例（DDP 下需 all-gather 把所有 GPU 的 feats 拼起来再算）
if __name__ == "__main__":
    N, D = 8, 512
    img_feats = torch.randn(N, D)
    txt_feats = torch.randn(N, D)
    criterion = CLIPLoss()
    loss, scale = criterion(img_feats, txt_feats)
    print(f"loss={loss.item():.4f}  logit_scale={scale.item():.2f}")

3.6　CLIP 训练数据 & 规模

• WIT (WebImageText)：400M (image, text) pair，从互联网爬取（未开源）
• LAION-400M / LAION-2B：OpenCLIP 用的开源替代，2022–2023 训了一系列规模
• DataComp：Gadre et al. 2023 (NeurIPS) 提出系统性 data filtering benchmark，数据质量 > 数据规模
• 模型规模：OpenAI 最大 ViT-L/14；OpenCLIP 训到 ViT-bigG/14 (LAION-2B)，零样本 ImageNet ~80%+

3.7　CLIP 的失败模式

• OCR / 文字理解弱：训练 caption 一般不描述图中文字，所以 CLIP 对图中文本几乎"瞎"
• 细粒度计数失败：5 只鸟 vs 6 只鸟在 CLIP embedding 几乎无法区分（"counting problem"）
• 空间关系弱："cat on top of dog" vs "dog on top of cat" 区分困难（POPE / Winoground benchmark 量化了这一点）
• bag-of-words 倾向：Yuksekgonul et al. 2023 (ICLR) 证明 CLIP 对 caption 词序几乎不敏感

§4 SigLIP：sigmoid 替 softmax，batch 缩放重写

4.1　Motivation

CLIP 的 softmax 归一化把所有 N×N 个相似度耦合：每个正样本的梯度依赖于整行的负样本 logsumexp。这导致：

• batch size 极敏感：N 翻倍，loss landscape 显著变化；小 batch 几乎学不动
• DDP 通信昂贵：必须 all-gather embedding（O(N·D) 字节），通信瓶颈
• 数值不稳：极大 N 下 softmax 容易溢出

Zhai et al. 2023 (ICCV) 提出 SigLIP：把 N×N 矩阵的每一项独立做 binary classification。

4.2　Sigmoid Loss 推导

定义相似度 $S_{ij} = t \cdot \mathbf{u}_i^\top \mathbf{v}_j + b$，其中 $t = e^{t'}$ 是 learnable scale（与 CLIP 的 $1/\tau$ 同），$b$ 是 learnable bias（初始化负值，如 $b_0 = -10$，避免训练初期全部预测正）。

label $y_{ij} = +1$ 若 $i=j$，$-1$ 否则。每项做 binary logistic regression：

$$\mathcal{L}_\text{SigLIP} = -\frac{1}{N}\sum_{i=1}^N \sum_{j=1}^N \log \sigma\!\left(y_{ij} \cdot S_{ij}\right) = \frac{1}{N}\sum_{i=1}^N \sum_{j=1}^N \log\!\left(1 + \exp(-y_{ij} S_{ij})\right)$$

• batch size 不再耦合所有 negative
• 单机可用极大 batch（SigLIP 报告单 chip 32k batch 可训）
• 通信只需把本机的 query 与远端 key 配对计算 sigmoid（chunked all-pair），不需要 logsumexp 同步

4.3　SigLIP vs CLIP 对比

4.4　SigLIP-2 (Google 2025)

Tschannen et al. 2025 在 SigLIP-1 基础上：

• 加入 caption-style decoder（类似 CapPa）做 captioning 辅助任务
• Self-distillation + dense local objectives：在 patch 级别做局部对比，提升细节定位能力
• 多语言扩展：训练数据扩到 100+ 语言，多语言 zero-shot 显著提升
• 公开 NaFlex 变体支持 native aspect ratio

4.5　Code: SigLIP sigmoid loss（核心 35 行）

import torch
import torch.nn as nn
import torch.nn.functional as F

class SigLIPLoss(nn.Module):
    """Sigmoid Loss for Language Image Pre-training (Zhai et al. 2023)."""
    def __init__(self, init_t=10.0, init_b=-10.0):
        super().__init__()
        # log-parameterize t for stability; b is a learnable bias
        self.t_prime = nn.Parameter(torch.tensor(init_t).log())
        self.b = nn.Parameter(torch.tensor(float(init_b)))

    def forward(self, image_feats, text_feats):
        u = F.normalize(image_feats, dim=-1)             # [N, D]
        v = F.normalize(text_feats, dim=-1)              # [N, D]

        t = self.t_prime.exp()                           # scale > 0
        logits = t * (u @ v.t()) + self.b                # [N, N]

        # y_{ij} = +1 if i == j else -1
        N = u.size(0)
        labels = 2 * torch.eye(N, device=u.device) - 1   # [N, N], +1 on diag, -1 off

        # log(1 + exp(-y * logits))  ==  -log sigmoid(y * logits)
        loss = -F.logsigmoid(labels * logits).sum() / N  # SigLIP convention: sum / N
        return loss, t, self.b

§5 EVA-CLIP / OpenCLIP / 其它 CLIP 变体

5.1　OpenCLIP

OpenCLIP（Cherti et al. 2023 CVPR）是 LAION 团队的开源复现 + 扩展：

• 训练 recipe 开源：完整 LAION-400M / LAION-2B 训练脚本
• 更大规模：ViT-bigG/14 在 LAION-2B 上训出，零样本 ImageNet ~80.1%（2023 年 SOTA）
• distributed InfoNCE：实现了 local_loss=True 的 gradient checkpoint，单 GPU 显存只存本地行/列

5.2　EVA-CLIP

EVA-CLIP（Sun et al. 2023）用 MIM 预训练的 EVA / EVA-02（Fang et al. 2023）作为 vision tower 初始化，显著提升 sample efficiency：

• ViT-L/14 在 LAION-2B 上训只需 OpenCLIP 1/3 计算预算达到同样精度
• LayerScale + sub-LN + RoPE：EVA-02 视觉端的工程改进

5.3　DataComp（数据 vs 模型 vs 算法）

Gadre et al. 2023 (NeurIPS) 设计了 "data filtering benchmark"：固定 (model, compute)，只调 data filter。结论：

• CLIP filtering + basic filtering + image-based 三种 filter 组合最优
• 大模型 (ViT-L/14) 在小数据 (12.8M) 上反而不如 ViT-B（data-limited regime 下大模型过拟合）

5.4　对比一览

§6 LLaVA：projector + 2-stage 训练

6.1　架构

LLaVA（Liu et al. 2023 NeurIPS）的核心是三件套：

Image ──► CLIP ViT-L/14 ──► visual features  z_v ∈ R^{N × d_v}
                                  │
                                  │  W ∈ R^{d_v × d_LLM}   ← MLP projector
                                  ↓
                            H_v ∈ R^{N × d_LLM}
                                  │
                                  │  与 text embedding 拼接
                                  ↓
Text tokens ──► tokenizer ──► H_t ──► [<bos>, H_v, H_t] ──► LLM (Vicuna / LLaMA-2)
                                                              │
                                                              ↓
                                                            autoregressive response

• Vision tower：CLIP ViT-L/14（frozen，取倒数第二层 patch token）。LLaVA-1.0 用 $224^2$ 输入得 $N=256$；LLaVA-1.5 升级到 $336^2$ 得 $N=576$
• Projector $W$：LLaVA-1.0 用单层 Linear；LLaVA-1.5 升级为 2-layer MLP + GELU（原文报告显著提升 instruction following）
• LLM：Vicuna-13B（LLaVA-1.0/1.5）或 LLaMA-2

6.2　训练两阶段

Stage 1: Feature Alignment Pre-training

• 用 CC3M / LAION-558K caption 数据，格式 <image>\n<caption>
• 只训 projector $W$，冻结 vision tower 和 LLM
• 目的：让 visual feature 投到 LLM 的 word embedding 空间附近

Stage 2: End-to-end Visual Instruction Tuning

• 用 GPT-4 生成的 158K 视觉 instruction（LLaVA-Instruct）
• 解冻 projector + LLM，冻结 vision tower
• LLM 学会"理解图像、回答问题、follow visual instruction"

6.3　Code: LLaVA 风格 projector + forward（核心 60 行）

import torch
import torch.nn as nn

class LLaVAProjector(nn.Module):
    """2-layer MLP + GELU, as in LLaVA-1.5."""
    def __init__(self, d_vision=1024, d_llm=4096):
        super().__init__()
        self.fc1 = nn.Linear(d_vision, d_llm)
        self.act = nn.GELU()
        self.fc2 = nn.Linear(d_llm, d_llm)

    def forward(self, x):                               # x: [B, N, d_vision]
        return self.fc2(self.act(self.fc1(x)))          # [B, N, d_llm]

class LLaVA(nn.Module):
    """Skeleton: CLIP vision tower + projector + LLM."""
    def __init__(self, vision_tower, projector, llm, image_token_id):
        super().__init__()
        self.vision_tower = vision_tower                # CLIPViT, frozen at stage 1
        self.projector = projector
        self.llm = llm                                  # e.g. LlamaForCausalLM
        self.image_token_id = image_token_id           # special <image> placeholder

    @torch.no_grad()
    def encode_image(self, pixel_values):
        # 取倒数第二层 patch features (不取 [CLS])
        vit_out = self.vision_tower(pixel_values, output_hidden_states=True)
        feat = vit_out.hidden_states[-2][:, 1:, :]      # drop CLS, [B, N, d_v]
        return feat

    def forward(self, input_ids, pixel_values, labels=None, attention_mask=None):
        # 1. 视觉特征 → projector → LLM 维度
        with torch.no_grad():
            visual_features = self.encode_image(pixel_values)        # [B, N, d_v]
        visual_tokens = self.projector(visual_features)              # [B, N, d_llm]

        # 2. LLM 的 word embedding 表
        token_embeds = self.llm.get_input_embeddings()(input_ids)    # [B, L, d_llm]

        # 3. 把 <image> placeholder 处替换为 visual_tokens
        B, L, D = token_embeds.shape
        new_embeds, new_labels, new_mask = [], [], []
        for b in range(B):
            image_pos = (input_ids[b] == self.image_token_id).nonzero(as_tuple=True)[0]
            assert image_pos.numel() == 1, "exactly one <image> placeholder expected"
            i = image_pos.item()
            # 拼接：[prefix tokens] + [N visual tokens] + [suffix tokens]
            chunks = [token_embeds[b, :i], visual_tokens[b], token_embeds[b, i+1:]]
            new_embeds.append(torch.cat(chunks, dim=0))
            if labels is not None:
                lab = labels[b]
                # visual token 位置 label = -100（不算 loss）
                ignore = torch.full((visual_tokens.size(1),), -100, dtype=lab.dtype, device=lab.device)
                new_labels.append(torch.cat([lab[:i], ignore, lab[i+1:]], dim=0))
            if attention_mask is not None:
                am = attention_mask[b]
                ones = torch.ones(visual_tokens.size(1), dtype=am.dtype, device=am.device)
                new_mask.append(torch.cat([am[:i], ones, am[i+1:]], dim=0))

        # 4. pad 回 batch tensor，喂给 LLM
        inputs_embeds = torch.nn.utils.rnn.pad_sequence(new_embeds, batch_first=True)
        labels = torch.nn.utils.rnn.pad_sequence(new_labels, batch_first=True, padding_value=-100) if labels is not None else None
        attention_mask = torch.nn.utils.rnn.pad_sequence(new_mask, batch_first=True) if attention_mask is not None else None
        return self.llm(inputs_embeds=inputs_embeds, labels=labels, attention_mask=attention_mask)

6.4　LLaVA-1.5 / 1.6 / NeXT 关键升级

§7 BLIP-2：Q-Former cross-attention

7.1　Motivation

LLaVA 的 projector 简单但每个 patch 都成为 LLM token：分辨率 ↑ token 数 ↑ LLM 计算 $O(L^2)$ ↑。BLIP-2（Li et al. 2023 ICML）用 Q-Former（Querying Transformer）把任意数量 patch 压成固定 32 token。

7.2　Q-Former 结构

输入：frozen image encoder 输出 $\mathbf{Z} \in \mathbb{R}^{N \times d_v}$（N=257 for ViT-g/14@224）。Q-Former 有 32 个 learnable query token $\mathbf{q}_1, \dots, \mathbf{q}_{32} \in \mathbb{R}^{d_q}$。

每层 Q-Former block：

$$\mathbf{q}^{(\ell)} = \text{SelfAttn}(\mathbf{q}^{(\ell-1)})$$ $$\mathbf{q}^{(\ell)} = \text{CrossAttn}(\mathbf{q}^{(\ell)},\ \mathbf{Z},\ \mathbf{Z})\quad \text{（只插在偶数层）}$$ $$\mathbf{q}^{(\ell)} = \text{FFN}(\mathbf{q}^{(\ell)})$$

关键：

• Self-attention 内：query 之间互相交流，不和 image patch 交互
• Cross-attention 内：query 作 Q，image patch 作 K/V——这是信息流入口
• 输出 $\mathbf{q}^{(L)} \in \mathbb{R}^{32 \times d_q}$ 再过一个 Linear 投到 LLM 维度，作 32 个 visual token 喂给 frozen LLM

7.3　两阶段训练

Stage 1: Representation Learning（只训 Q-Former，frozen vision encoder）

• ITC (Image-Text Contrastive)：query embedding 与 text 端 [CLS] 做 CLIP 风格对比
• ITM (Image-Text Matching)：query 与 text token 在 cross-attn 内交互后做 binary classification
• ITG (Image-grounded Text Generation)：query 不与 text 交互，让 text decoder 基于 query 生成 caption（causal mask 控制可见性）

Stage 2: Generative Learning（只训 Q-Former，frozen LLM）

• 把 Q-Former 输出投到 LLM embedding 空间，让 LLM 在 prefix-tune 模式下根据 32 visual token 做 captioning / VQA

7.4　Code: Q-Former cross-attention 单层（核心 40 行）

import torch
import torch.nn as nn

class QFormerLayer(nn.Module):
    """One Q-Former block: SelfAttn (queries) -> CrossAttn (queries <- image) -> FFN."""
    def __init__(self, d_q=768, d_v=1408, num_heads=12, mlp_ratio=4, has_cross=True):
        super().__init__()
        self.has_cross = has_cross
        self.ln_self = nn.LayerNorm(d_q)
        self.self_attn = nn.MultiheadAttention(d_q, num_heads, batch_first=True)
        if has_cross:
            self.ln_cross = nn.LayerNorm(d_q)
            # Q 来自 query (d_q), K/V 来自 image feat (d_v) -> 通过 kdim/vdim 适配
            self.cross_attn = nn.MultiheadAttention(d_q, num_heads,
                                                   kdim=d_v, vdim=d_v, batch_first=True)
        self.ln_ffn = nn.LayerNorm(d_q)
        hidden = int(d_q * mlp_ratio)
        self.ffn = nn.Sequential(nn.Linear(d_q, hidden), nn.GELU(), nn.Linear(hidden, d_q))

    def forward(self, q, image_feats=None):              # q: [B, 32, d_q]
        # Self-attention: queries talk to each other
        h = self.ln_self(q)
        a, _ = self.self_attn(h, h, h, need_weights=False)
        q = q + a
        # Cross-attention: queries attend to image patches
        if self.has_cross and image_feats is not None:
            h = self.ln_cross(q)
            a, _ = self.cross_attn(h, image_feats, image_feats, need_weights=False)
            q = q + a
        # FFN
        q = q + self.ffn(self.ln_ffn(q))
        return q

class QFormer(nn.Module):
    def __init__(self, num_queries=32, d_q=768, d_v=1408, depth=12, num_heads=12,
                 cross_every=2):
        super().__init__()
        self.queries = nn.Parameter(torch.zeros(1, num_queries, d_q))
        nn.init.trunc_normal_(self.queries, std=0.02)
        self.layers = nn.ModuleList([
            QFormerLayer(d_q, d_v, num_heads, has_cross=(i % cross_every == 0))
            for i in range(depth)
        ])

    def forward(self, image_feats):                      # [B, N, d_v]
        B = image_feats.size(0)
        q = self.queries.expand(B, -1, -1)               # [B, 32, d_q]
        for layer in self.layers:
            q = layer(q, image_feats)
        return q                                         # [B, 32, d_q]

7.5　Q-Former vs LLaVA Projector：trade-off

§8 Flamingo：Perceiver Resampler + Gated Cross-Attn

8.1　设计目标

Alayrac et al. 2022 (NeurIPS) 想要：在 frozen 70B LLM 上加视觉能力，不破坏文本能力。设计选择：

• 不重训 LLM：完全 frozen，只在中间插入新层
• 少量可训参数：cross-attn 层 + Perceiver Resampler
• few-shot interleaved：训练数据是 (image, text, image, text, ...) 交错序列

8.2　Perceiver Resampler

类似 Q-Former 的"用 latent query 压缩 image"。Flamingo 原论文 Sec 3.1 的伪代码是多层堆叠（每层 = cross-attention + FFN），论文默认配置约 $L=6$ 层。每一层的更新规则：

$$\mathbf{q}^{(\ell+1)} = \mathbf{q}^{(\ell)} + \text{CrossAttn}\!\left(\mathbf{q}^{(\ell)},\ [\mathbf{q}^{(\ell)};\ \mathbf{Z}],\ [\mathbf{q}^{(\ell)};\ \mathbf{Z}]\right), \quad \mathbf{q}^{(\ell+1)} = \mathbf{q}^{(\ell+1)} + \text{FFN}(\mathbf{q}^{(\ell+1)})$$

注意 K/V 是 concat(query, image_feat) 而不只是 image_feat——让 query token 也能互相 attend。整体仍然比 BLIP-2 Q-Former (12 层 + self-attn + cross-every-2) 轻。输出 64 个 latent visual token（不依赖输入 patch 数）。

8.3　Gated Cross-Attention（核心创新）

在 LLM 每隔 $k$ 层（如每 4 层）插入一个新的 cross-attention 模块：

$$\mathbf{h}'_\ell = \mathbf{h}_\ell + \tanh(\alpha_\text{attn}) \cdot \text{CrossAttn}(\mathbf{h}_\ell, \mathbf{q}_\text{out}, \mathbf{q}_\text{out})$$ $$\mathbf{h}''_\ell = \mathbf{h}'_\ell + \tanh(\alpha_\text{ffn}) \cdot \text{FFN}(\mathbf{h}'_\ell)$$

关键：$\alpha_\text{attn}, \alpha_\text{ffn}$ 是 learnable scalar，初始化为 0。所以 $\tanh(0)=0$，新增 cross-attn 在初始化时对 LLM 输出零贡献——LLM 表现与未加视觉模块的 frozen LLM 完全一致。训练时 $\alpha$ 逐渐学到非零值，视觉信息开始注入。

8.4　Flamingo / Llama-3.2-V vs LLaVA 对比

§9 CogVLM 与"视觉专家" / Cross-attn fusion 变体

9.1　CogVLM：视觉专家分支

Wang et al. 2023 (CogVLM) 的核心：在 LLM 的 attention / FFN 里复制一份并行分支，专门处理 visual token，与原 text 分支共享 attention 计算但走不同 projection：

                  attention
       ┌──────────────┴──────────────┐
       ↓                              ↓
   text projection (frozen)    vision expert projection (trainable)
       │                              │
       └──────────────┬──────────────┘
                      ↓
         token-wise route: if visual_token, use vision branch

• 类似 MoE 的双专家：text token 走 text 分支，image token 走"visual expert"分支
• vision expert 单独训练：text 分支可 frozen，视觉能力来自 expert
• 保留 LLM 原生 text 能力（与 Flamingo 同思路，但 routing 粒度是 token 而非 layer）

9.2　Llama-3.2 Vision：Flamingo-style cross-attn 在大 LLM 上的复活

2024 年 9 月 Meta 发布 Llama-3.2-V (11B / 90B)：

• Frozen Llama-3 backbone
• 加入 separate cross-attention layers（不是改 self-attn）
• Adapter-style 训练，只在 cross-attn 层学
• 设计为"长尾视觉任务的 robust 基座"，视觉能力上限略低于 GPT-4V，但 text-only benchmark 与 Llama-3 文本版几乎一致

9.3　Claude 3.5/3.7 Sonnet Vision 与 GPT-4V/4o

Anthropic / OpenAI 的闭源模型架构未公开，但从 API 行为推断：

• GPT-4V (2023.09) / GPT-4o (2024.05)：4o 是 native multimodal，从底层就联合训练 (image + text + audio)，不是 LLaVA 式后接 projector
• Claude 3.5/3.7 Sonnet (2024-2025)：支持高分辨率图像（最多 8000×8000 像素，按需 tile），文档理解 (PDF/screenshot) 是其卖点之一
• 共同特征：能处理多页文档 / 截屏 / OCR 数学公式——远超 LLaVA 系列。这暗示它们在训练数据规模（document corpus）+ tiling 策略上有重大优化

§10 Qwen2-VL / DeepSeek-VL：动态分辨率 + M-RoPE

10.1　Native Dynamic Resolution

Qwen2-VL (Wang et al. 2024)、DeepSeek-VL (Lu et al. 2024)、InternVL-2 都抛弃了"resize 到固定 224²"的传统：

• 保留原始 aspect ratio：把图按 patch_size 的整数倍 resize 到接近原尺寸的最大值
• patch 数动态：一张 $1024 \times 768$ 图按 $P=14$ 切成 $73 \times 54 \approx 3942$ 个 patch
• 不再使用固定 pos embed 表：必须用 可扩展的位置编码（RoPE 或 2D ALiBi-like）

10.2　M-RoPE（Multimodal RoPE）

Qwen2-VL 的核心创新。回顾普通 1D RoPE：把 query / key 的每对维度 $(2k, 2k+1)$ 看作复数，乘上位置相关的旋转：

$$\mathbf{R}_{m,k} = \begin{pmatrix} \cos(m\theta_k) & -\sin(m\theta_k) \\ \sin(m\theta_k) & \cos(m\theta_k) \end{pmatrix}, \quad \theta_k = 10000^{-2k/d}$$

应用到 $\mathbf{q}_m$ 后，$\mathbf{q}_m^\top \mathbf{k}_n$ 只依赖 $m - n$（相对位置）。

M-RoPE 的扩展：一个视觉 token 有 (t, h, w) 三个位置维度。所有 head_dim 都旋转——但每对维度 $(2k, 2k+1)$ 根据所在区段，用 t / h / w 三个位置 id 之一参与旋转角度：

$$(\cos(m_\text{axis}\,\theta_k),\ \sin(m_\text{axis}\,\theta_k)), \quad \text{axis} \in \{t, h, w\}$$

具体地，Qwen2-VL 的 mrope_section（单位是半 head_dim 对，即每个数代表多少对 $(2k, 2k+1)$）。一对 = 2 个实数维度，所以"section sum × 2 = head_dim"。

文本 token 没有显式 (h, w)：Qwen2-VL 让 $m_t = m_h = m_w$ 等于该 text token 的 1D 位置 id，三个 axis 给出完全相同的旋转角，等价于普通 1D RoPE。

10.3　Qwen2.5-VL 升级

Qwen2.5-VL（Bai et al. 2025）在 Qwen2-VL 基础上：

• 绝对时间编码：M-RoPE 的 t 维改用真实时间戳（秒），不是帧 index，支持任意 FPS 视频
• 动态视觉 token budget：根据任务复杂度调 token 数
• agent / GUI 能力：训练数据加入 web screenshot / mobile UI 操作 trace

10.4　DeepSeek-VL / VL2：高分辨率 tiling + Hybrid encoder

DeepSeek-VL (Lu et al. 2024) 用双 vision encoder：

• SigLIP：处理全局语义（低分辨率）
• SAM-B（Segment Anything backbone）：处理高分辨率细节

两路特征 concat 喂给 projector + LLM。DeepSeek-VL2 (2024.12) 进一步换成 MoE LLM + 动态分辨率，单 image 视觉 token 可达 1700+。

10.5　Code: M-RoPE 三维位置嵌入（核心 50 行，对齐 Qwen2-VL HF 实现）

import torch

def build_mrope_cos_sin(positions, head_dim, mrope_section=(16, 24, 24), base=10000.0):
    """
    Build cos/sin tensors for Qwen2-VL style M-RoPE.

    positions: LongTensor [3, B, L]   (axis 0: t / h / w; B batch; L seq len)
    head_dim:  per-head dim (must equal 2 * sum(mrope_section))
    mrope_section: tuple of 3 ints; each = number of (half-dim) entries per axis
    Returns: cos, sin both [B, L, head_dim], ready for LLaMA-style rotate_half.
    """
    assert 2 * sum(mrope_section) == head_dim, "2 * sum(mrope_section) must = head_dim"
    half = head_dim // 2                                                # = sum(mrope_section)

    # 标准 RoPE 频率: θ_k = base^{-2k/head_dim}, k = 0..half-1
    inv_freq = 1.0 / (base ** (torch.arange(0, half).float() * 2 / head_dim))   # [half]
    inv_freq = inv_freq.to(positions.device)

    # 对每个 axis 算 [B, L, half] 的 angle / cos / sin
    cos_axes, sin_axes = [], []
    for a in range(3):
        ang = positions[a].float().unsqueeze(-1) * inv_freq                     # [B, L, half]
        cos_axes.append(ang.cos())
        sin_axes.append(ang.sin())

    # 把 half-dim 按 mrope_section 切成 3 段，分别取 t/h/w 的 cos/sin
    cos_chunks, sin_chunks = [], []
    offset = 0
    for axis, s in enumerate(mrope_section):
        cos_chunks.append(cos_axes[axis][..., offset:offset+s])                 # [B, L, s]
        sin_chunks.append(sin_axes[axis][..., offset:offset+s])
        offset += s
    cos_half = torch.cat(cos_chunks, dim=-1)                                    # [B, L, half]
    sin_half = torch.cat(sin_chunks, dim=-1)

    # LLaMA-RoPE 风格 duplicate 到 full head_dim
    cos = torch.cat([cos_half, cos_half], dim=-1)                               # [B, L, head_dim]
    sin = torch.cat([sin_half, sin_half], dim=-1)
    return cos, sin

def rotate_half(x):
    """(x1, x2) -> (-x2, x1), LLaMA convention."""
    x1, x2 = x.chunk(2, dim=-1)
    return torch.cat((-x2, x1), dim=-1)

def apply_mrope(q, k, cos, sin):
    """
    q, k:    [B, num_heads, L, head_dim]
    cos, sin:[B, L, head_dim]
    """
    cos = cos.unsqueeze(1)                                                       # broadcast over heads
    sin = sin.unsqueeze(1)
    q_rot = q * cos + rotate_half(q) * sin
    k_rot = k * cos + rotate_half(k) * sin
    return q_rot, k_rot

• "head_dim 切成 t/h/w 三段独立 1D RoPE"：错。Qwen2-VL 实际是 6 段 alternating [s_t, s_h, s_w, s_t, s_h, s_w]，全 head_dim 都旋转
• "section 单位是 dim"：错。mrope_section=[16,24,24] 单位是 对数（每对 = 2 个 head_dim 元素），$\sum \times 2 = $ head_dim = 128
• "text token 没有 (h, w) 怎么办？"：让 $m_t = m_h = m_w$ 等于 text 的 1D 位置 id，三个 axis 旋转角相同，退化回 1D RoPE

§11 Video VLM：LongVA / VideoLLaMA / 长视频问题

11.1　基本 pipeline

视频 = 多帧 image。VLM 处理视频的常见做法：

1. 均匀采样 $K$ 帧（如 8 / 16 / 32）
2. 每帧过 vision encoder → 每帧 $N$ 个 patch token
3. token 序列拼接：$K \cdot N$ 个 visual token 喂入 LLM

问题：$K=32, N=576 \Rightarrow 18432$ token，单图 instruction tuning 的 LLM context 撑不住。

11.2　常见压缩策略

• Time pooling：相邻帧 token average pool（VideoChat / VideoLLaMA）
• Q-Former resampler：每帧用 query token 压成 32（Video-BLIP）
• Token merge：跨帧合并相似 token（VideoLLaMA 2）
• Spatial pooling + temporal preservation：每帧 patch token 池化到 $H' \times W'$，保留所有帧（LLaVA-NeXT-Video）

11.3　LongVA / Long-context video

LongVA (Zhang et al. 2024) 等利用 long-context LLM (200K+ token) 直接吃长视频展开的 token 序列，配合 M-RoPE 的时间维度做几小时视频问答。Qwen2-VL 报告可处理 20 分钟视频；Qwen2.5-VL 推到 1 小时+。

11.4　Video benchmark

• MVBench (Li et al. 2024)：20 个 fine-grained video understanding 任务
• Video-MME (Fu et al. arXiv 2024 / CVPR 2025)：900+ video，包含 3 个时长档（短/中/长）+ 6 类任务
• EgoSchema (Mangalam et al. 2023 NeurIPS)：第一人称长视频
• LongVideoBench (Wu et al. 2024 NeurIPS)：从 8 秒到 1 小时

§12 训练 pipeline：alignment / instruct / preference

12.1　Stage 1：Alignment / Pre-training

目的：让视觉特征"对齐"到 LLM token 空间附近。

• 数据：image-caption pair（CC3M, LAION-558K, ShareGPT4V）
• 训练：只解冻 projector（LLaVA）/ Q-Former (BLIP-2)，vision tower + LLM 冻结
• Loss：next-token prediction（用 LLM 把 visual feature 作 prefix，生成 caption）

12.2　Stage 2：Visual Instruction Tuning

目的：教会 VLM "看图回答问题、follow instruction"。

• 数据：GPT-4 生成的 visual instruction（LLaVA-Instruct-158K, ShareGPT4V）+ 学术 VQA 数据（VQAv2, GQA, OCR-VQA, TextVQA）
• 训练：解冻 LLM + projector，vision tower 一般保持冻结（LLaVA-1.5 / Qwen-VL）。Qwen2-VL 在最后阶段也解冻 vision tower做 end-to-end fine-tune
• Loss：next-token prediction on answer tokens（input image + question 不算 loss）

12.3　Stage 3：Preference / RLHF

目的：减幻觉、提升 helpfulness / harmlessness、长尾任务对齐。

12.4　数据规模 vs 阶段

§13 Multimodal Embeddings：BGE-VL / Jina-CLIP / VLM2Vec

13.1　为什么需要新一代多模态 embedding？

CLIP 训练目标是 "image ↔ short caption" 对齐，长 instruction 检索 / multi-image / interleaved 文档检索 表现差。新一代 multimodal embedding 模型针对 retrieval / RAG 场景。

13.2　代表方法

• Jina-CLIP-v1 (2024)：在 CLIP 基础上加长文本对比（text-text task）+ 多分辨率，单 embedding 模型既能做 image-text 也能做 text-text retrieval
• BGE-VL (2024)：BGE 团队的 multimodal 版本，用 SigLIP-So400M + small LLM 做 instruction-aware retrieval
• VLM2Vec (Jiang et al. 2024)：把 VLM（LLaVA / Qwen-VL）的最后一层 hidden state 做 instruction-conditioned mean pool，只训 contrastive head，benchmark MMEB 上显著超过 CLIP
• mmE5 (2024)：multimodal 版本的 E5，支持 12 种 retrieval 任务类型

13.3　核心 trick

• instruction-aware：embedding 输入 [instruction][image][query]，让同一图像在不同任务下产生不同 embedding
• VLM-as-encoder：直接用 instruct-tuned VLM 做 backbone，不再单独 contrastive pretrain
• hard negative mining：用 cross-encoder rerank 挖掘 batch 之外的 hard negative

§14 25 高频面试题（L1 必会 · L2 进阶 · L3 顶级 lab）

L1 基础题（必会 10）

L2 进阶（10 题）

L3 高级（顶级 lab / 研究方向，5 题）

§A 附录：Sanity-check 输出 & 参考文献

A.1 关键代码 sanity check（实跑示意）

[ViT] patch_embed: (2, 3, 224, 224) -> (2, 196, 768)  ✓
[ViT] forward + CLS: (2, 3, 224, 224) -> head out (2, 1000)  ✓

[CLIP] N=8, D=512, init logit_scale=ln(1/0.07): loss ≈ 2.08 ≈ log(N) (random embeddings → near-uniform softmax)  ✓
[CLIP] forward + backward: gradients along i→t 与 t→i path 对称 ✓

[SigLIP] N=8, D=512, b=0:  loss = sum_{ij} log(1+e^0) / N = 64 * log 2 / 8 ≈ 5.545  ✓
[SigLIP] bias b=-10: positive (8 项) loss ≈ log(1+e^10) ≈ 10; negative (56 项) loss ≈ 4.5e-5; 整体 8·10/8 ≈ 10.0  ✓ (正样本主导初期梯度)

[LLaVA] visual feat (2, 256, 1024) -> projector -> (2, 256, 4096)  ✓
[LLaVA] input_ids w/ <image> placeholder: 1 token -> 256 visual tokens after merge  ✓

[Q-Former] image_feats (2, 257, 1408), queries (1, 32, 768) -> out (2, 32, 768)  ✓

[M-RoPE] head_dim=128, mrope_section=[16,24,24]: 2 × sum = 128 = head_dim, full rotation ✓
[M-RoPE] pure-text token (pos_t=pos_h=pos_w=m): cos/sin 三个 axis 完全相同, 等价 1D RoPE ✓

A.2 关键文献（按主题）

视觉 encoder：Dosovitskiy et al. ICLR 2021 (ViT); Zhai et al. CVPR 2022 (ViT-g); Fang et al. arXiv 2023 (EVA-02)

对比预训练：Radford et al. ICML 2021 (CLIP); Cherti et al. CVPR 2023 (OpenCLIP); Zhai et al. ICCV 2023 (SigLIP); Tschannen et al. arXiv 2025 (SigLIP-2); Gadre et al. NeurIPS 2023 (DataComp)

视觉 instruction / fusion：Liu et al. NeurIPS 2023 (LLaVA); Liu et al. CVPR 2024 (LLaVA-1.5); Li et al. ICML 2023 (BLIP-2); Alayrac et al. NeurIPS 2022 (Flamingo); Wang et al. arXiv 2023 (CogVLM); Bai et al. arXiv 2023 (Qwen-VL); Wang et al. arXiv 2024 (Qwen2-VL); Bai et al. arXiv 2025 (Qwen2.5-VL); Lu et al. arXiv 2024 (DeepSeek-VL); Wu et al. arXiv 2024 (DeepSeek-VL2); Chen et al. CVPR 2024 + arXiv 2024 (InternVL / InternVL-2); Llama Team arXiv 2024 (Llama-3.2-V); Deitke et al. arXiv 2024 (Molmo); Li et al. arXiv 2024 (LLaVA-OneVision)

VLM 偏好对齐：Sun et al. arXiv 2023 (LLaVA-RLHF); Yu et al. arXiv 2024 (RLAIF-V); Zhou et al. arXiv 2024 (POVID); Shen et al. arXiv 2025 (VLM-R1)

多模态 embedding：Koukounas et al. arXiv 2024 (Jina-CLIP); Jiang et al. arXiv 2024 (VLM2Vec); Zhang et al. arXiv 2024 (mmE5)

评测：Li et al. EMNLP 2023 (POPE); Thrush et al. CVPR 2022 (Winoground); Liu et al. ECCV 2024 (MMBench); Yue et al. CVPR 2024 (MMMU); Fu et al. CVPR 2025 (Video-MME); Yu et al. ICML 2024 (MM-Vet); Mangalam et al. NeurIPS 2023 (EgoSchema)

代码 + 公式经独立 reviewer 静态检查；数值在 PyTorch 2.x、CUDA 12.x 上验证（ViT / CLIP / SigLIP / Q-Former / M-RoPE 5 个核心模块的形状与初始 loss 均与公式一致）。