VLM 算法知识与面经汇总

一、VLM 核心知识体系

1.1 视觉编码器 (Visual Encoder)

Vision Transformer (ViT)

• 将图像切分为固定大小的 patch（通常 14×14 或 16×16 像素）
• 每个 patch 通过线性投影得到一个 token embedding
• 添加位置编码（positional embedding）保留空间信息
• 经过标准 Transformer Encoder 层（Self-Attention + FFN）
• 输出：一组 patch 特征向量（如 224×224 图像 + 14×14 patch = 256 个 token）

CLIP Visual Encoder

• 在 400M+ 图文对上通过对比学习训练
• 使用 ViT-L/14 架构（304M 参数）
• Softmax-based InfoNCE Loss：对 batch 中 N 个图文对构建 N×N 相似度矩阵
• 生成与语言语义对齐的视觉特征

SigLIP (Sigmoid Loss for Image-Language Pre-training)

EVA-CLIP

• 两阶段：先用 Masked Image Modeling (MIM) 预训练 ViT，再做 CLIP 对比学习
• EVA-02 使用 RoPE + SwiGLU FFN
• 使用模型：Qwen-VL (EVA-CLIP-14B), InternVL (InternViT-6B)

1.2 VLM 主流架构

[BOS] [IMG_1] [IMG_2] ... [IMG_256] [User query tokens] [Response tokens]

1.3 视觉-语言对齐 (Visual-Language Alignment)

连接器模块 (Connector/Projector)

1.4 训练阶段 (Training Stages)

1.5 分辨率处理 (Resolution Handling)

Dynamic Tiling / AnyRes（主流方案）

Native Dynamic Resolution (Qwen2-VL)

• 使用 2D-RoPE 替代绝对位置编码 → 天然支持任意分辨率
• Spatial Merge (2×2→1)：减少 4× token 数
• 无需 tiling，更优雅

1.6 Mixture-of-Experts (MoE) 在 VLM 中的应用

二、2025-2026 最新进展

2.1 重要模型发布

闭源模型

开源模型

2.2 架构创新

• M-RoPE → Interleaved-MRoPE：分离/交错时空维度的位置编码
• DeepStack (Qwen3-VL)：视觉特征深度集成到 LLM 各层
• Cascade RL (InternVL3.5)：离线 MPO + 在线 GSPO
• Visual Token 压缩：Dynamic-VLM (ICCV 2025) 减少 50-75% token

2.3 训练范式变化

VLM 强化学习（最大范式转变）

• GRPO for VLMs：扩展 DeepSeek GRPO 到多模态（InternVL3, Qwen3-VL）
• DPO for VLMs：Direct Preference Optimization 应用于视觉语言任务
• OPA-DPO (CVPR 2025)：Object-presence-aware DPO 针对幻觉

Thinking / Test-Time Compute

• "Thinking" 变体成为标准：Qwen3-VL-Thinking, Gemini 2.5 Pro, o3/o4
• Temporal Chain of Thought (NeurIPS 2025)：逐帧推理长视频

多模态 Scaling Laws

2.4 Benchmark 趋势

MMMU (截至 2026.05)

2.5 新兴研究方向

三、面试高频问答

Q1: CLIP 和 SigLIP 的核心区别？

# CLIP Loss
logits = image_embeds @ text_embeds.T * exp(log_temperature)  # NxN
labels = torch.arange(N)
loss = (F.cross_entropy(logits, labels) + F.cross_entropy(logits.T, labels)) / 2

# SigLIP Loss
logits = image_embeds @ text_embeds.T * exp(log_temperature) + bias
labels = 2 * torch.eye(N) - 1  # +1 匹配, -1 不匹配
loss = -F.logsigmoid(labels * logits).sum() / N

Q2: LLaVA 训练流水线详解

Q3: Visual Connector 的作用？为什么 MLP 就够了？

三个核心功能：维度对齐 (ViT dim → LLM dim)、模态桥接、Token 压缩（可选）

