DP · DiT · Flow Matching 三剑客

1.1 DDPM 原理：两个方向

前向过程 q（加噪，固定不学）

给干净数据 x₀ 逐步加高斯噪声，T 步后变纯噪声。单步：

关键技巧——任意步可一次性算出（reparameterization）：

反向过程 p_θ（去噪，要学的）

DDPM 的洞察：与其学均值 μ，不如学预测噪声 ε。简化后的训练目标：

1.2 采样：DDPM vs DDIM

其中 x̂₀ = (xₜ − √(1−ᾱₜ)·ε_θ)/√ᾱₜ 是当前估计的干净数据。下面 1.2b 专门讲透 DDIM。

1.2b 深入 DDIM：DDPM 为什么能从 1000 步压到 10 步

① 它解决什么问题

DDPM 推理要沿反向马尔可夫链一步步走，100~1000 步，每步一次网络前向——太慢，机器人根本没法实时（DP 要 10Hz）。DDIM (Song et al. 2021) 的目标：用同一个已训练好的 ε_θ，不重新训练，把采样压到 10~50 步。

② 核心洞察：训练目标其实不绑定"那条马尔可夫链"

DDPM 的训练 loss ‖ε − ε_θ‖² 只依赖边缘分布 q(xₜ|x₀)=√ᾱₜx₀+√(1−ᾱₜ)ε，并不关心 xₜ 与 xₜ₋₁ 之间具体怎么连。

Song 等人发现：可以构造一族非马尔可夫的前向过程，它们的边缘分布 q(xₜ|x₀) 完全相同（所以同一个 ε_θ 依然有效），但反向过程的随机性可调。用一个参数 σ 控制：

• x̂₀ = (xₜ − √(1−ᾱₜ)·ε_θ)/√ᾱₜ  ——用当前预测的噪声反推"干净数据估计"
• σ 最大 → 退化回 DDPM（随机马尔可夫）
• σ = 0 → DDIM：去掉随机项 σ·z，整个过程确定性

③ σ=0 带来两个好处

1. 确定性：同一噪声起点 → 同一输出（可复现、可插值）
2. 可跳步：既然不依赖马尔可夫的"逐步"假设，就能在时间步子集 {1000, 900, ..., 0} 上跳着走，10 步直达

④ 为什么 DDIM 是"概率流 ODE"——通往 Flow Matching 的桥

当 σ=0 且步长趋近无穷小时，DDIM 的离散更新收敛到一个常微分方程 (ODE)：

也就是说，DDIM 采样 = 用欧拉法解这条 ODE。而 Flow Matching 是直接学一条 ODE 的速度场。两者都在"解 ODE"，只是：

这就是 Tab 4 "统一视角"里"DDIM 与 FM 殊途同归"的精确含义——它们解的是同类 ODE，区别在路径直不直。

⑤ 代码：换 scheduler 即可，训练零改动

