多模态与生成模型 Multimodal & Generative Models

阶段总览

1. 视觉语言模型（VLM）

1.1 三种架构范式

2026 年的趋势明确指向原生统一架构：图像与文本不再是「编码器 + 适配器」的拼接，而是在共享潜空间里直接做 token 级跨模态注意力。这也是「原生多模态」这个词的含义。

python# VLM 的最小前向结构（投影式）：理解视觉 token 是怎么“进入”LLM 的
import torch, torch.nn as nn

class SimpleVLM(nn.Module):
    def __init__(self, vision, d_vision=1024, d_llm=4096, patch=14, img=336):
        super().__init__()
        self.vision = vision                                  # ViT / SigLIP，输出 patch 特征
        self.projector = nn.Sequential(                       # 关键适配层：维度对齐
            nn.Linear(d_vision, d_llm), nn.GELU(), nn.Linear(d_llm, d_llm))
        self.n_visual_tokens = (img // patch) ** 2            # 336/14 = 24 -> 576 个视觉 token
        print(f"每张图将占用 {self.n_visual_tokens} 个 token —— 这是成本的关键")

    def forward(self, pixel_values, text_embeds):
        vis = self.vision(pixel_values)                       # (B, N_patch, d_vision)
        vis = self.projector(vis)                             # (B, N_patch, d_llm)
        # 把视觉 token 拼在文本 token 之前（或按占位符插入）
        return torch.cat([vis, text_embeds], dim=1)

# 成本直觉：576 个视觉 token ≈ 一段 400 字中文；高分辨率切图会成倍放大
# 这就是「图片一多，账单就爆」的根本原因，也是视觉 token 压缩成为热点的原因

1.2 多模态评测：幻觉与细粒度感知

• 视觉幻觉：模型描述图像中不存在的物体或文字。这是 VLM 最常见也最危险的失效模式。
• 细粒度感知：小物体、密集文字（OCR）、图表数值、空间关系（左/右/上/下）——这些是能力分水岭。
• 计数与比较：数物体个数、比较大小，看似简单但准确率往往远低于人类直觉。
• 文档理解：表格结构、印章、手写体、跨页引用，是实际业务中最有价值的场景。
• 评测方法：不能只看整体相似度。要构造「有标准答案的细粒度问题」，并单独统计幻觉率（模型说出的不存在元素比例）。

python# 幻觉率评测：把「模型提到的元素」与「图中真实元素」做集合比较
def hallucination_rate(samples):
    """samples: [{"claimed": [...], "present": [...]}, ...]"""
    total, halluc = 0, 0
    for s in samples:
        claimed = set(x.strip().lower() for x in s["claimed"])
        present = set(x.strip().lower() for x in s["present"])
        total += len(claimed)
        halluc += len(claimed - present)          # 说了但图里没有
    return halluc / max(1, total)

# 典型结论：通用 VLM 在自然图片上幻觉率较低，
# 但在「文字密集 / 低分辨率 / 专业图表」上会显著升高 —— 这决定你能否用在业务里

1.3 动手练习与自测

1. 三种 VLM 架构（投影式 / 交叉注意力式 / 原生统一式）在「跨模态交互深度」与「训练成本」上如何排序？
2. 一张 336×336 图在 patch=14 时产生多少视觉 token？提到 1008×1008 后是多少？
3. 为什么视觉幻觉比 OCR 错误更危险？给出一个业务场景。
4. 写一个评估流程，把「细粒度感知（OCR / 计数 / 空间）」与「幻觉率」分开统计。
5. 2026 年 VLM 架构的趋势是什么？为什么？

2. 生成模型：扩散与 Flow Matching

2.1 扩散模型的直觉与最小实现

扩散模型的想法是：定义一条从数据到噪声的加噪路径，然后训练一个网络学会反向去噪。生成时从纯噪声出发，迭代去噪若干步得到样本。它稳定、可控、覆盖模式全，是 2024 年之后图像与视频生成的主流。

python# DDPM 的核心：加噪公式与训练目标（极度精简版）
import torch, torch.nn as nn

class TinyUNet(nn.Module):
    def __init__(self, d=64):
        super().__init__()
        self.net = nn.Sequential(nn.Conv2d(1, d, 3, padding=1), nn.SiLU(),
                                 nn.Conv2d(d, d, 3, padding=1), nn.SiLU(),
                                 nn.Conv2d(d, 1, 3, padding=1))
        self.temb = nn.Linear(1, d)                      # 时间步条件（实际用正弦编码）
    def forward(self, x, t):
        h = self.net[0](x) + self.temb(t).view(-1, -1, 1, 1)
        return self.net[2:](torch.cat([h], dim=1)) if False else self.net(x)

T = 1000
betas = torch.linspace(1e-4, 0.02, T)
alphas = 1.0 - betas
alpha_bar = torch.cumprod(alphas, dim=0)                 # ᾱ_t

def q_sample(x0, t, noise):
    """前向加噪：x_t = √ᾱ_t · x_0 + √(1-ᾱ_t) · ε  —— 一步到位"""
    a = alpha_bar[t].view(-1, 1, 1, 1)
    return a.sqrt() * x0 + (1 - a).sqrt() * noise

# 训练目标：预测噪声 ε（等价于预测 x0 或速度 v，只是参数化不同）
model = TinyUNet()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
for x0 in loader:
    t = torch.randint(0, T, (x0.size(0),))
    noise = torch.randn_like(x0)
    loss = nn.functional.mse_loss(model(q_sample(x0, t, noise), t), noise)
    opt.zero_grad(); loss.backward(); opt.step()

2.2 Flow Matching 与统一架构

Flow Matching（流匹配）可以理解为扩散的简化版：不定义离散的加噪步，而是直接学习一个从噪声分布到数据分布的连续速度场，训练目标变成回归「把噪声点推向数据点的速度」。它训练更稳、采样步数更少、实现更干净，因此在 2025–2026 年被大量图像/视频模型采用（如视频扩散中的 Flow Matching、机器人 VLA 中的动作头）。

python# Flow Matching 的目标：给定噪声 x0 与数据 x1，学一个线性路径的速度
import torch

def flow_matching_loss(model, x1):
    """x1: 真实数据；x0: 噪声；t~U(0,1)"""
    x0 = torch.randn_like(x1)
    t = torch.rand(x1.size(0), *([1] * (x1.dim() - 1)))
    xt = (1 - t) * x0 + t * x1          # 线性插值路径
    v_target = x1 - x0                  # 该路径上的真实速度（常数）
    return torch.nn.functional.mse_loss(model(xt, t), v_target)

# 采样：从噪声出发，沿学到的速度场用少量步数积分（欧拉法）
@torch.no_grad()
def sample(model, shape, steps=20):
    x = torch.randn(shape)
    for i in range(steps):
        t = torch.full((shape[0],), i / steps)
        x = x + model(x, t) * (1.0 / steps)          # 20 步左右即可出图
    return x

• 为什么少步也行：路径接近直线时速度场近似常数，大步长积分误差小，所以 20–50 步就能出高质量结果，甚至可蒸馏到 1–4 步。
• 统一条件的优点：文本、图像参考、深度图、动作序列都可以作为条件注入同一骨干，这直接支撑了「图像编辑 / 图生视频 / 动作生成」的统一下游。
• 与 VLM 的合流：生成式世界模型与多模态理解模型正在共享骨干（如 mixture-of-transformers：一部分负责推理「应该发生什么」，一部分负责生成「看起来是什么样」）。

2.3 动手练习与自测

1. 写出扩散的前向加噪公式 x_t = √ᾱ_t·x_0 + √(1−ᾱ_t)·ε，并说明训练目标为什么可以是预测 ε。
2. 为什么 DiT 替代 U-Net 能带来缩放收益？给出两个关键理由。
3. 写出 Flow Matching 的直线路径与速度目标，并解释为什么它采样步数更少。
4. ε / x0 / v 三种预测目标各在什么阶段更稳？
5. 扩散与 Flow Matching 在数学上是什么关系？

3. 视频生成：一致性是最大的难题

3.1 三类失效与对应技术

经验上，视频一致性随时长近似指数衰减：短视频看不出差别，一旦拉到 60 秒，误差会逐帧累积，把「偶然好看」暴露成「结构性崩坏」。所以评测视频模型时，时长与连续镜头数比单帧画质更能区分高下。

3.2 动手练习与自测

1. 视频生成的三类核心失效是什么？各对应什么技术手段？
2. 为什么「能生成好看短视频」不足以判断视频模型能否进生产？
3. 长视频的对象持久性（object permanence）为什么是分水岭？
4. 「可被动作条件化」为什么被视为世界模型与视频生成的分界？
5. 身份保持（角色一致）可用哪些手段提升？

4. 语音与全模态（Omni）

4.1 三条技术路线

• ASR：Whisper 系仍是开源主力；浏览器端可用小模型（如 whisper-tiny/base 的 ONNX 量化版）做本地识别。
• TTS：从拼接式到神经声码器，再到零样本声音克隆。合规上必须做声纹授权与防滥用（这是监管关注点）。
• 实时性：语音交互的体验门槛是端到端延迟 < 1s，这要求流式 ASR + 流式生成 + 流式 TTS 全链路配合。
• 评测：ASR 看 WER；TTS 看自然度（MOS）与相似度；对话看轮次打断（barge-in）与响应延迟。

4.2 动手练习与自测

1. 三条语音技术路线各适合什么场景？给出选择判据。
2. 实时语音交互的体验门槛时延是多少？如何拆解各环节预算？
3. ASR / TTS / 语音对话分别用什么指标评测？
4. 声音克隆有哪些合规红线？工程上如何落实？
5. 端到端语音模型为什么能实现「打断（barge-in）」？

5. 多模态数据与部署

5.1 数据形态与质量

python# 图文对质量过滤：CLIP 相似度 + 文本启发式，是性价比最高的清洗组合
import torch

@torch.no_grad()
def filter_image_text(pairs, clip_model, clip_proc, min_score=0.25, min_len=8):
    kept = []
    for img, text in pairs:
        if len(text.strip()) < min_len:            # 文本太短（"image1.jpg"）直接丢
            continue
        if text.strip().lower() in {"图片", "照片", "image", "photo", "untitled"}:
            continue
        inputs = clip_proc(text=text, images=img, return_tensors="pt", padding=True)
        score = clip_model(**inputs).logits_per_image.item()
        if score >= min_score:                     # 图文相关性达标
            kept.append((img, text))
    return kept

# 经验：真实网页图文对里常有 40%+ 的低质量样本，不过滤直接训练会显著伤害模型

5.2 部署与成本核算

5.3 动手练习与自测

1. 真实网页图文对里低质量样本占比大概多少？不做过滤直接训练会怎样？
2. 写出图文质量过滤的组合手段（至少两种信号）。
3. 交错图文（interleaved）数据为什么是原生多模态预训练的核心？
4. 视觉 token 成本可从哪几个方向优化？各降多少量级？
5. 合成数据用于多模态训练有什么风险？如何缓解？

6. 对比学习与 CLIP：对齐图文空间

6.1 InfoNCE：把「匹配」变成分类

CLIP 用对比学习把图像与文本编码到同一向量空间：正样本对（同一图的 caption）靠近，负样本对远离。其核心损失是 InfoNCE：把「从一堆里挑出正确配对」建模为 N 分类。

text# InfoNCE（NT-Xent 变体）
# 一个 batch 有 N 个图文对；对第 i 对：
#   分子: exp( sim(I_i, T_i) / τ )          # 正样本相似度(温度缩放)
#   分母: Σ_j exp( sim(I_i, T_j) / τ )       # 含 1 个正 + (N-1) 个负(其他图)
#   L_i = -log( 分子 / 分母 )
# 对称：图像->文本 与 文本->图像 两方向各算一次取平均
# sim = 余弦相似度；τ(温度) 典型 0.01~0.1，控制分布锐度

6.2 CLIP 零样本分类怎么算

CLIP 最强的能力是零样本分类：把类别名写成 prompt（"a photo of a {class}"），编码所有类别文本，再与图像编码算余弦相似度，取最高者。整个过程不需要任何下游训练数据。

python# CLIP 零样本分类（伪代码）
import torch.nn.functional as F

def clip_zero_shot(image, classes, image_enc, text_enc, prompts="{c}"):
    img_feat = F.normalize(image_enc(image), dim=-1)            # (1, D)
    texts = [prompts.format(c=c) for c in classes]
    txt_feat = F.normalize(text_enc(texts), dim=-1)             # (C, D)
    logits = img_feat @ txt_feat.T * 100.0                      # 相似度(温度放大)
    return classes[logits.argmax()]                             # 取最相似类

# 进阶：prompt 集成("a photo of a {c}", "a drawing of a {c}"...) 提升鲁棒性

SigLIP 的改进：把 CLIP 的 softmax（归一化）换成sigmoid 损失，对每个 (image, text) 对独立做二分类（是否匹配），不再依赖 batch 内归一化。好处是不依赖超大 batch，小 batch 也能训好，且对长尾/难负样本更鲁棒——这正是 2025–2026 年许多 VLM 视觉编码器的首选（SigLIP-2 等）。

6.3 动手练习与自测

1. 写出 InfoNCE 的分子与分母，并解释温度 τ 的作用与典型取值。
2. CLIP 为什么依赖极大 batch？不维护负样本库是怎么做到的？
3. SigLIP 相对 CLIP 的 sigmoid 损失改进在哪里？为什么它对 batch size 不敏感？
4. 写出 CLIP 零样本分类流程（类别 prompt → 文本编码 → 相似度 → argmax）。
5. prompt 集成（多模板平均）为什么能提升零样本鲁棒性？

7. ViT：把图像当 token 序列

7.1 patch embedding、class token 与位置编码

ViT 的核心思想：把图像切成 P×P 的 patch，每个 patch 拉平后过线性层变成一个 token，再像文本一样喂进 Transformer。于是「图像理解」被统一成「token 序列理解」。

python# ViT 前向的极简版（patch -> token -> Transformer）
import torch, torch.nn as nn

class PatchEmbed(nn.Module):
    def __init__(self, img=224, patch=14, d=768):
        super().__init__()
        self.n = (img // patch) ** 2          # 224/14 = 16 -> 256 个 token
        self.proj = nn.Conv2d(3, d, patch, stride=patch)   # 卷积即「无重叠切图+投影」
    def forward(self, x):
        return self.proj(x).flatten(2).transpose(1, 2)      # (B, n_tokens, d)

# 拼接 [CLS] + 256 个 patch token，加位置编码，过 Transformer
# 输出取 [CLS] 做分类，或取全部 token 给 VLM 用

7.2 变体与高效化：Swin 的窗口注意力

标准 ViT 是全局注意力，复杂度 O(N²)（N=patch 数），高分辨率下爆炸。Swin Transformer 引入窗口注意力（只在局部窗口内做自注意力，再跨窗口移位通信），把复杂度降到近线性，且天然支持层次化特征（适合检测/分割）。

2026 年的 VLM 视觉塔趋势：SigLIP-2 / InternViT 等超大 ViT（2B–6B 参数）作编码器，再接轻量 projector 到 LLM。视觉塔越大，细粒度感知与 OCR 越强，但视觉 token 数随之成为成本核心（见 1.1）。

7.3 动手练习与自测

1. ViT 的 patch embedding、[CLS] token、位置编码各起什么作用？
2. 为什么 ViT 在 ImageNet-1k 上打不过 ResNet，却在 JFT-300M 上反超？
3. Swin 的窗口注意力把复杂度从 O(N²) 降到近似多少？为什么可行？
4. 2026 年 VLM 视觉塔的主流选择是什么？视觉塔越大带来什么代价？
5. 224×224、patch=14 时序列有多少 token？

8. VLM 架构深入：连接器、分辨率与训练阶段

8.1 连接器方案对比

VLM 三段式 = 视觉编码器 + 连接器 + LLM。连接器负责把视觉特征「翻译」成 LLM 能懂的 token，方案差异直接决定信息保真度与参数量。

8.2 分辨率处理：切图与动态分辨率

固定低分辨率会丢细节。主流做法是动态分辨率 + 切图（tiling）：原图按宽高比切成多个子图（tile），每个 tile 编码成若干视觉 token，再拼回序列；超分辨率信息作为单独 tile。这样兼顾「看清全局」与「看清局部」。

python# 动态切图：按原图比例切若干 tile，每块独立编码
def dynamic_tiles(img, base=336, max_tiles=12):
    w, h = img.size
    scale = base / min(w, h)
    tw, th = int(w * scale), int(h * scale)
    cols, rows = max(1, round(tw / base)), max(1, round(th / base))
    tiles = []
    for r in range(rows):
        for c in range(cols):
            tile = img.crop((c*base, r*base, (c+1)*base, (r+1)*base))
            tiles.append(tile)
    return tiles[:max_tiles]            # 超出的丢弃或下采样

# token 数 = Σ tile 的 patch 数；动态分辨率下可能从 256 涨到 1024+

8.3 代表模型差异

8.4 训练三阶段：各自对齐什么

关键洞察：第一阶段只解决「视觉特征能被 LLM 读懂」，第二阶段解决「模型真的会用视觉信息做多种任务」，第三阶段解决「按用户指令精准输出」。跳过任一阶段都会在对应能力上出现明显短板（如只做一阶段会「看得见但不会用」）。

8.5 动手练习与自测

1. 四种连接器（线性 / MLP / Q-Former / Perceiver）各适合什么需求？
2. 动态分辨率 + 切图解决了什么问题？代价是什么？
3. 列出 VLM 训练的三阶段，以及各阶段冻结什么、对齐什么。
4. 为什么只做第一阶段会出现「看得见但不会用」？
5. Gemini 3 的原生多模态与「ViT + LLM 拼接」的本质区别是什么？

9. 视频理解：帧、时序与 token 爆炸

9.1 帧采样与时序位置编码

视频 = 帧序列。直接对每帧做 ViT 会 token 爆炸（1 分钟 30fps = 1800 帧）。做法是帧采样：均匀/关键帧抽样到 K 帧（常 8–32 帧），每帧取若干 token，再在时序维做位置编码让模型知道先后顺序。

9.2 长视频的 token 爆炸与压缩

长视频的瓶颈是token 数 = 帧数 × 每帧 token。压缩手段：① 降低帧率（关键帧优先）；② 每帧用 Perceiver/重采样压到固定 token；③ 用 3D VAE 在时间维压缩（视频生成同款思路）；④ 分层——先粗看全片摘要，再对 relevant 片段精看。

python# 视频 token 预算估算
def video_tokens(n_frames, tokens_per_frame, sampler="uniform", k=16):
    picked = min(k, n_frames) if sampler == "uniform" else n_frames
    return picked * tokens_per_frame      # 例如 16 帧 * 256 = 4096 token

# 30s@8fps=240 帧 -> 若只取 16 帧、每帧 256 token = 4096
# 若不采样 240*256 = 61440 token —— 直接撑爆上下文

python# 用 3D VAE 压缩后的真实 token 预算(空间 /8, 时间 /4, patch 2)
def video_tokens(F, H, W, sd=8, td=4, patch=2):
    lf = 1 + (F - 1)//td          # 潜空间帧数(首帧不压缩)
    lh, lw = H//sd, W//sd
    return lf * (lh//patch) * (lw//patch)

for F, H, W in [(16, 480, 832), (49, 480, 832), (121, 720, 1280)]:
    print(F, '帧', H, 'x', W, '->', video_tokens(F, H, W), 'tokens')

# 预期输出:
# 16 帧 480 x 832 -> 6240 tokens
# 49 帧 480 x 832 -> 20280 tokens
# 121 帧 720 x 1280 -> 111600 tokens

9.3 动手练习与自测

1. 30 秒 8fps 视频共多少帧？若全帧每帧 256 token 是多少？均匀采样到 16 帧后是多少？
2. 帧采样的三种策略各有什么取舍？
3. 时序位置编码（Temporal PE）解决什么问题？
4. 长视频 token 爆炸的四种压缩手段是什么？
5. 为什么「要不要看视频、看多少帧」比选模型更重要？

10. 语音与音频：从 ASR 到端到端对话

10.1 Whisper：编码器-解码器与多任务格式

Whisper 用编码器-解码器做语音识别：音频 mel 谱过 encoder，decoder 自回归生成文本。它的妙处是多任务格式——在输入前加特殊 token（如 <|startoftranscript|>、语言标记、<|transcribe|>/<|translate|>）来指定任务（转录/翻译/带时间戳），一套权重覆盖多语言多任务。

python# Whisper 的多任务条件 (伪代码)
# 输入: [<|startoftranscript|>, <|en|>, <|transcribe|>, <|notimestamps|>] + mel
# 输出: 对应语言的文本
# 关键: 这些条件 token 让同一个 decoder 学会「切换到不同任务模式」
result = whisper_model.transcribe(
    audio, language="en", task="transcribe",  # 也可 task="translate"
)
# 端到端时延取决于模型尺寸: tiny(32MB) < base < small < ... < large-v3

10.2 语音 LLM 与端到端对话

2026 年的实时语音模型（如 GPT-4o 语音、Gemini 原生语音、各家 Omni 模型）走端到端：语音切成离散 token 或连续表征，与文本 token 在同一个 Transformer 里联合建模，能在用户说话中途就「听、想、回」，实现打断（barge-in）与自然轮次。体验门槛是端到端延迟 < 1s。

10.3 动手练习与自测

1. Whisper 的多任务格式靠什么实现？一套权重如何覆盖转录 / 翻译 / 时间戳？
2. 实时本地 ASR 与精度优先各该选什么尺寸的模型？
3. 写出一条流式语音对话的端到端时延预算（各环节毫秒数）。
4. 语音 LLM 与级联式在「副语言信息」上的差别是什么？
5. 长音频识别为什么需要重叠窗口？

11. 扩散模型数学进阶：引导、加速与潜空间

11.1 预测目标：ε / x0 / v

三者可相互转换（给定 α_t, σ_t），只是参数化不同。v-prediction 在极噪步更数值稳定，且和 Flow Matching 的速度场同构，是 2025–2026 许多视频/高分辨率模型的选择。

11.2 分类器无关引导（CFG）

CFG 是「文本对齐」的关键：同时跑有条件与无条件两次预测，按引导强度 w 外推：

text# CFG：在条件与无条件预测之间插值
# ε_hat = ε_uncond + w * ( ε_cond - ε_uncond )
# w(引导强度): 越大越贴合 prompt，但多样性和自然度下降
#   经验: w=3~7 常用；w>10 易过饱和、文字伪影、构图崩
# 实现: 把空 prompt 也拼进 batch，一次前向得两个输出，再线性组合

11.3 DDIM 加速与潜空间扩散

DDIM 用非马尔可夫确定性采样，把 1000 步 DDPM 压到 20–50 步且质量损失小。而潜空间扩散（Latent Diffusion）先在 VAE 把图像压到 8×8 倍小的潜空间再扩散——把像素级去噪换成潜变量级去噪，算力降约 1/64（8²），这是 SD 系列能跑在消费级 GPU 的根本。

text# 为什么 latent diffusion 更高效
# 像素空间: 512x512x3 -> U-Net 在 (512,512) 上算注意力 O(HW)^2
# 潜空间   : 64x64x4  (VAE 压缩 8x) -> 注意力 token 数降 64 倍
# 代价: VAE 编码/解码的一次性开销 + 潜空间可能丢极细高频细节
# DDIM 采样: x_{t-1} = ...(确定性, 可跳步) -> 步数 1000->25 仍可用

11.4 动手练习与自测

1. 写出 CFG 的外推公式，并说明 w 取 3~7 与 >10 的差别。
2. DDIM 把 DDPM 的 1000 步压到多少步？为什么可以跳步？
3. 潜空间扩散为什么比像素空间省算力？给出压缩倍数与注意力 token 数对比。
4. CFG 在视频生成里为什么还需要时域引导？
5. ε / x0 / v 哪种参数化与 Flow Matching 统一？

12. Flow Matching / Rectified Flow 深入

12.1 为什么训练更直

扩散的路径是「加噪→去噪」的随机过程，轨迹弯曲、需要多步。Rectified Flow 把路径直接定义成噪声到数据的直线插值，训练目标是沿这条直线的常速场。路径越直，采样步数越少——可蒸馏到 1–4 步，且训练目标更简单稳定。

text# Rectified Flow 的路径与速度
# 直线路径:  x_t = (1-t)*x0 + t*x1     (t:0->1, x0=噪声, x1=数据)
# 速度目标:  v = dx/dt = x1 - x0       (沿直线是常数!)
# 训练:  MSE( model(x_t, t), x1 - x0 )
# 采样: 从 x0 出发，沿学到的 v 积分(几步即可，因为路径近直线)
# 与 DDPM 关系: 可视为把「弯曲的加噪路径」整流成「直线」

python# Flow Matching 最小可运行示例（纯标准库）：把噪声推向 N(2, 0.7)
import random, statistics
random.seed(0)
def data(n):  return [random.gauss(2.0, 0.7) for _ in range(n)]
N = 4000
x0 = [random.gauss(0.0, 1.0) for _ in range(N)]   # 噪声
x1 = data(N)                                       # 数据
t  = [random.random() for _ in range(N)]
xt = [(1.0 - ti)*a + ti*b for ti, a, b in zip(t, x0, x1)]
vt = [b - a for a, b in zip(x0, x1)]               # 真速度 = x1 - x0 (常数)

def lstsq3(A, y):                                  # 正规方程 + 高斯消元
    n = 3
    AtA = [[sum(r[i]*r[j] for r in A) for j in range(n)] for i in range(n)]
    Aty = [sum(r[i]*yy for r, yy in zip(A, y)) for i in range(n)]
    M = [row[:] + [Aty[i]] for i, row in enumerate(AtA)]
    for c in range(n):
        p = max(range(c, n), key=lambda r: abs(M[r][c]))
        M[c], M[p] = M[p], M[c]
        pv = M[c][c]
        for j in range(c, n+1): M[c][j] /= pv
        for r in range(n):
            if r != c:
                f = M[r][c]
                for j in range(c, n+1): M[r][j] -= f*M[c][j]
    return [M[i][n] for i in range(n)]

w = lstsq3([[1.0, ti, xi] for ti, xi in zip(t, xt)], vt)
print('coef [bias, t, x]:', [round(v, 3) for v in w])

def sample(steps):                                 # Euler 积分
    x = [random.gauss(0.0, 1.0) for _ in range(20000)]
    dt = 1.0 / steps
    for i in range(steps):
        tt = i*dt
        x = [xi + dt*(w[0] + w[1]*tt + w[2]*xi) for xi in x]
    return x
for k in (1, 2, 4, 8):
    x = sample(k)
    print('steps', k, 'mean', round(statistics.mean(x), 3),
          'std', round(statistics.pstdev(x), 3))

# 预期输出(近似):
# coef [bias, t, x]: [1.984, 1.066, -0.524]
# steps 1 mean 1.985 std 0.476
# steps 2 mean 1.997 std 0.541
# steps 4 mean 1.996 std 0.57
# steps 8 mean 1.997 std 0.583

读这三个数：均值目标 2.0——1 步就把均值推到 1.985，说明直线路径的单步积分误差极小；再增加到 8 步，均值几乎不动（1.997），分布只做微调。这正是 FLUX / SD3 敢把采样压到 4 步甚至更少、并进一步蒸馏到 1–2 步的原因。对比之下，DDPM 的弯曲路径若只用 1 步，图像几乎是噪声。

12.2 动手练习与自测

1. 写出 Rectified Flow 的直线路径与速度目标，并说明为什么速度是常数。
2. 为什么路径越直采样步数越少？可蒸馏到几步？
3. Rectified Flow 相对 DDPM 的训练优势是什么？
4. FLUX / SD3 采用什么训练目标？
5. 「扩散」与「流匹配」在数学上如何统一？

13. DiT：用 Transformer 替代 U-Net

13.1 adaLN-Zero 条件注入

DiT 把 U-Net 换成 Transformer：在 patch 上做注意力。条件（时间步 t、文本、类别）通过 adaLN-Zero 注入——用条件预测 LayerNorm 的 scale/shift（以及 gate），且初始化为零，使残差分支从「恒等」开始，训练更稳、条件可控。

text# adaLN-Zero: 用条件预测归一化参数
# 输入条件 c (如时间步 t 的编码)
#   (shift, scale, gate) = MLP_zero_init(c)      # 零初始化 MLP
# 每个 DiT block 内:
#   h = x * (1 + scale) + shift                  # 自适应 LayerNorm
#   h = Attention(h)
#   h = x + gate * h                             # gate 初始 0 -> 先恒等
# 文本条件: 走 cross-attention 或 concate 到条件 c 一起进 adaLN

python# adaLN-Zero 为什么稳: gate=0 时整个 block 是恒等映射
import random
random.seed(1)
def layernorm(x):
    m = sum(x)/len(x)
    v = sum((xi-m)**2 for xi in x)/len(x)
    return [(xi-m)/((v+1e-5)**0.5) for xi in x]

d = 4
x = [random.gauss(0, 1) for _ in range(d)]

def block(x, shift, scale, gate, fb=0.5):
    h = [xi*(1.0+s)+sh for xi, s, sh in zip(layernorm(x), scale, shift)]
    attn = [hi*fb for hi in h]                     # 占位子层
    return [xi + gate*a for xi, a in zip(x, attn)]

o0 = block(x, [0.0]*d, [0.0]*d, 0.0)                # 零初始化
print('gate=0  -> max|out-x| =', round(max(abs(a-b) for a, b in zip(o0, x)), 6))
o1 = block(x, [0.2]*d, [0.1]*d, 0.8)                # 训练后
print('gate=0.8 -> max|out-x| =', round(max(abs(a-b) for a, b in zip(o1, x)), 3))

# 预期输出:
# gate=0  -> max|out-x| = 0.0
# gate=0.8 -> max|out-x| = 0.536

这个 0.0 就是 adaLN-Zero 的核心：训练第一步时，所有条件分支贡献为 0，整层退化成恒等映射，于是深层 Transformer 不会一上来就被随机的条件调制破坏，梯度能平稳传播。随着训练推进，gate 从 0 长到 0.5–1.5，条件才逐步「接管」——这也是绝大多数 2026 的 DiT 视频/图像骨干（FLUX、Wan、HunyuanVideo）默认开 zero-init 的原因。

13.2 动手练习与自测

1. adaLN-Zero 如何注入条件？为什么 gate 初始化为 0？
2. DiT 从 XS 到 XL，相对计算与生成质量大致如何变化？
3. DiT 的 scaling 表现为什么优于 U-Net？
4. 文本条件在 DiT 里怎么进？两种常见方式是什么？
5. 为什么 Sora / Veo / FLUX 都转向 DiT 骨干？

14. 文生图与文生视频：架构演进与难点

14.1 文生图架构演进：SD → SDXL → FLUX

演进主线：U-Net → DiT、DDPM → Rectified Flow、文本编码器从 CLIP 升级到 T5/多模态。结果是文本对齐更强、细节更真、采样更快。

14.2 文生视频：时空一致性、物理合理、时长

视频生成（Sora / Veo / Wan / 可灵）在图像生成之上叠加三个难度：① 时空一致性（人物/物体跨帧不变形、不闪）；② 物理合理性（运动符合重力/碰撞/遮挡）；③ 时长与记忆（长镜头不漂移）。

14.3 动手练习与自测

1. 文生图架构从 SD → SDXL → FLUX 的演进主线是什么（骨干 / 目标 / 文本编码器）？
2. 文生视频在图像生成之上多了哪三个难度？
3. Sora 与 Wan 在上下文 / 时长与部署方式上的差别是什么？
4. 「统一理解与生成」的方向为什么重要？
5. 身份保持与长镜头漂移各用什么手段缓解？

15. 多模态评测：测什么、局限在哪

15.1 主流基准测什么

15.2 评测的局限与自建

• 选择题偏差：单选可被策略性猜测抬高分数，应辅以开放式 + 人工/LLM 评判。
• 污染：公开基准同样面临训练数据泄露，需污染检查。
• 细粒度缺失：幻觉率、OCR 准确率、空间关系这些弱项常不在总分之内，要单测。
• 自建优先：用你业务分布的真实样本（文档、图表、监控帧）建私有评测，比刷公开榜更有意义——这也正是 Hamauls Orion M11「多模态理解与检索」要做的。

python# 自建多模态评测：按能力维度分桶，单独统计幻觉率
def evaluate_vlm(model, samples):
    # samples: [{"img":..., "q":..., "gold":..., "dim":..., "claimed":[...], "present":[...]}]
    from collections import defaultdict
    acc, tot = defaultdict(int), defaultdict(int)
    claimed_all, halluc_all = 0, 0
    for s in samples:
        pred = model.ask(s["img"], s["q"])
        tot[s["dim"]] += 1
        if normalize(pred) == normalize(s["gold"]):
            acc[s["dim"]] += 1
        claimed_all += len(s["claimed"])
        halluc_all += len(set(s["claimed"]) - set(s["present"]))   # 说了但图里没有
    for dim in tot:
        print(f"{dim}: acc={acc[dim]/tot[dim]:.2f} (n={tot[dim]})")
    print("幻觉率:", round(halluc_all / max(1, claimed_all), 3))

# 预期输出（示意）：
# ocr: acc=0.72 (n=40)
# count: acc=0.55 (n=30)      <- 计数是大弱项
# spatial: acc=0.63 (n=30)
# chart: acc=0.48 (n=25)      <- 图表读数最弱
# 幻觉率: 0.118               <- >0.05 需警惕, 业务需加外部校验

15.3 动手练习与自测

1. 多数基准偏「感知」还是「推理」？为什么这会导致误导？
2. 选择题型评测的偏差是什么？如何补足？
3. 自建评测集相比刷公开榜的价值是什么？
4. 幻觉率、OCR、空间关系这些弱项为什么常不在总分里？
5. M11 的多模态 RAG 相比纯文本 RAG 在含图表文档上的优势来自哪里？

项目里程碑

阶段练习项目

常见误区

• 不做分辨率与切图策略，导致视觉 token 爆炸，成本高到无法上线。
• 只看整体相似度评测，忽略幻觉率与细粒度感知，上线后频繁出错。
• 把图文对的网页数据直接用于训练，未做相关性过滤，模型学到大量噪声。
• 误以为 U-Net 仍是主流，不了解 DiT 的可扩展性与统一条件能力。
• 用「能生成好看短视频」判断视频模型可用性，忽略长镜头一致性与物理合理性。
• 把声音克隆能力当作纯技术问题，忽视授权与合规风险。
• 忽略多模态数据的许可与版权，训练数据来源不透明，为后续合规埋雷。

面试高频问题速答

VLM 的三种架构范式各有什么取舍？

投影式：视觉编码器 + 投影层 + LLM，实现简单、复用成熟 LLM、训练便宜，但跨模态交互浅，细粒度推理较弱。交叉注意力式：在 LLM 层间插入视觉交叉注意力，融合更深、对高分辨率细节更好，但结构改造复杂、训练与推理成本高。原生统一式：视觉与文本 token 在同一骨干做统一注意力，交互最深、可涌现视觉推理，但需要海量交错数据与算力。2026 年趋势指向原生统一。

为什么现代生成模型从 U-Net 转向 DiT？

两个原因：① 可扩展性——Transformer 能直接受益于缩放律，模型变大时生成质量持续提升，而 U-Net 的卷积归纳偏置在超大规模下收益有限；② 统一性——同一骨干可接受文本、图像、动作、相机轨迹等异构条件，从而支持视频生成、图像编辑与动作生成等统一下游，这是世界模型方向所必需的。

扩散模型和 Flow Matching 的关系？

两者都是「学一个从噪声到数据的变换」。扩散模型定义离散加噪步骤并学习去噪；Flow Matching 直接学习连续时间上的速度场，目标是把噪声点沿一条路径推到数据点。Flow Matching 训练更稳、采样步数更少、实现更简洁，因此在近两年的图像与视频模型中被广泛采用。它们在数学上可以视为同一家族的不同参数化。

视觉 token 为什么是成本关键？怎么优化？

视觉 token 数 ≈ (分辨率/切图尺寸)²。分辨率翻三倍，token 数涨九倍，而每个 token 都要过完整的注意力与 FFN，成本线性甚至更差地增长。优化手段：分辨率自适应（按任务需求降采样）、动态切图（只在需要看细节时切）、视觉 token 池化或重采样压缩、缓存重复图像、以及在路由层用小模型处理简单图像任务。

多模态模型最危险的失效模式是什么？怎么防？

视觉幻觉——描述图中不存在的内容，在医疗、金融、合规场景可能造成实际损害。防御：① 评测上单独统计幻觉率而不只报整体准确率；② 要求模型对不确定内容显式表达不确定或拒绝回答；③ 引入外部校验（OCR 引擎、结构化抽取后再比对）；④ 高风险场景用人工复核；⑤ 训练数据里加入「否定的样本」以降低过度描述倾向。

学习资源