为什么简单 MLP 就够：当 ViT 和 LLM 都是强预训练模型时，projector 只需做"翻译"。Q-Former 等复杂设计可能因 query 数量不足而成为信息瓶颈。对需要细粒度空间理解的任务 (OCR, grounding)，保留全部 token 的 MLP 更优。

Q4: VLM 如何处理高分辨率图像？

核心挑战: ViT 注意力 O(n²)，分辨率翻倍则 patch 数翻 4 倍。

# Dynamic Tiling (AnyRes) - 主流方案
def tile_image(image, base_res=336, max_tiles=12):
    cols, rows = find_best_grid(W, H, base_res, max_tiles)
    resized = resize(image, (rows*base_res, cols*base_res))
    tiles = split_into_grid(resized, cols, rows)
    thumbnail = resize(image, (base_res, base_res))
    return tiles + [thumbnail]  # 每个独立编码后拼接

Qwen2-VL 方案：2D-RoPE + Spatial Merge (2×2→1)，无需 tiling。

Q5: Visual Grounding 如何实现？

# 主流方法：坐标 Token 化
User: 图中的狗在哪里？
Model: <box>(234, 156, 567, 489)</box>
# 坐标归一化到 [0, 1000]，LLM 自回归生成

训练数据：RefCOCO, Visual Genome。挑战：坐标幻觉、多相似物体歧义。

Q6: MoE 如何应用于 VLM？

Input Token → Router → Top-K 专家 → 加权求和

核心优势：3-7× 参数只用 1.5-2× 计算。VLM 特有挑战：视觉 token 导致负载不均衡、需要模态平衡的辅助 loss。

Q7: 视频理解的核心挑战？

方案：均匀采样、关键帧选择、时序池化、Dynamic FPS (Qwen2.5-VL)、分层编码。长视频前沿：Agentic 方法 + Temporal CoT。

Q8: VLM 的 RLHF/DPO 与纯文本有何不同？

最新方法：OPA-DPO, S2H-DPO, RA-DPO, POVID

Q9: 如何减少 VLM 幻觉？

# Contrastive Decoding 核心思想
logits_final = logits_with_image - α * logits_without_image
# 惩罚不看图也能生成的 token（文本先验偏置）

Q10: 设计多模态 RAG 系统

关键点：ColPali/ColQwen per-patch 检索、混合检索 scoring、强制引用来源减少幻觉。

Q11: 如何高效部署 VLM？

四、代码实现题

4.1 实现 Visual Projector

import torch
import torch.nn as nn

class MLPProjector(nn.Module):
    """LLaVA-style 2-layer MLP projector."""
    def __init__(self, visual_dim: int, llm_dim: int, hidden_dim: int = None):
        super().__init__()
        hidden_dim = hidden_dim or llm_dim
        self.projector = nn.Sequential(
            nn.Linear(visual_dim, hidden_dim),
            nn.GELU(),
            nn.Linear(hidden_dim, llm_dim),
        )

    def forward(self, visual_features: torch.Tensor) -> torch.Tensor:
        # (batch, num_patches, visual_dim) → (batch, num_patches, llm_dim)
        return self.projector(visual_features)


class PerceiverResampler(nn.Module):
    """Flamingo-style: 变长视觉特征 → 固定 num_latents 个 token"""
    def __init__(self, visual_dim, llm_dim, num_latents=64, num_heads=16, num_layers=6):
        super().__init__()
        self.latents = nn.Parameter(torch.randn(num_latents, llm_dim) * 0.02)
        self.input_proj = nn.Linear(visual_dim, llm_dim)
        self.layers = nn.ModuleList([
            PerceiverLayer(llm_dim, num_heads) for _ in range(num_layers)
        ])
        self.norm = nn.LayerNorm(llm_dim)

    def forward(self, visual_features):
        B = visual_features.shape[0]
        x = self.input_proj(visual_features)
        latents = self.latents.unsqueeze(0).expand(B, -1, -1)
        for layer in self.layers:
            latents = layer(latents, x)
        return self.norm(latents)