dp: diffusion_policy/workspace/* 配置 + policy 里的 noise_scheduler

# 训练时: DDPMScheduler, num_train_timesteps=100
noise_scheduler = DDPMScheduler(num_train_timesteps=100, ...)

# 推理时想加速: 直接换成 DDIMScheduler, 复用同一个 ε_θ 权重!
noise_scheduler = DDIMScheduler(num_train_timesteps=100, ...)
self.num_inference_steps = 16        # 只走 16 步

# conditional_sample 里的循环逻辑完全不变:
for t in scheduler.timesteps:                 # DDIM 只有 16 个 t
    model_output = model(trajectory, t, ...)  # 同一个网络
    trajectory = scheduler.step(model_output, t, trajectory).prev_sample
    #            ↑ scheduler.step 内部从 DDPM 公式换成 DDIM 公式 (σ=0)

1.2c DDPM / DDIM / Flow Matching 三者区别与联系

一张表看清

三句话理清关系

• DDIM ⊂ DDPM 生态：DDIM 不是新范式，是 DDPM 的"快速采样模式"。同一族公式里 σ 从大调到 0，DDPM 平滑变成 DDIM。
• DDIM 是 DDPM 通往 ODE 的桥：σ=0 让随机 SDE 退化成确定性 ODE，从此可以用 ODE 求解器(欧拉/RK)加速。
• FM 是"生来就是直路的 ODE"：DDIM 是把弯路当 ODE 解(将就)，FM 是训练时就修一条直路(根治)。所以 FM 步数能更少、更稳。

用"赶路"打个比方

对应到本仓库代码

DP 是"DDPM 训练 + DDIM 采样"的典型；π0/GR00T 是"FM 训练 + ODE 采样"。看懂这两行，就理解了当前动作生成的两条主流技术路线。

1.3 代码精读①：前向加噪 + 训练 loss

dp: diffusion_policy/policy/diffusion_unet_lowdim_policy.py

# ═══ 采样随机时间步 ═══
timesteps = torch.randint(0, 100, (bsz,)).long()   # t ~ U(0,100)
noise = torch.randn(trajectory.shape)              # ε ~ N(0,I)

# ═══ 前向加噪 (一步到位, 对应公式 xₜ=√ᾱ·x₀+√(1-ᾱ)·ε) ═══
noisy_trajectory = self.noise_scheduler.add_noise(
    trajectory, noise, timesteps)
#   diffusers 内部: √ᾱₜ·trajectory + √(1-ᾱₜ)·noise

# ═══ 预测噪声 ═══
pred = self.model(noisy_trajectory, timesteps, global_cond=obs_cond)

# ═══ 目标 = 噪声本身 (epsilon prediction) ═══
target = noise   # prediction_type == 'epsilon'
loss = F.mse_loss(pred, target)   # 就是公式里的 ‖ε - ε_θ‖²

1.4 代码精读②：反向去噪采样

dp: diffusion_policy/policy/diffusion_unet_lowdim_policy.py · conditional_sample

trajectory = torch.randn(size=shape)          # xₜ = 纯噪声起点
scheduler.set_timesteps(self.num_inference_steps)  # 推理 10-16 步

for t in scheduler.timesteps:                 # t 从大到小
    model_output = model(trajectory, t, global_cond=obs_cond)  # 预测 ε
    trajectory = scheduler.step(              # xₜ → xₜ₋₁
        model_output, t, trajectory).prev_sample
# 循环结束 → trajectory 是干净动作 x₀

scheduler.step() 内部就是 DDPM/DDIM 的那条反向公式。换 scheduler（DDPMScheduler→DDIMScheduler）就切换采样方式，训练代码完全不用动——这是范式与实现解耦的好例子。

1.5 DP 如何把"生成图片"变成"生成动作"

2.1 DiT 是什么 & 为什么

DiT (Diffusion Transformer, Peebles & Xie 2022)：把扩散模型里那个"去噪网络"从 U-Net 换成 Transformer。

核心问题：Transformer 怎么吃"扩散步 t"和"条件 c"？答案是 AdaLN（Adaptive Layer Norm）——把 (t, c) 编码成每层 LayerNorm 的 scale/shift。

2.1b 重要澄清：DiT + Flow Matching 为什么不重复？

误解的根源在一句话：DiT ≠ "用了 DDPM"。DiT 只是一个网络结构（Transformer 骨架 + AdaLN 条件注入），它本身不含任何加噪/去噪逻辑，也不含任何范式。DiT 原论文恰好用 DDPM 来训练它，但那只是作者当时的选择，不是 DiT 的一部分。

关键：网络 ≠ 范式，是两层独立的东西

把一个去噪/预测网络的接口抽象出来，它长这样：

网络不知道、也不关心这个输出张量"是什么含义"。含义完全由外面的训练 loss 赋予：

用代码看最清楚

看 starVLA 的 DiT.forward（Tab 2.4 的代码）——它只是：编码时间步 → 过 N 层 Transformer → 投影输出。全程没有"加噪/去噪/ε/速度"任何字样，就是个"吃 (xₜ,t,c) 吐一个张量"的纯函数：

class DiT(...):
    def forward(self, hidden_states, encoder_hidden_states, timestep):
        temb = self.timestep_encoder(timestep)
        for block in self.transformer_blocks:
            hidden_states = block(hidden_states, ..., temb=temb)
        return self.proj_out_2(...)   # 只是输出张量, 不含任何范式语义

"含义"在外面的 action head 里才被赋予。同一个 self.model（DiT），换一行 loss 就切换范式：

# ── FM 写法 (starVLA 现状) ──
velocity = actions - noise                    # 目标定义成"速度"
pred = self.action_decoder(self.model(...))   # self.model 就是 DiT
loss = ((pred - velocity) ** 2).mean()        # ← 这行让 DiT 输出=速度

# ── 改成 DDPM 写法 (DiT 类一字不改) ──
target = noise                                # 目标改成"噪声"
pred = self.action_decoder(self.model(...))   # 同一个 DiT
loss = ((pred - target) ** 2).mean()          # ← 这行让 DiT 输出=噪声

所以 "DiT + FM" 没有重复——两者干的是不同的活

FM 负责"出题和判分"，DiT 负责"做题"。两件事完全不重叠，反而缺一不可——FM 需要一个网络来预测速度场，DiT 正好胜任。"DiT + FM" = 用 Transformer 这个工具，去做 FM 这套题。

一个类比：菜谱 vs 厨具

2.2 AdaLN 公式

普通 LayerNorm：LN(x) = γ·norm(x) + β，γ/β 是固定可学参数。

AdaLN：让 γ/β 由条件动态生成：

这样每个扩散步、每个条件，都会调制出不同的归一化行为。是把条件注入 Transformer 的标准做法，等价于 CNN 里的 FiLM（见 DP 学习课）。

2.3 代码精读①：DP 仓库的 Transformer 去噪器

dp: diffusion_policy/model/diffusion/transformer_for_diffusion.py

DP 的 Transformer 变体用 encoder-decoder 结构（条件做 memory，动作做 target）：

def forward(self, sample, timestep, cond=None):
    # sample: [B,Tp,Da] 噪声动作; timestep: 扩散步; cond: [B,To,cond_dim] 观测
    time_emb = self.time_emb(timesteps).unsqueeze(1)  # [B,1,n_emb] 扩散步嵌入

    input_emb = self.input_emb(sample)                # 动作 → token

    # ═══ encoder: 把 (时间步 + 观测) 编码成 memory ═══
    cond_embeddings = time_emb
    if self.obs_as_cond:
        cond_obs_emb = self.cond_obs_emb(cond)        # 观测 → token
        cond_embeddings = torch.cat([time_emb, cond_obs_emb], dim=1)
    x = cond_embeddings + self.cond_pos_emb
    memory = self.encoder(x)                          # [B, T_cond, n_emb]

    # ═══ decoder: 动作 token 交叉注意 memory ═══
    x = input_emb + self.pos_emb
    x = self.decoder(
        tgt=x, memory=memory,
        tgt_mask=self.mask,          # 因果掩码: 动作只看自己和之前
        memory_mask=self.memory_mask
    )
    x = self.head(x)                 # → [B,Tp,Da] 预测噪声
    return x

2.4 代码精读②：starVLA 的标准 DiT（AdaLN 版）

starVLA: starVLA/model/modules/action_model/flow_matching_head/cross_attention_dit.py

class AdaLayerNorm(nn.Module):
    def forward(self, x, temb):
        temb = self.linear(self.silu(temb))      # 条件 → 2×dim
        scale, shift = temb.chunk(2, dim=1)       # 拆成 scale / shift
        x = self.norm(x) * (1 + scale[:, None]) + shift[:, None]  # AdaLN!
        return x

class DiT(...):
    def forward(self, hidden_states, encoder_hidden_states, timestep, ...):
        temb = self.timestep_encoder(timestep)    # 扩散步 → 嵌入

        for idx, block in enumerate(self.transformer_blocks):
            if idx % 2 == 1 and self.config.interleave_self_attention:
                # 奇数层: self-attn (动作 token 互相看)
                hidden_states = block(hidden_states, encoder_hidden_states=None, temb=temb)
            else:
                # 偶数层: cross-attn (动作 token 看 VLM/观测特征)
                hidden_states = block(hidden_states,
                    encoder_hidden_states=encoder_hidden_states, temb=temb)

        # 输出层也用 AdaLN 调制
        shift, scale = self.proj_out_1(F.silu(temb)).chunk(2, dim=1)
        hidden_states = self.norm_out(hidden_states)*(1+scale[:,None])+shift[:,None]
        return self.proj_out_2(hidden_states)

2.5 DiT vs U-Net 对比

注意 FiLM 和 AdaLN 是同一思想的两种实现：用条件生成 scale/shift 去调制特征，只是一个调卷积输出、一个调 LayerNorm。

3.1 Flow Matching 的核心思想

DDPM 走的是一条"加噪马尔可夫链"，弯弯曲曲。Flow Matching (FM) 问：能不能让"噪声→数据"走直线？

3.2 公式：条件 FM / Rectified Flow

最常用的是线性插值路径（Rectified Flow）。给数据 x₁ 和噪声 x₀~N(0,I)：

这条直线的速度（对 t 求导）是常数：

训练目标——让网络预测这个速度：

推理——从噪声 x₀ 出发解 ODE（欧拉法，几步即可）：

3.3 DDPM vs Flow Matching 对照

3.4 代码精读①：starVLA 的 FM 训练

starVLA: starVLA/model/modules/action_model/GR00T_ActionHeader.py · forward

def forward(self, vl_embs, actions, state=None, ...):
    # ═══ 采样噪声 + 时间步 ═══
    noise = torch.randn(actions.shape)            # x₀ ~ N(0,I)
    t = self.sample_time(...)                     # t ~ Beta(1.5,1.0), 偏向小t
    t = t[:, None, None]

    # ═══ 线性插值构造 noisy action (FM 路径) ═══
    noisy_trajectory = (1 - t) * noise + t * actions   # xₜ=(1-t)x₀+t·x₁
    velocity = actions - noise                          # 真实速度 v=x₁-x₀

    # ═══ DiT 预测速度 ═══
    t_discretized = (t[:,0,0] * self.num_timestep_buckets).long()
    action_features = self.action_encoder(noisy_trajectory, t_discretized)
    ... # 拼接 state / future tokens
    model_output = self.model(                    # 这个 model 就是 DiT!
        hidden_states=sa_embs,
        encoder_hidden_states=vl_embs,            # 观测/VLM 特征做 cross-attn
        timestep=t_discretized)
    pred = self.action_decoder(model_output)

    # ═══ FM loss: ‖v - v_θ‖² ═══
    loss = ((pred[:, -actions.shape[1]:] - velocity) ** 2).mean()
    return loss

3.5 代码精读②：starVLA 的 FM 推理（ODE 欧拉）

starVLA: GR00T_ActionHeader.py · predict_action

actions = torch.randn(B, action_horizon, action_dim)  # x₀ 噪声起点
num_steps = self.num_inference_timesteps              # 如 4 步
dt = 1.0 / num_steps

for t in range(num_steps):
    t_cont = t / num_steps                            # 0, 0.25, 0.5, 0.75
    t_disc = int(t_cont * self.num_timestep_buckets)
    action_features = self.action_encoder(actions, t_disc)
    ...
    model_output = self.model(hidden_states=sa_embs,
        encoder_hidden_states=vl_embs, timestep=t_disc)
    pred_velocity = self.action_decoder(model_output)[:, -action_horizon:]
    actions = actions + dt * pred_velocity            # 欧拉积分! x += Δt·v
return actions                                        # 干净动作

对照公式 x ← x + Δt·v，4 步就从噪声积分到动作。比 DDPM 的几十步快一个量级。

3.6 openpi 里的 FM（注意 t 方向相反）

openpi: src/openpi/models/pi0.py · compute_loss / sample_actions

# 训练 (注意 t=1 是噪声, 与 starVLA 相反!)
time = beta(1.5, 1) * 0.999 + 0.001
x_t = time * noise + (1 - time) * actions   # t=1→noise, t=0→action
u_t = noise - actions                        # 速度方向也跟着反
v_t = model(x_t, time, ...)
loss = mean((v_t - u_t)²)

# 推理: dt 为负, 从 t=1 积分到 t=0
dt = -1.0 / num_steps
x = noise
for step: x = x + dt * v_t   # 反方向积分

4.1 统一视角：都是 SDE/ODE 的离散化

DDPM 和 Flow Matching 看似不同，其实是同一个连续过程的两种刻画。生成可以统一写成一条微分方程，从噪声演化到数据：

• DDPM = 这个 SDE（随机微分方程） 的特定离散化，含随机项 dW，预测噪声 ε（≈ 分数 ∇log p）
• DDIM = 去掉随机项后对应的 概率流 ODE，所以确定性、可跳步
• Flow Matching = 直接学这条 ODE 的速度场 v，并选最简单的直线路径

4.2 score（分数）、噪声 ε、速度 v 的换算

三者可互相换算（在给定路径下）。例如 DDPM 的 ε_θ 与分数差一个 −1/√(1−ᾱₜ) 因子；线性路径下速度 v 与 ε、x₀ 也有线性关系。它们是同一信息的不同参数化。

4.3 把四个概念拼回去：每个方法是怎么组合的

读到任何一个动作生成方法，都可以用这张表的五栏去拆解它：范式 / 预测量 / 架构 / 采样 / 条件注入。

4.4 条件注入方式横向对比

FiLM 与 AdaLN 本质相同（生成 scale/shift 调制特征），区别只是调制对象。扩散步 t 常走 AdaLN/FiLM，复杂观测常走 cross-attn 或 token 拼接。

5.1 方法树：从三个底座长出的家族

【范式层】
DDPM(2020) ──┬── DDIM(2021) 快速采样
             ├── Score SDE(2021) 统一理论
             └── Flow Matching / Rectified Flow(2022-23) 直线路径
                      │
                      └── Consistency Models / 蒸馏 → 1步生成

【架构层】
U-Net ──► DiT(2022) ──┬── PixArt, SD3 (图像)
                       ├── 视频 DiT (Sora类)
                       └── 动作 DiT (GR00T, π0 动作头)

【机器人应用层】
Diffusion Policy(2023, DDPM+UNet/Transf)
   │
   ├── 3D Diffusion Policy (点云观测)
   ├── Diffusion Policy + Flow Matching (换范式提速)
   ├── π0 / π0.5 (Flow Matching + 双Gemma, VLA)
   ├── GR00T N1.x (Flow Matching + DiT 动作专家)
   └── RDT, MDT 等 (扩散/DiT 大动作模型)

5.2 关键衍生及其动机

5.3 学习建议：怎么读一个新动作生成论文

1. 先定范式：它用 DDPM 还是 Flow Matching？看训练 loss 预测 ε 还是 v。
2. 再看架构：去噪网络是 U-Net 还是 DiT/Transformer？
3. 查条件注入：观测/语言怎么进网络（FiLM/AdaLN/cross-attn/token）？
4. 看采样：推理几步？DDIM 还是 ODE 欧拉？
5. 找创新点：多数论文只动其中 1-2 项，其余沿用经典。

这三块对算力的影响 🩷整理

选 DDPM / DiT / Flow Matching 不只是精度问题，也直接影响训练与推理的算力开销。下面是从"这三块怎么选"角度看资源的对照(概念性，非某一篇的具体数字)。

6. 自测：15 题检验你是否真懂四者关系

选完点提交，即时判分 + 解析。