class PerceiverLayer(nn.Module):
    def __init__(self, dim, num_heads):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(dim, num_heads, batch_first=True)
        self.cross_attn = nn.MultiheadAttention(dim, num_heads, batch_first=True)
        self.ffn = nn.Sequential(nn.Linear(dim, dim*4), nn.GELU(), nn.Linear(dim*4, dim))
        self.norm1 = nn.LayerNorm(dim)
        self.norm2 = nn.LayerNorm(dim)
        self.norm3 = nn.LayerNorm(dim)

    def forward(self, latents, context):
        x = self.norm1(latents)
        latents = latents + self.self_attn(x, x, x)[0]
        x = self.norm2(latents)
        latents = latents + self.cross_attn(x, context, context)[0]
        latents = latents + self.ffn(self.norm3(latents))
        return latents

4.2 交错图文输入的 Attention Mask

import torch
from typing import List

def create_interleaved_attention_mask(
    seq_len: int,
    image_regions: List[tuple],  # [(start, end), ...]
    dtype=torch.float32,
) -> torch.Tensor:
    """
    规则:
    1. 整体 causal mask（每个 token 只能看前面的）
    2. 同一图像内 token 双向注意
    3. 不同图像 token 不能直接注意
    """
    # 标准下三角 causal mask
    causal = torch.tril(torch.ones(seq_len, seq_len, dtype=torch.bool))
    
    # 同一图像内允许双向注意
    for start, end in image_regions:
        causal[start:end, start:end] = True
    
    # 转为 float: 0=可注意, -inf=mask
    mask = torch.zeros(seq_len, seq_len, dtype=dtype)
    mask.masked_fill_(~causal, float('-inf'))
    
    return mask.unsqueeze(0).unsqueeze(0)  # (1, 1, seq_len, seq_len)

# 使用示例:
# 序列: [text:10] [image_0:256] [text:15] [image_1:256] [text:20]
mask = create_interleaved_attention_mask(557, [(10, 266), (281, 537)])

4.3 图像 Tiling（高分辨率输入）

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

def find_best_grid(width, height, base_res=336, max_tiles=12):
    """找到最匹配宽高比的网格配置"""
    aspect = width / height
    best_grid, best_score = (1, 1), float('inf')
    
    for total in range(1, max_tiles + 1):
        for cols in range(1, total + 1):
            rows = total // cols
            if rows * cols != total or rows == 0:
                continue
            score = abs(math.log(cols/rows) - math.log(aspect)) + 0.01 * total
            if score < best_score:
                best_score = score
                best_grid = (cols, rows)
    return best_grid

def tile_image(image: torch.Tensor, base_res=336, max_tiles=12):
    """
    Args: image (C, H, W)
    Returns: tiles (N+1, C, base_res, base_res), grid (cols, rows)
    """
    C, H, W = image.shape
    cols, rows = find_best_grid(W, H, base_res, max_tiles)
    
    # Resize to fit grid
    resized = F.interpolate(
        image.unsqueeze(0), (rows*base_res, cols*base_res),
        mode='bicubic', align_corners=False
    ).squeeze(0)
    
    # Split into tiles
    tiles = []
    for r in range(rows):
        for c in range(cols):
            tiles.append(resized[:, r*base_res:(r+1)*base_res, c*base_res:(c+1)*base_res])
    
    # Thumbnail (全局视图)
    thumb = F.interpolate(image.unsqueeze(0), (base_res, base_res),
                          mode='bicubic', align_corners=False).squeeze(0)
    tiles.append(thumb)
    
    return torch.stack(tiles), (cols, rows)

# Example
image = torch.randn(3, 1920, 1080)
tiles, grid = tile_image(image)
print(f"Grid: {grid[0]}×{grid[1]}, Total tiles: {tiles.shape[0]}")
# Grid: 3×5, Total tiles: 16 (15 tiles + 1 thumbnail)

五、必知论文清单

六、面试准备要点总结