A Blog on Continuous DLM
2026 上半年 6 篇集中工作综述 — 以 ELF 为锚，5 家 FM 横向对比 + 字节 Cola-DLM

Ruofeng Yang（杨若峰） · Shanghai Jiao Tong University · 2026-05
锚论文：ELF arXiv 2605.10938 （Hu, Qiu, Lu, Zhao, Li, Kim, Andreas, He · MIT · 2026-05-11，非本文作者）· Code: lillian039/ELF · 代码审过 PyTorch port @ pytorch_elf

1 · 离散 DLM 的已有问题

1.1 离散 DLM 五年演进路线

1.2 共同特征 + 共同瓶颈

这套路线都把 D-LLM 定义为：mask/uniform 离散腐蚀 → 逐位置独立 softmax reverse。 随着工作越做越多，发现它撞上四堵墙：

1.3 过去一年的"修"路线

这些都是 修——保持"离散 + factorized"这个根基不变，在边缘 patching。 ELF 的回答更激进：跳出离散空间。如果 token 嵌入已经被 T5 学好了， 为什么 diffusion 还要在离散符号上跑？为什么不直接在 T5 那个连续 + 有几何结构的空间里跑 flow？

2 · ELF 的核心想法 — 一个 "已知未知" 的连续空间

2.1 两个"连续"，一个"冻结"

ELF 在两个意义上是 continuous（paper §2 明确说 "continuous in two senses"）：

• 状态空间连续：denoising 在 T5-small contextual embedding 空间（512 维实数向量）发生，不在 token 词表 V × L 网格上
• 时间连续：用 Flow Matching（rectified-flow 插值 z = t·x + (1−t)·ε）学速度场 v_θ(z, t)，不是 DDPM 离散步 t∈{1,...,T}

但 ELF 还有一个关键的"冻结"：encoder 不学。这是它和过去同类工作的最大区别。

input_ids:        [B, 1024]               ← 1024 个 token ID（每个是 0~32127 之间的整数）
                       ↓ T5-small frozen encoder
T5 contextual emb: [B, 1024, 512]         ← 每个"位置"得到一个 512-d vector
                       ↓ + noise
z_t (noisy):       [B, 1024, 512]         ← ELF denoise 就在这个 tensor 上
                       ↓ 32 步 Flow Matching denoising
clean embedding:   [B, 1024, 512]         ← 终点 ≈ 干净的 contextual embedding
                       ↓ decoder head（512 → 32128 logits）
vocab logits:      [B, 1024, 32128]       ← 只在 t=1 这一步才出现
                       ↓ per-position argmax
output token IDs:  [B, 1024]

2.2 为什么"frozen contextual embedding"是这条路的关键

过去 5 年的 continuous DLM 路线（paper Tab 2 p.15 给了完整 landscape）分两条线：

• Embedding-space, learn embedding：Diffusion-LM 2022 / CDCD 2022 / Plaid 2023 / SeqDiffuSeq 2024 / GENIE 等 — 端到端学 embedding + diffusion
• Latent diffusion, fixed encoder + separate decoder：LD4LG 2023 / TEncDM / Cosmos / CoDAR — 用预训练 encoder，但另外训 separate decoder

共同问题：

1. "鸡和蛋"：embedding 学习和 diffusion 学习互相依赖，早期训练不稳定
2. 多目标拉扯：embedding 既要满足 reconstruction，又要满足 diffusion topology，又要不 collapse — 容易陷入 trivial 解
3. Per-step token CE：Tab 2 显示许多老工作在中间步就强加 token-level CE 监督（"Train per-step discr.: Yes"），这相当于把"连续 transport"和"离散 classification"两件事强行耦合，部分把问题①（quantization wall）带回来了

ELF 在 Tab 2 里是唯一一行 "fix enc / no train per-step discr / no infer per-step discr / no separate decoder" 同时为否的——架构上最干净的设计点。

ELF 的 framing：把"语义几何"和"transport 动力学"两件事在架构上分离：

• 语义几何 = T5-small encoder 输出空间。已经存在，已知，不学。
• Transport 动力学 = ELF DiT transformer 学的 flow matching。仅此一件事要学。

2.3 T5-small encoder 为什么是好选择

论文没有 sweep encoder 选择（只 ablate T5-small / base / large 三个 size，App C.1）。 这是 ELF 最容易被 reviewer 攻击的地方：能不能换成 BERT? Sentence-BERT? CLIP text? 一个 LLaMA-7B hidden state? 猜测：T5 的 span corruption 让 hidden state 几何特别平滑，恰好适合 flow matching。 但这是猜测，不是 paper claim。

2.4 "Contextual" vs "Static" embedding —— 借 T5 的语义流形当坐标系

一句话总结：ELF 没有自己学语言的几何，它直接搭便车坐在 T5 已经画好的"文本流形"上做 transport。

2.4.1 Static (非 contextual) embedding

最早的词向量做法（word2vec / GloVe / Diffusion-LM 用的 learned embedding matrix）：

• 存储结构：lookup table E，形状 [32128, 512]（vocab × dim）
• 对任意句子里出现 "bank" → token_id = 4321 → embedding = E[4321]
• 永远是同一个 512-d 向量，不管上下文

所以无论是 "I deposited money in the bank"（金融机构）还是 "We walked along the river bank"（河岸），`bank` 都被映射到同一个固定向量。模型自己没法从 embedding 那一层看出"这个 bank 是哪个意思"——只能靠后面的 transformer 自己消歧。

2.4.2 Contextual embedding

预训练 encoder（BERT / T5 encoder 等）的做法：跑一遍 transformer encoder over the whole sequence，每个 token 位置的输出向量都受整句话影响。

input_ids: [B, 1024]    一个句子，1024 个位置
   ↓ T5 encoder (6 层 self-attention + MLP)
output:    [B, 1024, 512]    每个位置一个 512-d 向量，
                              且这个向量是 attention over 所有位置算出来的

所以同样是 "bank"：

• "I deposited money in the bank" 里位置 5 的 `bank` → 向量 v1（语义上离 "investment", "financial" 近）
• "We walked along the river bank" 里位置 5 的 `bank` → 向量 v2（语义上离 "shore", "water" 近）
• v1 ≠ v2，embedding 那一层就已经做了语义消歧

2.4.3 几何对比

2.4.4 对 diffusion 来说为什么重要 —— 借坐标系，不画地图只走路

T5 预训练（~1T tokens）已经把文本数据组织成了一个有结构的 512-d 流形：语义相近的句子 / 位置在这个空间里几何上也相近，上下文消歧、词性、句法关系都被编码进了向量的位置和方向。

ELF 把 T5 encoder 冻住当"坐标系"——diffusion 的工作变成了"在这张已经画好的语义地图上做 transport"，而不是"先画地图再 transport"。

对比之下：

• Diffusion-LM：自己学 embedding（地图边画边走，两个任务互相干扰，训练不稳定）
• LangFlow：自己学 embedding（同上）
• DFM / FLM：直接在 simplex / one-hot 上做（连地图都没有，纯靠 Transformer 后处理）
• ELF：借用 T5 的地图（专心走路）

2.4.5 这就是为什么 105M + 45B tokens 能打过 1B+ 的 LLaDA

因为 ELF 实际能用的"语言知识"远不止 45B，而是 45B + T5 那 1T tokens 的预训练迁移。Codex GPT-5.5 xhigh 在 cross-model review 里也直接点了这个：

代价：上限被 T5-small 锁死。换 7B encoder 还有效吗？scale 到 LLaMA-70B 行不行？这是 ELF 的命门，也是 Gemini auto-gemini-3 review 标的"T5 的生成式插件而非通用架构"那个点（详见 §10 与 ELF 的命门讨论）。

2.5 最后一步离散化 — 共享 Transformer 的 decoder head

整个 flow 从 ε（标准高斯 × noise_scale=2.0）→ clean embedding 都在连续空间。 但 t=1 时模型必须输出离散 token。ELF 的做法：

1. 主 transformer forward 已经预测 clean embedding x̂（[B, L, 512]）
2. 最后另外跑一次 forward，decoder_step_active=True，这次 transformer 输出经过 factored decoder head（768 → 512 GELU → 32128）映射到 vocab logits
3. 取 argmax 得到 token

关键：denoise 主干 + 离散化 decoder 是同一份 transformer 权重，靠 4 个 mode token 切换。 论文 App C.4 显示这种 in-context conditioning 比 adaLN-Zero 略好且省 43M 参数（详见 §5）。

3 · 相关工作 A — Flow-Matching 家族 5 paper 对比（同期）

2026 年 2-5 月，一共出现了 5 篇基于 Flow Matching 的语言模型工作， 其中 ELF 是 paper 自己 Tab 2 显示的最后一行。这一节把这 5 篇放在一起对比，明确 ELF 在 FM 家族里的独特定位。

3.1 五篇 paper 速写

3.2 八维结构对比表 （点击列名 → 高亮该列 + 弹论文卡片）

3.3 State space 几何 — 什么叫"在 simplex / one-hot 上走 flow"

§3.2 表第一行的 State space 是 5 篇 paper 的核心分歧点。CFM / FLM / DFM 一类说自己"在 simplex 上走 flow"， LangFlow 说自己"在 learned embedding 上走"，ELF 说自己"在 contextual embedding 上走"——这些到底什么意思？把它讲透。

3.3.1 One-hot 是什么

一个 token 表示成 vocab-size 长的向量，只有一位是 1，其他全是 0：

vocab V = 32128
token "bank" (id=4321) → one_hot 长度 V 的向量
   = [0, 0, ..., 0, 1, 0, ..., 0]
              ↑ 第 4321 位

整个句子（L=64 个 token）→ 形状 [64, 32128]，每行是一个 one-hot。

3.3.2 Simplex 是什么

V 维空间里所有"概率分布"组成的集合：长度 V 的非负向量，且各分量之和 = 1。直观理解：

• V 个顶点 = V 个 one-hot（"纯净 token"对应单纯形的角）
• 内部点 = 概率混合（0.5·"bank" + 0.5·"shore" 是 simplex 内部某点）
• 形状：V=3 时是三角形；V=32128 时是 32127 维的"超三角形"

V=3 时的 simplex（直观图）：

      (1,0,0)    ← token A 的 one-hot
        /\
       /  \
      / .  \    ← 内部任意点 = 概率混合
     / .. . \
    /________\
(0,1,0)    (0,0,1)
 token B    token C

3.3.3 "走 flow" 在不同 state space 是什么意思

Flow matching 的核心是 z_t = t·x + (1−t)·ε——从噪声 ε 走到数据 x。 关键问题是：x 长什么样、ε 长什么样、在哪个空间里走。

3.3.4 几何含义

想象 V=32128 维空间里数据点 x 长什么样：

最关键的一点：one-hot 空间里，"bank" 和 "dog" 的欧氏距离 = "bank" 和 "shore" 的欧氏距离 = √2。没有任何语义几何——token 之间的相似性必须由 Transformer 自己从头学出来。

3.3.5 4-token 直观例子

假设词表只有 4 个 token：river / bank / money / shore

• ELF 输入：每个位置一个 512-d contextual 向量，"bank" 在 "river __" 后的向量跟在 "money __" 后的向量不同，且分别离 "shore" 和 "金融-ish" 的向量近
• LangFlow / Diffusion-LM 输入：每个位置一个 D-d static 向量，"bank" 永远是同一个向量；模型学到的关系是 "bank ≈ money" 比 "bank ≈ shore" 近一点点（但都只是这 4 个固定点之间的关系）
• CFM / FLM / DFM 输入：每个位置一个 4-d one-hot：

  river: [1, 0, 0, 0]
  bank : [0, 1, 0, 0]
  money: [0, 0, 1, 0]
  shore: [0, 0, 0, 1]
  

  所有 token 互相垂直，"bank-river" 跟 "bank-money" 完全等距。Transformer 必须从一堆垂直 one-hot 输入中，靠 attention 自己摸索出 "bank" 在 "river" 旁边时该往哪边走

3.3.6 为什么说 simplex/one-hot 派"连地图都没有，纯靠 Transformer 后处理"

回到 §2.4 那个比喻：

• ELF：T5 已经把语义地图画好了，diffusion 只需要在地图上走路
• LangFlow / Diffusion-LM：自己边走边画地图（lookup table 是学出来的，但只有 V 个固定点，没上下文消歧）
• CFM / FLM / DFM：根本没有地图——所有 token 在 V 维空间里互相垂直，模型只能靠 Transformer 自己的中间层学出"哪些 token 在语义上相近"

这就解释了为什么 CFM / FLM / DFM 都需要更多 trick：

1. 大模型容量：Transformer 自己要把"one-hot 空间 → 内部 hidden 语义空间"的映射学出来
2. 蒸馏 / 重参数化：FLM 蒸馏到 1 步，CFM self-distill，DFM 改 mean denoiser——都是为了弥补"几何信息缺失"
3. 必须用 CE/KL on simplex：纯 L2 在 one-hot 上不合理（详见 §3.4 ③），所以 loss 必须搬到概率几何上

对照之下 ELF 用 MSE 是合法的——因为 contextual embedding 不是概率分布，是带几何结构的语义向量，欧氏距离反映语义距离。

3.4 四个聚类轴

3.5 两个 critical reading 问题

3.6 ELF 对每个 sibling 的对比叙述

ELF vs CFM：两者都把离散文本放到连续 FM 里，但CFM 的连续对象是 simplex-valued endpoint，ELF 的是 T5 contextual embedding。 CFM 押注"少步 self-distillation"，单步 LM1B 274.87；ELF 押注"无蒸馏 32 步"，OWT 24.08。 两条完全互补的路线——蒸馏路 vs 采样路。（点击此标题 → 滚到 §3.2 表 + 高亮 CFM 列）

ELF vs FLM/FMLM：两者都做 continuous flow LM，也都在 OWT 上用 Gen-PPL； 但 FLM 用 V 维 one-hot（vocab 越大状态越大），ELF 用 512 维 T5 embedding + 128 bottleneck。 FLM 的卖点是天然可蒸馏到 FMLM；ELF 的卖点是无蒸馏即少步。 直接对比：FLM 1024 步 OWT Gen-PPL 62.23 vs ELF 32 步 24.08 —— ELF 完胜，但代价是放弃了 vocab-level 状态空间的"天然性"。

ELF vs DFM：两者都认真做 ablation，但变量完全不同—— DFM 在变 PSD/ESD consistency 把 flow map 压到 few-step；ELF 在变 ODE/SDE/γ/SC-CFG 把 base flow 调到 32 步。 DFM 的强点是 1-4 NFE；ELF 的强点是无蒸馏 32 NFE。再次互补。

ELF vs LangFlow：两者都在 embedding-space 做 FM，也都报 OWT 数字；但 LangFlow 的 24.6 是 held-out NLL upper bound，ELF 的 24.08 是 Gen-PPL，不能直接比。 可比项：LangFlow OWT Gen-PPL 36.5 (1024 步) vs ELF 24.08 (32 步) —— ELF 在生成质量上明显优。 反过来，LangFlow 有 likelihood story（可信 NLL bound + 4/7 zero-shot benchmark 超过 AR），ELF 目前没有对应 likelihood claim。 两边互补。

3.7 FM 家族一句话总结

4 · 训练 pipeline（ELF 算法核心）

💡 关键澄清：网络直接预测 clean embedding x̂，不是 velocity

ELF 用的是 x-prediction parameterization（App C.1 ablation 选出来的—— x-pred 在高维比 v-pred / ε-pred 稳定，因为"clean text 在低维流形上"）：

# sampling_utils.py:115-127
def net_out_to_v_x(net_out, z, t, t_eps=5e-2):
    x = net_out                            # ← 网络输出直接就是 x̂（clean embedding pred）
    denom = torch.clamp(1.0 - t, min=t_eps)
    v = (x - z) / denom                    # ← velocity 是后处理算出来的
    return v, x

但这不代表跳过逐步去噪。推理仍然 32 步 Euler 迭代：

for step i in range(32):
    x̂  = net_θ(z_t, t, c, ω, "denoise")    # 每步预测 clean embedding
    v  = (x̂ - z_t) / (1 - t)               # 由 x̂ 换算瞬时 velocity
    z_t = z_t + dt · v                     # Euler 走一小步
# 最后一步：x̂ = net_θ(z_t≈x, t=1, c, ω, "decode") → unembed → token

三件事要分清：

	真值
网络直接输出什么	clean embedding x̂（一直在预测最终目标 x0）
Flow Matching 框架下的 transport 量	velocity v
推理过程	仍然 32 步 Euler 迭代；每步用网络的 x̂ 算 v 再走一小步

为什么这么设计：

1. x-pred 的 target 固定（clean embedding x₀），不随 t 变；v 和 ε 的 target 都随 t 变化，高维下难学
2. App C.1 显示 ε-pred 在 768/1024 dim 直接 collapse
3. 实际 MSE loss 形式上是 ‖v_pred − v_target‖²，但 v_pred / v_target 都从 x_pred / x₀ 换算，梯度其实在监督 x_pred → x₀

和 consistency model / mean flow 的区别：那些工作目标是真的 1 步从 noise 直接跳到 x（学一个"时间无关的 x-prediction"）。ELF 没走那条路——仍是 32 步，但每步的局部预测对象是 x 而非 v。FMLM 就是 FLM 的 consistency-distilled 1-步版本；ELF 的 future work 也提了这个方向。

4.2 论文 Algorithm 3 (denoiser) + Algorithm 4 (decoder)

论文 App B 写成两个独立算法。PyTorch port 改成 per-example mix，数学上等价（见 §4.6）。两个算法的关键差异：

Algorithm 3 伪代码（denoiser，paper App B.1，去 LaTeX）：

# Algorithm 3: ELF denoiser training with conditioning and guidance
# net(z, t, c, w, mode): ELF network with in-context conditioning
# self_cond_proj(z): concat-to-original-dim projection
# self_cond_prob: 0.5
# s: discrete token sequence
# c: condition (optional, only for XSum/WMT)

x = encode(s)                               # T5 frozen forward
t = sample_t()                              # logit-normal scalar per sample
w = sample_sc_cfg_scale()                   # ω ∈ [0.5, 5], paper: power-biased
                                            # PyTorch port: shifted log-uniform
e = randn_like(x)                           # standard Gaussian（与 paper 一致）
z = t * x + (1 - t) * e                     # rectified-flow interpolant
v = x - e                                   # base velocity target

# (1) 不带 self-cond 的 forward (no_grad)
z_no_sc = self_cond_proj(concat([z, zeros_like(z)], dim=-1))
x_no_sc = net(z_no_sc, t, c, w, mode="denoise")
v_no_sc = (x_no_sc - z) / (1 - t)

# (2) 带 self-cond 的 forward (no_grad, stopgrad on x_no_sc)
z_sc = self_cond_proj(concat([z, stopgrad(x_no_sc)], dim=-1))
x_sc = net(z_sc, t, c, w, mode="denoise")
v_sc = (x_sc - z) / (1 - t)

# (3) CFG target: post-combination quantity
v_target = v + (1 - 1/w) * (v_sc - v_no_sc)

# Per-example self-cond mask
self_cond_mask = uniform(B) < self_cond_prob
v_pred   = where(self_cond_mask, v_sc, v_no_sc)
v_target = where(self_cond_mask, v_target, v)
v_target = stopgrad(v_target)

loss_denoise = mse_loss(v_pred, v_target)

逐行拆解：v_target 是怎么构造出来的？（Alg 3 最绕的 5 行）

看 Alg 3 最容易迷的就是 (3) 之后 where 和 stopgrad 那 5 行。它们做了 4 件事：

# (3) CFG target: post-combination quantity
v_target = v + (1 - 1/w) * (v_sc - v_no_sc)     # 计算"带 CFG"的 target

# Per-example self-cond mask
self_cond_mask = uniform(B) < self_cond_prob     # 每个 example 独立抽 Bernoulli(0.5)
v_pred   = where(self_cond_mask, v_sc, v_no_sc)  # gradient forward 走哪条
v_target = where(self_cond_mask, v_target, v)    # target 选哪个
v_target = stopgrad(v_target)                    # 截梯度

关键 insight：这是同一个 batch 同时训练两种模式。 mask 把 batch 切两半：50% 走 self-cond + CFG 路径，50% 走 plain FM 路径。 这两条路径必须用同一个 mask挑 v_pred 和 v_target，否则配对错乱。

这里 mse_loss 展开是什么？

就是 velocity 上的 L2 距离 + per-token mean，标准 Flow Matching 损失。具体计算：

# v_pred ∈ [B, L, 512]，来自 ELF 主干 gradient-tracked forward 后转 velocity：
#   x_pred = ELF_transformer(z_self_cond, t, c, ω, decode_mode=False)
#   v_pred = (x_pred - z) / clamp(1 - t, t_eps)            # paper Eq 4

# v_target ∈ [B, L, 512]，由 Eq 3 训练时 CFG 构造（前面 4.4 节详）：
#   v_base    = (x_0 - z) / clamp(1 - t, t_eps) = (x - ε·noise_scale)
#   v_target  = v_base + (1 - 1/ω) · (v_cond - v_uncond)
#   v_target  = v_target.detach()                          # 梯度只走 v_pred

l2_per_token = ((v_pred - v_target) ** 2).mean(dim=-1)     # [B, L]  channel-wise mean
l2_per_token *= loss_mask                                  # 排除 padding + cond positions

数学上 ELF 的 MSE 等价于：

其中：

Algorithm 4 伪代码（decoder，paper App B.1）：

# Algorithm 4: ELF decoder training with conditioning and guidance
x = encode(s)
p = sample_per_token_p()                    # logit-normal PER TOKEN (different from denoiser)
w = sample_sc_cfg_scale()
e = randn_like(x)                           # standard Gaussian（与 paper 一致）
z = p * x + (1 - p) * e                     # per-token corruption ratio

# decoder always uses zero self-cond input
z = self_cond_proj(concat([z, zeros_like(z)], dim=-1))
h = net(z, t=1, c, w, mode="decode")        # mode token gate = 1
s_pred = unembed(h)                         # factored decoder head

loss_decode = ce_loss(s_pred, s)

这里 ce_loss 展开是什么？

就是标准的 per-token cross-entropy，没有任何 ELF-specific 改造。具体计算（来自 src/train_step.py）：

# decoder_logits ∈ [B, L, 32128]，由 ELF 主干 forward + factored decoder head 给出：
#   hidden_768 = ELF_transformer(z̃, t=1, c, ω, decode_mode=True)[B, L, 768]
#   hidden_512 = GELU_tanh(hidden_768 @ proj_kernel + proj_bias)     # 768 → 512
#   decoder_logits = hidden_512 @ unembed_kernel + unembed_bias       # 512 → 32128

log_probs    = F.log_softmax(decoder_logits.float(), dim=-1)          # [B, L, 32128]
ce_per_token = -log_probs.gather(-1, target_ids.unsqueeze(-1)).squeeze(-1)
# ⇔ -log p_θ(s_i | z̃_i, t=1, c, ω, mode=decode)                     # [B, L]

# 然后 mask 掉 padding 位置 + 条件生成的 cond 位置，再聚合
ce_per_token *= loss_mask   # loss_mask = (1 - cond_seq_mask) * attention_mask

数学上 ELF 的 CE 等价于：

关键变量含义：

三个容易混淆的点

1. decoder 分支永远 t=1。不像 denoiser 分支 t 从 logit-normal 抽，decoder 总是在"clean 端点"做 final-step decoding。 但 z̃_i 仍然有 corruption——只是 corruption ratio p_i 从一个独立的 logit-normal 分布抽（per token，不是 per sequence），让 decoder 见过 noisy embedding 也能还原 token。
2. decoder 分支不带 SC-CFG guidance。Eq 3 的 self-conditioning CFG 只用于 denoiser 分支的 L_MSE。 decoder 分支自己只跑一次 forward，输入 self-cond 部分填 0，直接算 CE。
3. per-token corruption，不是 per-sequence。这是 decoder 和 denoiser 最大的差别—— denoiser 的 t 是 (B,) scalar per 序列；decoder 的 p 是 (B, L, 1) tensor per 位置。 意义：模拟推理时不同 token 位置 reconstruction 质量不同（有些 token 在 ODE 轨迹上接近 clean，有些差远了）。

4.3 Embedding corruption — 两套独立的 logit-normal schedule

两条分支用不同的时间/腐蚀分布。Paper App B.1 + 代码 src/configs/training_configs/train_owt_ELF-B.yml 默认：

核心思路：denoiser 训练时多接触噪声大的样本（学习如何 transport）， decoder 训练时多接触接近 clean 的样本（学习如何 round 回 token）。 而且 decoder 是每个 token 独立抽 corruption ratio，模拟推理时不同位置的 reconstruction 质量。

# sampling_utils.py::add_noise (denoiser)
def add_noise(x0, noise, t, config, cond_seq_mask=None):
    t_expanded = t.reshape(-1, 1, 1)                       # [B, 1, 1]
    z = t_expanded * x0 + (1 - t_expanded) * noise * config.denoiser_noise_scale
    if cond_seq_mask is not None:                          # 条件生成时保留 cond token 不腐蚀
        z = cond_seq_mask * x0 + (1 - cond_seq_mask) * z
    return z

# train_step.py — decoder branch (per-token p sampling)
decoder_z_vals = (
    torch.randn((B * L,), dtype=dtype, device=device)
    * config.decoder_p_std + config.decoder_p_mean         # = N(0.8, 0.8²)
)
decoder_lambda_t = torch.sigmoid(decoder_z_vals).reshape(B, L, 1)  # [B, L, 1] per-token
decoder_noise = torch.randn(x0.shape, dtype=dtype, device=device) * config.decoder_noise_scale
decoder_z = decoder_lambda_t * x0 + (1 - decoder_lambda_t) * decoder_noise

4.4 训练时 CFG（Eq 3，全文最 tricky 的点）

Image diffusion 的 classifier-free guidance 通常是推理时跑两遍 forward 然后线性组合：

ELF 把它烤进训练——模型直接学 post-combination quantity，推理只需一次 forward。Paper Eq 3：

这里的 trick 是 self-cond 的"condition"不是输入文本 c，而是 self-cond 输入 x'。 所以"uncond"就是 x'=0，"cond"就是 x'=stopgrad(net1)。CFG scale ω∈[0.5, 5] 是 ELF 自己也学的输入参数（4 个 SC-CFG token 编码）。

实现需要 3 次 forward。代码实际执行顺序是：

1. v_uncond：no_grad，self-cond 输入 = zeros（最早跑，作 baseline）
2. v_pred：带梯度 forward，self-cond 输入 = stopgrad(uncond 的 x_pred)。L2 loss 用这个 v_pred
3. v_cond：no_grad，与第 2 次同输入，用于构造 v_target（不是 v_pred）

梯度只过第 2 次。最终 L2 loss = ‖v_pred − stopgrad(v + (1−1/ω)(v_cond − v_uncond))‖²。

# src/train_step.py — Eq 3 的自条件 CFG target 构造（简化版）

def compute_shared_uncond(z, t_input, x_tokens):
    # forward #1: self-cond input = zeros
    z_uncond = restore_cond(torch.zeros_like(z), x_tokens, cond_seq_mask)
    z_input_uncond = torch.cat([z, z_uncond], dim=-1)
    with torch.no_grad(), autocast(bf16):
        net_out_uncond = model(z_input_uncond, t_input,
                               self_cond_cfg_scale=self_cond_cfg_scale)
    return net_out_uncond

def get_sc_cond_and_uncond(z, t_input, cond_mask, x_tokens, shared_net_out_uncond):
    v_uncond, x_uncond = net_out_to_v_x(shared_net_out_uncond, z, t_input, t_eps)
    x_uncond = restore_cond(x_uncond, x_tokens, cond_mask)

    # forward #2: self-cond input = stopgrad(x_uncond)
    z_input_cond = torch.cat([z, x_uncond], dim=-1)         # 注意 stop-grad on x_uncond
    with torch.no_grad(), autocast(bf16):
        net_out_cond = model(z_input_cond, t_input,
                             self_cond_cfg_scale=self_cond_cfg_scale)
    v_cond, _ = net_out_to_v_x(net_out_cond, z, t_input, t_eps)
    return v_cond, v_uncond

def get_sc_guided_v(z, t_input, base_v_target, x_tokens, shared_net_out_uncond):
    v_cond, v_uncond = get_sc_cond_and_uncond(...)
    sc_w = self_cond_cfg_scale.reshape(B, 1, 1)
    sc_guidance = (1 - 1 / sc_w) * (v_cond - v_uncond)      # ← Eq 3 第二项
    sc_guidance = torch.where(use_self_cond_mask.bool(),
                              sc_guidance,
                              torch.zeros_like(sc_guidance))
    return (base_v_target + sc_guidance).detach()           # ← .detach() 是关键

# forward #3 (gradient-tracked) 在主 batch forward 里：
net_out, decoder_logits = model(model_input, t_mixed,
                                self_cond_cfg_scale=self_cond_cfg_scale,
                                decoder_step_active=decoder_step_active)
v_pred, _ = net_out_to_v_x(net_out, denoiser_z, t, t_eps=0.05)   # gradient-tracked
v_final_target = get_sc_guided_v(denoiser_z, t, base_v_target=v_target, ...)
l2_per_token = ((v_pred - v_final_target) ** 2).mean(dim=-1)     # MSE

4.5 Per-example branching — 工程实现 vs 论文算法

Paper Algs 3+4 写成两个独立 training step，按 0.8 / 0.2 概率轮换。PyTorch port 改成：

# src/train_step.py — 关键混合 forward
# 每行独立 Bernoulli(0.2) → decoder mode；否则 → denoiser mode
decoder_step_active = torch.bernoulli(
    torch.full((B,), config.decoder_prob, dtype=torch.float32),
    generator=gen,
).to(device=device, dtype=dtype)             # (B,) 1.0=decode 0.0=denoise
decoder_mask_B11 = decoder_step_active.view(-1, 1, 1)
decoder_mask_B1  = decoder_step_active.view(-1, 1)

# t、z 都按 per-example 混合
denoiser_t = t                                # logit-normal per-sample
decoder_t  = torch.ones_like(t)               # 永远 1
t_mixed = decoder_step_active * decoder_t + (1.0 - decoder_step_active) * t
z_mixed = decoder_mask_B11 * decoder_z + (1.0 - decoder_mask_B11) * denoiser_z

# 单次 forward — mode token gate 也是 per-example
net_out, decoder_logits = model(
    model_input, t_mixed,
    self_cond_cfg_scale=self_cond_cfg_scale,
    decoder_step_active=decoder_step_active,   # (B,) per-row gate
)

# CE / L2 各自用 mask 分流
loss_mask_f = loss_mask.to(ce_per_token.dtype)
ce_mask = loss_mask_f * decoder_mask_B1
l2_mask = loss_mask_f * (1.0 - decoder_mask_B1)

# 关键：单一分母归一化（不是两个分母）
total_sum = (ce_per_token * ce_mask).sum() + (l2_per_token * l2_mask).sum()
loss = total_sum / torch.clamp(loss_mask_f.sum(), min=1.0)
# loss_mask_f = ce_mask + l2_mask，所以这等价于 sum/(ce_mask.sum()+l2_mask.sum())
# 注意：pad_token=="pad" 时 loss_mask 屏蔽 padding；pad_token=="eos" 时全 1

4.6 等价性证明（简版）

论文 Algs 3+4 是两个独立 step，按 (1−p):p 比例轮换（p = decoder_prob = 0.2）。 PyTorch port 是同一个 step 内 per-example 抽 mode。先注意： 每个 example 内所有 token 共享同一个 mode 抽样结果（不是 token-wise i.i.d.）。

记 b ∈ (0, 1) 为 example 的 mode 指示（1 = decode），B0 = denoiser 行数，B1 = decoder 行数。 固定 batch、固定 loss denominator M = loss_mask.sum()，PyTorch port 的 loss：

L_code = [ Σ_{b=1 行} Σ_token CE + Σ_{b=0 行} Σ_token L2 ] / M

对 mode 抽样取期望（每行 Bernoulli(p)）：

𝔼[L_code] = (p · 𝔼_row[Σ CE | decode] + (1−p) · 𝔼_row[Σ L2 | denoise]) · (B / M)

= 𝔼[L_paper] · (per-example token 数加权和) — 等价于 paper Algs 3+4 的固定 batch-size 加权期望。

注意：

• 这是期望意义等价，不是 bitwise 等价。逐 step 轨迹不同。
• "梯度方差更小"是直觉假设；paper 没证明。可能优势：同 batch 内两个 head 都收到信号，不用交替优化步。

4.7 输入条件 CFG — Label drop 机制（XSum / WMT 才有）

条件生成时还需要另一个 classifier-free guidance，针对 input condition（不是 self-cond）。 10% 概率把 cond sequence 直接 drop（zero out），让模型学到 p(x | ∅) 分布：

# src/train_step.py — label drop for input-condition CFG
if config.label_drop_prob > 0:
    drop = label_drop_mask.to(dtype=torch.float32).reshape(-1, 1, 1)  # (B, 1, 1) 0/1
    cond_mask = cond_seq_mask                                          # (B, S)
    # block_mask: 1 仅在 (non-cond row, cond col)
    # 目的：让 target token 看不到 cond token
    block_mask = (1 - cond_mask).unsqueeze(-1) * cond_mask.unsqueeze(1)
    encoder_attention_mask = encoder_attention_mask * (1 - drop * block_mask)

label drop 实际两阶段：

1. 先改 T5 encoder 的 encoder_attention_mask，让 target token 看不到 cond token （block_mask 只在 non-cond row × cond col 上为 1） — 这样 T5 encode 出来的 x₀ 本身就不含条件信息
2. Encode 之后再把 dropped 行的 denoiser_z 和 x₀ 在 cond 位置清零 （torch.where(drop & cond_seq_mask, zeros, denoiser_z)）— 匹配 paper "zeroing condition embeddings"

5 · 架构、参数量、shape（最详细一节）

5.4 Bottleneck 设计（App C.2 ablation）

T5 embedding 512-d → bottleneck → DiT hidden。直觉：clean 文本数据其实在 低维流形上。 论文 App C.2 sweep 了 bottleneck ∈ (32, 128, 512)：

• 32-d：SDE 下 PPL 最低但 entropy 偏低（多样性损失）
• 128-d：PPL/entropy 平衡最好，是 default
• 512-d (no bottleneck)：entropy 高但 PPL 明显恶化

class BottleneckTextProj(nn.Module):
    def __init__(self, text_encoder_dim, hidden_size, bottleneck_dim):
        super().__init__()
        self.proj1 = nn.Linear(text_encoder_dim, bottleneck_dim, bias=False)  # 512 → 128
        self.proj2 = nn.Linear(bottleneck_dim, hidden_size,    bias=True)     # 128 → 768

    def forward(self, x):                       # [B, L, 512]
        return self.proj2(self.proj1(x))        # [B, L, 768]

class TextRotaryEmbeddingFast(nn.Module):
    def __init__(self, dim, pt_seq_len=512, ft_seq_len=None,
                 theta=10000.0, num_empty_token=0):
        super().__init__()
        ft_seq_len = ft_seq_len or pt_seq_len
        # 标准 RoPE 频率
        freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[:dim//2].float() / dim))
        # 位置缩放支持 fine-tune 时 seq_len 与 pretrain 不同
        pos   = torch.arange(ft_seq_len).float() / ft_seq_len * pt_seq_len
        freqs_main = torch.einsum('..., f -> ... f', pos, freqs)
        freqs_main = repeat(freqs_main, '... n -> ... (n r)', r=2)

        # prefix 的 cos=1, sin=0 → 不旋转
        if num_empty_token > 0:
            cos_prefix = torch.ones((num_empty_token, freqs_main.shape[-1]))
            sin_prefix = torch.zeros_like(cos_prefix)
            freqs_cos = torch.cat([cos_prefix, torch.cos(freqs_main)], dim=0)
            freqs_sin = torch.cat([sin_prefix, torch.sin(freqs_main)], dim=0)
        self.register_buffer("freqs_cos", freqs_cos, persistent=False)
        self.register_buffer("freqs_sin", freqs_sin, persistent=False)

    def forward(self, t):                       # [B, n_heads, L_total, head_dim]
        cos = self.freqs_cos.to(t.dtype)        # 显式 dtype cast 防 bf16 精度漂移
        sin = self.freqs_sin.to(t.dtype)
        return t * cos + rotate_half(t) * sin

class TimestepEmbedder(nn.Module):
    # t (scalar in [0,1]) -> hidden vector (e.g., 768)
    # Init: MLP weights normal(0.02), biases zero
    def __init__(self, hidden_size, frequency_embedding_size=256):
        super().__init__()
        self.mlp_0 = nn.Linear(frequency_embedding_size, hidden_size, bias=True)
        self.mlp_2 = nn.Linear(hidden_size, hidden_size, bias=True)

    @staticmethod
    def timestep_embedding(t, dim=256, max_period=10000):
        half = dim // 2
        freqs = torch.exp(-math.log(max_period) * torch.arange(half).float() / half)
        args  = t[:, None].float() * freqs[None]
        return torch.cat([torch.cos(args), torch.sin(args)], dim=-1)   # [B, 256]

    def forward(self, t):                       # [B]
        emb = self.mlp_0(self.timestep_embedding(t, 256))   # [B, 768]
        return self.mlp_2(F.silu(emb))                       # [B, 768]

class Attention(nn.Module):
    def __init__(self, dim=768, num_heads=12, qkv_bias=True, qk_norm=True,
                 attn_drop=0.0, proj_drop=0.0):
        super().__init__()
        self.num_heads = num_heads
        head_dim       = dim // num_heads                  # 64 for ELF-B
        self.qkv       = nn.Linear(dim, dim * 3, bias=qkv_bias)
        self.q_norm    = RMSNorm(head_dim) if qk_norm else nn.Identity()
        self.k_norm    = RMSNorm(head_dim) if qk_norm else nn.Identity()
        self.proj      = nn.Linear(dim, dim, bias=True)

    def forward(self, x, rope_fn, attention_mask=None):
        B, N, C = x.shape                                   # N = 1036 在 ELF-B 训练时
        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads)
        qkv = qkv.permute(2, 0, 3, 1, 4)                    # [3, B, n_heads, N, head_dim]
        q, k, v = qkv[0], qkv[1], qkv[2]

        q = self.q_norm(q)                                   # qk-norm（论文与官方实现都开）
        k = self.k_norm(k)
        if rope_fn is not None:                              # 应用 RoPE（含 prefix-no-rotation）
            q = rope_fn(q)
            k = rope_fn(k)
        # 实际 layers.py 里包了一层 wrapper：int/float mask -> bool mask 再传 SDPA
        x = scaled_dot_product_attention(q, k, v, attn_mask=attention_mask)
        return self.proj(x.permute(0, 2, 1, 3).reshape(B, N, C))

class SwiGLUFFN(nn.Module):
    def __init__(self, dim, hidden_dim, drop=0.0):
        super().__init__()
        # SwiGLU 标准做法：把 hidden 缩到 2/3 保持 param count
        hidden_dim_eff = int(hidden_dim * 2 / 3)             # 768*4 = 3072 → 2048
        self.w12 = nn.Linear(dim, 2 * hidden_dim_eff, bias=True)   # 768 → 4096
        self.w3  = nn.Linear(hidden_dim_eff, dim, bias=True)       # 2048 → 768

    def forward(self, x):                                    # [B, N, 768]
        x1, x2 = self.w12(x).chunk(2, dim=-1)                # 各 [B, N, 2048]
        return self.w3(F.silu(x1) * x2)                      # [B, N, 768]

class FinalLayer(nn.Module):
    # Last layer that maps hidden 768 -> embedding output 512.
    def __init__(self, hidden_size, patch_size, out_channels):
        super().__init__()
        self.norm_final = RMSNorm(hidden_size)
        # 关键: kernel + bias 都用 0 初始化（DiT 标配）
        # → 开局时模型预测的 clean x_pred ≡ 0；
        #   velocity 由后处理 v=(x_pred - z)/(1 - t) 计算
        self.linear = nn.Linear(hidden_size, patch_size**2 * out_channels, bias=True)
        nn.init.zeros_(self.linear.weight)
        nn.init.zeros_(self.linear.bias)

    def forward(self, x):                                    # [B, L, 768]
        return self.linear(self.norm_final(x))               # [B, L, 512]

class ELFBlock(nn.Module):
    def __init__(self, hidden_size, num_heads, mlp_ratio=4.0):
        super().__init__()
        self.norm1 = RMSNorm(hidden_size, eps=1e-6)
        self.attn  = Attention(hidden_size, num_heads, qkv_bias=True, qk_norm=True)
        self.norm2 = RMSNorm(hidden_size, eps=1e-6)
        self.mlp   = SwiGLUFFN(hidden_size, int(hidden_size * mlp_ratio))

    def forward(self, x, rope_fn, attention_mask=None):
        x = x + self.attn(self.norm1(x), rope_fn, attention_mask)
        x = x + self.mlp(self.norm2(x))
        return x

class ELF(nn.Module):
    # 源码默认 num_model_mode_tokens=0, vocab_size=0
    # train.py 实际从 config / tokenizer 把 4 / 32128 传进来
    def __init__(self, text_encoder_dim=512, max_length=1024,
                 hidden_size=768, depth=12, num_heads=12,
                 mlp_ratio=4.0, bottleneck_dim=128,
                 num_time_tokens=4, num_self_cond_cfg_tokens=4,
                 num_model_mode_tokens=4, vocab_size=32128):
        super().__init__()
        # Self-conditioning projection: [z; x_pred] (2×512) -> 512
        self.self_cond_proj = nn.Linear(2 * text_encoder_dim, text_encoder_dim, bias=True)

        # Bottleneck text projection (512 -> 128 -> 768)
        self.text_proj = BottleneckTextProj(text_encoder_dim, hidden_size, bottleneck_dim)

        # Prefix tokens + their (input-dependent) embedders
        self.t_embedder      = TimestepEmbedder(hidden_size)
        self.t_emb_tokens    = nn.Parameter(torch.empty(1, num_time_tokens, hidden_size))

        self.self_cond_cfg_embedder = TimestepEmbedder(hidden_size)
        self.self_cond_cfg_tokens   = nn.Parameter(
            torch.empty(1, num_self_cond_cfg_tokens, hidden_size))

        self.mode_tokens = nn.Parameter(torch.empty(1, num_model_mode_tokens, hidden_size))

        # RoPE with prefix no-rotation
        head_dim     = hidden_size // num_heads
        prefix_total = num_time_tokens + num_self_cond_cfg_tokens + num_model_mode_tokens
        self.feat_rope = TextRotaryEmbeddingFast(
            dim=head_dim, pt_seq_len=max_length, num_empty_token=prefix_total)

        # 12 ELFBlocks
        self.blocks = nn.ModuleList([
            ELFBlock(hidden_size, num_heads, mlp_ratio) for _ in range(depth)])

        # Flow-matching output head (zero-init)
        self.final_layer = FinalLayer(hidden_size, patch_size=1, out_channels=text_encoder_dim)

        # Factored decoder unembedding: 768 -> 512 (GELU) -> vocab
        self.proj_kernel    = nn.Parameter(torch.empty(hidden_size, text_encoder_dim))
        self.proj_bias      = nn.Parameter(torch.empty(text_encoder_dim))
        self.unembed_kernel = nn.Parameter(torch.empty(text_encoder_dim, vocab_size))
        self.unembed_bias   = nn.Parameter(torch.empty(vocab_size))

def forward(self, x, t, self_cond_cfg_scale=None, decoder_step_active=None):
    # x: [B, L, 512]  if no self-cond, OR  [B, L, 1024]  if self-cond cat([z, x_pred])
    # t: [B]                                            扩散时间 ∈ [0,1]
    # self_cond_cfg_scale: [B] or None                  ω 用 SC-CFG token 编码
    # decoder_step_active: None | True/False | Tensor[B]   控制 model-mode token gate
    B = x.shape[0]

    # ====== 1. self-cond projection: 2C -> C ======
    if x.shape[-1] == 2 * self.text_encoder_dim:       # 训练 & 推理都走这里
        x = self.self_cond_proj(x.float())             # [B, L, 1024] -> [B, L, 512]

    # ====== 2. bottleneck text projection ======
    x = self.text_proj(x.float())                      # [B, L, 512] -> [B, L, 768]

    # ====== 3. build prefix context tokens ======
    time_emb = self.t_embedder(t)                      # [B, 768]
    prefix   = self.t_emb_tokens.expand(B, -1, -1) + time_emb.unsqueeze(1)  # [B, 4, 768]
    if self_cond_cfg_scale is not None:
        sc_emb  = self.self_cond_cfg_embedder(self_cond_cfg_scale)          # [B, 768]
        prefix2 = self.self_cond_cfg_tokens.expand(B, -1, -1) + sc_emb.unsqueeze(1)
        prefix  = torch.cat([prefix, prefix2], dim=1)                       # [B, 8, 768]

    # ====== 4. model-mode tokens with per-example gating ======
    if decoder_step_active is None:
        gate = 0.0                                     # 默认 denoise: tokens 被乘 0
    elif isinstance(decoder_step_active, torch.Tensor):
        gate = decoder_step_active.view(-1, 1, 1)      # [B, 1, 1]  per-example
    else:
        gate = float(decoder_step_active)              # 1.0 in final decode
    mode_tokens = self.mode_tokens.expand(B, -1, -1) * gate                 # [B, 4, 768]
    x = torch.cat([mode_tokens, x], dim=1)                                  # [B, L+4, 768]
    model_mode_offset = self.num_model_mode_tokens     # = 4

    # ====== 5. prepend (time + sc-cfg) tokens ======
    # 最终顺序: [time(4), sc-cfg(4), mode(4), main(L)]
    x = torch.cat([prefix, x], dim=1)                                       # [B, L+12, 768]
    prefix_len = prefix.shape[1]                       # = 8 (time + sc-cfg)

    # ====== 6. 12 ELFBlocks with RoPE ======
    for block in self.blocks:
        x = block(x, rope_fn=self.feat_rope, attention_mask=None)           # full bidi

    # ====== 7. strip prefix (动态 = prefix_len + model_mode_offset) ======
    x = x[:, prefix_len + model_mode_offset:]                                # [B, L, 768]

    # ====== 8. flow-matching head (always computed) ======
    flow_output = self.final_layer(x.float())                               # [B, L, 512]

    # ====== 9. decoder head (only if decoder_step_active) ======
    decoder_logits = None
    if decoder_step_active is not None:
        x_f32  = x.float()
        hidden = F.gelu(x_f32 @ self.proj_kernel + self.proj_bias, approximate="tanh")
        decoder_logits = hidden @ self.unembed_kernel + self.unembed_bias   # [B, L, 32128]

    return flow_output, decoder_logits

6 · 推理 / 采样 — 完整代码 + 时间网格 + Tab 6/7 全数字

6.1 推理主流程

给定 (B, L) 和采样配置（method, n_steps, cfg, sc_cfg, γ）：

# src/utils/generation_utils.py — _generate_samples_single_batch (简化)

@torch.no_grad()
def _generate_samples_single_batch(model, generator, z, t_steps,
                                   cond_seq, cond_seq_mask,
                                   config, sampling_config,
                                   cfg_scale, self_cond_cfg_scale):
    method = sampling_config.sampling_method                # 'ode' or 'sde'
    B, L, d = z.shape                                       # d = 512

    if cond_seq is None:                                    # OWT 无条件生成
        cond_seq = torch.zeros((B, L, d), dtype=z.dtype, device=z.device)
        cond_seq_mask = torch.zeros((B, L), dtype=z.dtype, device=z.device)

    # 在条件位置上把 z 设回 clean cond_seq（cond 不去噪）
    z      = restore_cond(z, cond_seq, cond_seq_mask)
    x_pred = restore_cond(torch.zeros_like(z), cond_seq, cond_seq_mask)

    n = t_steps.shape[0]                                    # = n_steps + 1
    sde_gamma = getattr(sampling_config, "sde_gamma", 0.0)

    use_bf16 = config.use_bf16 and z.is_cuda
    with torch.amp.autocast('cuda', dtype=torch.bfloat16, enabled=use_bf16):
        # n_steps - 2 个中间步用 ODE/SDE
        for i in range(n - 2):
            t       = t_steps[i].item()
            t_next  = t_steps[i + 1].item()
            if method == "sde":
                z, x_pred = _sde_step(z, t, t_next, x_pred, gamma=sde_gamma, ...)
            else:                                           # 'ode'
                z, x_pred = _ode_step(z, t, t_next, x_pred, ...)

        # 最后一步强制 ODE — t 接近 1 不再注入新噪声
        z, x_pred = _ode_step(z, t_steps[-2], t_steps[-1], x_pred, ...)
    return z                                                 # [B, L, 512]


@torch.no_grad()
def _dlm_decode_batch(z, model, t_final_val, config, self_cond_cfg_scale):
    # 最终一步把 latent z (≈ clean embedding) 映射回 token IDs
    B = z.shape[0]
    t_final = torch.full((B,), float(t_final_val), dtype=z.dtype, device=z.device)
    sc_batch = (torch.full((B,), float(self_cond_cfg_scale), dtype=z.dtype, device=z.device)
                if config.num_self_cond_cfg_tokens > 0 else None)

    # 推理时 self-cond 输入永远 = zeros（与训练 decoder 分支一致）
    z_input = torch.cat([z, torch.zeros_like(z)], dim=-1) if config.self_cond_prob > 0 else z

    with torch.amp.autocast('cuda', dtype=torch.bfloat16, enabled=config.use_bf16):
        _, decoder_logits = model(
            z_input, t_final,
            self_cond_cfg_scale=sc_batch,
            decoder_step_active=True,                       # ← mode token gate = 1
        )
    return decoder_logits.argmax(dim=-1)                    # [B, L]

关键点：主循环 + 最终 decode 是两次独立 forward。前者把噪声 ε transport 到接近 clean x； 后者把 clean embedding 投影到 vocab。

6.2 ODE step — 标准 Euler（caller 在 generation.py 里先 init z = randn × denoiser_noise_scale）

def _ode_step(model, z, t, t_next, x_pred_prev,
              config, cfg_scale, self_cond_cfg_scale,
              cond_seq, cond_seq_mask):
    t_batch = torch.full((z.shape[0],), float(t), dtype=z.dtype, device=z.device)
    v_pred, x_pred = _forward_sample(
        model=model, z=z, t_batch=t_batch, x_pred_prev=x_pred_prev,
        config=config, cfg_scale=cfg_scale, self_cond_cfg_scale=self_cond_cfg_scale,
        cond_seq=cond_seq, cond_seq_mask=cond_seq_mask,
    )
    return z + (t_next - t) * v_pred, x_pred                # Euler: z_{i+1} = z_i + dt · v

6.3 SDE step — PyTorch branch（与论文伪码 Alg 6 update 基点略有差异：从 z_back Euler，不是从原 z）

def _sde_step(model, z, t, t_next, x_pred_prev,
              config, cfg_scale, self_cond_cfg_scale,
              cond_seq, cond_seq_mask, gamma, generator):
    h      = float(t_next - t)
    alpha  = max(0.0, min(1.0, 1.0 - gamma * h))            # 信号保留比例 ∈ [0,1]
    t_back = alpha * float(t)                               # 时间往回拉到 α·t

    eps = torch.randn(z.shape, dtype=z.dtype, device=z.device) * config.denoiser_noise_scale
    z_back = restore_cond(alpha * z + (1.0 - alpha) * eps, cond_seq, cond_seq_mask)

    t_batch = torch.full((z.shape[0],), t_back, dtype=z.dtype, device=z.device)
    v_pred, x_pred = _forward_sample(
        model=model, z=z_back, t_batch=t_batch, x_pred_prev=x_pred_prev,
        config=config, cfg_scale=cfg_scale, self_cond_cfg_scale=self_cond_cfg_scale,
        cond_seq=cond_seq, cond_seq_mask=cond_seq_mask,
    )
    # 从 backtracked state 用 Euler 一步推到 t_next
    return z_back + (t_next - t_back) * v_pred, x_pred

三个直觉：

1. γ = 0: alpha = 1, t_back = t, z_back = z — 退化为 ODE Euler
2. γ > 0: alpha < 1，z 被 α 缩小并注入新噪声 (1-α)·ε — 相当于把"已经去噪一些"的状态拉回到更早时刻，再 denoise 一次
3. 因此 SDE 是用额外随机性"修正"早期 denoise 错误。Tab 7 同 CFG 下 SDE 比 ODE PPL 低 12-35%（详见 6.8）

6.4 时间网格 — 训练同分布的 logit-normal

# 函数签名默认参数是 P_mean=-0.8（旧默认）
# 但 caller 在 generation.py 中传入 config.denoiser_p_mean = -1.5（OWT 训练值）
def get_sampling_steps(n_steps, time_schedule="logit_normal",
                       P_mean=-0.8, P_std=0.8, device=None, dtype=torch.float32):
    if time_schedule == "uniform":
        return torch.linspace(0.0, 1.0, n_steps + 1, dtype=dtype, device=device)

    # logit-normal：从训练同分布抽 n_steps - 1 个点
    z = torch.randn((n_steps - 1,), dtype=dtype, device=device) * P_std + P_mean
    steps = torch.sigmoid(z)
    steps = torch.sort(steps).values                        # 升序排列
    # 强制端点 0 / 1
    lo = torch.zeros((1,), dtype=dtype, device=steps.device)
    hi = torch.ones((1,),  dtype=dtype, device=steps.device)
    return torch.cat([lo, steps, hi], dim=0)                # [n_steps + 1]

论文 App B.2："smaller intervals when t is close to 0 and larger intervals as t approaches 1"。 P_mean=−1.5 使 sigmoid(N(−1.5, 0.64)) 的密度向 t 较小的 noisy 区集中， 所以中间 sample 点偏小 → 排序后noisy 区间隔细密、clean 区间隔粗，与训练 t 同分布匹配。

6.5 _forward_sample — 套两层 CFG

真实的每步 forward要处理两层 CFG：

• SC-CFG（self-conditioning CFG）：训练时已烤进网络，推理时只需一次 forward；通过 self_cond_cfg_scale token 编码 ω
• Input-cond CFG（条件生成才有）：标准推理时 CFG，需要 cond + uncond 两次 forward

# sampling_utils.py — 双层 CFG 嵌套

def _forward_sample(model, z, t_batch, x_pred_prev, config,
                    cfg_scale, self_cond_cfg_scale, cond_seq, cond_seq_mask):
    # 内层：带 cond 的 forward（条件 token + SC-CFG）
    v_cond, x_cond = _forward_sample_self_cond(
        model, z, t_batch, x_pred_prev, config,
        self_cond_cfg_scale=self_cond_cfg_scale,
        cond_seq=cond_seq, cond_seq_mask=cond_seq_mask,
    )
    if cfg_scale == 1.0:
        return v_cond, x_cond                       # 无 input-cond CFG，直接返回

    # 外层：input-cond CFG → 再跑一次 uncond
    z_uncond = restore_cond(z, torch.zeros_like(z), cond_seq_mask)
    x_pred_prev_uncond = (None if x_pred_prev is None else
                          restore_cond(x_pred_prev, torch.zeros_like(x_pred_prev), cond_seq_mask))
    v_uncond, x_uncond = _forward_sample_self_cond(
        model, z_uncond, t_batch, x_pred_prev_uncond, config,
        self_cond_cfg_scale=self_cond_cfg_scale,
        cond_seq=torch.zeros_like(cond_seq), cond_seq_mask=cond_seq_mask,
    )
    # 标准 CFG 线性组合
    v_out = v_uncond + cfg_scale * (v_cond - v_uncond)
    x_out = x_uncond + cfg_scale * (x_cond - x_uncond)
    return restore_vx(v_out, x_out, cond_seq, cond_seq_mask)

每步代价（worst case，cond 生成）：2 次模型 forward（cond + uncond）。 OWT 无条件生成 cfg_scale=1，每步只1 次 forward。SC-CFG 被烤进训练所以不用 ×2。

6.6 单步算力 vs Baseline

6.7 论文 Tab 6 — System-level @ OWT (6 seeds)

论文 page 26 Table 6（6 个 evaluation seed 平均 ± SE）：

三个观察：

1. 32 步 SE 极小 (0.16)——结果非常稳定，不是单 seed 运气
2. γ 从 2.0 → 1.5 — 步数多时不需要那么多噪声注入
3. 从 8 到 32 步 PPL 砍 ⅔（67.32 → 24.08），但 entropy 几乎不变（~5.15）

6.8 论文 Tab 7 — Scaling × CFG × Sampler（64 步）

论文 page 26 Table 7。三个 size × 两种采样器 × CFG sweep。SDE 全方位优于 ODE。 表内灰色项是 entropy < 5.0（多样性不足，不算 valid）：

ⁱ = 论文表中标灰的 cell：CFG > 3 后 ELF-B / ELF-M 出现 PPL 反转/上升， 不是 entropy < 5.0；它们 entropy 仍 ≥5.29。论文 App C 同时用 entropy < 5 或 PPL > 300 作"poor generation"红区。

关键观察（数字均来自 Tab 7 valid 区间内）：

• SDE 对 ODE 同 CFG 下降幅显著：CFG=2 时 ELF-B 35.0% / ELF-M 32.7% / ELF-L 21.5%；CFG=3 时 25.9% / 24.7% / 12.3%
• 更大模型偏好更高 SC-CFG：ELF-B 在 CFG=3 取得 valid 区最低 PPL 19.72；ELF-M 在 CFG=3 取 21.69； ELF-L 在 CFG=4 取 21.37（论文文字说"only ELF-L benefits from CFG=3 to 4"）
• ELF-L 的 PPL 没有 ELF-M 低 — paper 解释为 entropy-PPL frontier 在更大模型上 trade-off 点更右

6.9 条件生成默认 (XSum / WMT)

src/configs/sampling_configs/cond_sampling_configs.yml：

- sampling_method: ode
  num_sampling_steps: [64]
  cfgs: [2]                  # input-cond CFG = 2
  self_cond_cfg_scales: [1]  # SC-CFG = 1（已烤进训练）
  time_schedule: logit_normal

条件生成默认使用 ODE（paper/config 默认；论文未明确解释，可理解为条件任务在标准 CFG=2 下已经稳定，不需要 SDE 额外随机性）。 SC-CFG=1 因为推理时不需要额外 ω 调整；input-cond CFG=2 是标准 image diffusion 推理时 CFG。

6.10 PyTorch port 与 JAX 原版的数值漂移承诺

README 承诺：PyTorch port 在 8× L40S / H200 上跑应与 paper TPU v5p-64 数字漂移 ≲ 1 Gen-PPL 或 < 0.5 BLEU/ROUGE。漂移来源：

• bf16 autocast（PyTorch）vs JAX TPU 默认 numerics
• 采样过程的随机 RNG（每次 batch 抽 logit-normal 时间网格、SDE noise injection、init z）
• Muon NS5 内部 numerics 重新走 PyTorch（fp32-patched）vs optax.contrib.muon

README 强调用 use_bf16=true（匹配训练 precision）和 use_compile=true（torch.compile ~3-4× speedup）作为推荐 eval flag。

7 · 主结果 — 全部数字

7.1 Scaling: 三个 size 都改善 Gen-PPL / Entropy frontier

Tab 7 各 size 内自身最低 valid PPL（valid = 落在 entropy 合理区）： ELF-B SDE CFG=3 → 19.72；ELF-M SDE CFG=3 → 21.69；ELF-L SDE CFG=4 → 21.37。 绝对最低是 ELF-B 的 19.72；ELF-L 21.37 比 ELF-M 21.69 更低。 但 paper 强调 frontier 而非单点最低：scaling 整体向更优方向推进（同 entropy 下更低 PPL，同 PPL 下更高 entropy）。

7.2 系统级对比（Fig 7）— 三个独立维度全面胜出

Fig 7(a) — Gen-PPL vs Sampling Steps

ELF-B 32 步达到 Gen-PPL ≈ 24。从 Fig 7(a) 视觉读数：ELF-B 32-step 已接近或优于若干 baseline 在高 step（如 1024）下的水平， 推理时间 substantially less than prior methods（paper §4.2 原文）。

Fig 7(b) — Distillation 后的 baseline 也输给原版 ELF

三种蒸馏过的 few-step variant：

• MDLM + SDTT [Deschenaux & Gulcehre, ICLR 2025]
• Duo + DCD [Sahoo et al. 2025]
• FMLM [Hu et al. 2026] (flow-map）

这些都需要额外蒸馏阶段（10K-100K extra steps），但 32 步 PPL 还是不如未蒸馏的 ELF-B。 即在这套系统配置下，ELF 不加额外 distillation 仍然超过这些 distilled baselines（"架构层面的优势"是我对这个现象的解读，非论文逐字 claim）。

Fig 7(c) — Training token 预算（柱状）

详见 4.9 节 Tab 5：ELF 45.2B 总 token，所有 baseline 都在 524-577B 区间， 其中蒸馏 variant 因为还要加蒸馏 epoch，token 更多。精确 ratio 11.6× / 12.2× / 12.8×（paper 简称 ~12×）。 Tab 5 只统计 ELF/baseline 自身训练与蒸馏 token，不包含外部 encoder 预训练成本。

7.3 条件生成（Tab 1）— 2 任务 / 4 指标全部表内最佳

† = 直接取自该方法原 paper（De-En 数据的默认来源）； ‡ = ELF 团队用公开 codebase 重跑（XSum 数据的默认来源）；Duo De-En 在 ELF 团队的对比里也是 ‡（重跑）。

重要观察：

• BLEU 26.4 比第二名（AR 25.2）高 1.2 分；超过同模型族 MDLM 8.0 分
• XSum R-1 36.0 比第二名 MDLM 33.4 高 2.6 分
• ELF-B（105M+35M = 140M）参数少于 Duo 的 170M+35M = 205M，依然全胜
• AR 在 De-En 上比所有对比的 DLM baseline 强（25.2 vs MDLM 18.4 / Duo 21.3 / E2D2 24.8 / SeqDiffuSeq 21.3 / CDCD 24.9）， 在本表对比中，ELF 是唯一超过 AR baseline 的 DLM

7.4 关键 ablation 汇总（App C 全部 7 个 ablation）

论文 App C (pages 20-23) 系统 ablate 7 个设计选择。这是"为什么 ELF 能 work"的实证支撑：

C.1 — 为什么 x-pred 才行？

三种 prediction 是数学等价的，但训练 signal 完全不同。论文用三个 encoder size (T5-small/base/large = 512/768/1024 dim) sweep：

• x-pred：512/768/1024 dim 都稳定，frontier 接近平行
• v-pred：512 dim ok，768 退化，1024 严重退化（PPL 高 100+）
• ε-pred：全 dim 都崩（PPL > 300 或 entropy < 5）

解释：clean 文本数据在 embedding 空间是低维流形。x-pred 预测的就是这个流形上的点； ε-pred 预测的是高维 Gaussian，模型必须学一个全维度等熵分布——更难。 这条 finding 支持"continuous DLM 的关键不是连续，是 x-prediction" 的 framing。

C.3 — 80/20 denoise/decode 比例

很反直觉：如果 decoder 占比上升到 0.5，按理说 decoder 应该学得更好——但实际整体 frontier 都退化。 解释：decoder 共享 transformer 主干。如果训练时频繁切换 mode，主干被两个目标拉扯；只占 20% 时 decoder 学到的是 "在已经 transport 到 clean 的 embedding 上做最后一步映射"——比例小但效果反而好。

C.6 — Time schedule 在 few-step 时尤其关键

Logit-normal time grid 让 noisy 区间更密——8-step 时这极其重要。 Uniform 8 步 PPL 远高于 logit-normal 8 步。32-step 之后两者差距收窄。
γ sweep（paper 选默认值）：8/16 步默认 γ=2.0；32 步 γ=1.5；64 步 γ=1.0。 论文文字说 γ 控制 PPL/entropy trade-off，paper 默认 γ=1.0 作为各 step budget 的 balance； 8/16 步用更大 γ=2.0 是因为粗步长需要更多 stochasticity 修正噪声累积。

7.5 Tab 6 + Tab 7 数据汇总（detail 详见 6.7-6.8）

7.6 数据来源 & 实验环境

• OWT dataset: OpenWebText（Gokaslan & Cohen 2019）— 9.04B tokens, GPT-style web text
• WMT14 De-En: L=128, 144M total target tokens（paper §4 page 6）
• XSum: L=1088, 6M total target tokens（paper §4 page 6）
• Gen-PPL 判官: frozen GPT-2 Large
• Entropy: 生成 token 的 unigram entropy（多样性指标）
• 训练硬件: TPU v5p × 64（OWT 5 epochs ≈ 7.5h 总 for ELF-B）
• PyTorch port evaluation 推荐 target: 8× L40S / H200 + use_bf16 + use_compile

8 · 定性效果 — 去噪轨迹

这张图回答了"continuous DLM 到底在做什么"——它在 embedding 空间里描出一条平滑轨迹， 最后一步才把轨迹终点投影到 token 词表。和离散 DLM 每步都做 vocab argmax 完全是两套范式。

9 · 和字节 Cola-DLM 对比 — Field Landscape

Cola-DLM（ByteDance Seed, arXiv 2605.06548, 2026 年 5 月） 是和 ELF 几乎同时（2 周内）冒出来的同类工作。两边都是 continuous DLM，但设计哲学几乎相反： ELF 求简，Cola 求强。下面是我从 Cola 的公开 blog 和 arXiv 摘要整理的对比。

9.0 一句话定位

9.1 关键差异表

9.2 ELF / Cola 的客观技术差异

9.3 两边各自能给出而另一边给不出的 claim

9.4 Cola-DLM 两阶段训练 + 推理（来自他们 blog）

Cola 不像 ELF 那样单阶段端到端训练。两个训练阶段 + 独立的推理流程：

关键超参（来自 blog RQ4 sweet spot 表，released checkpoint 配置）：

• Latent dim: 16
• Block size: 16
• VAE learning-rate ratio: 1.0（与 DiT 同 lr）
• Noise schedule location: 1.0
• Sampling steps: 16
• Classifier-free guidance: 7（released checkpoint 默认；blog 说 CFG ≈ 3-7 范围内表现最好）
• VAE logSNR: 可学（收敛到 ≈ 4.5）

9.5 Block-Causal Attention（Cola 的核心架构选择）

Cola DiT 在序列维度上做块因果（block-causal）分解：

• Block 内部（block size = 16 个 token-block 位置）：完全双向 attention，就像普通 DiT
• Block 之间：因果 attention，第 i 个 block 只能看到 [0..i] 的 block；不能看到 i+1, i+2, ...

这种设计的好处：

1. KV cache 兼容：因为 inter-block 是因果的，已经生成完的早期 block 的 K/V 可以缓存。下一个 block 不重新算前面的 attention，类似 AR 的推理加速。
2. 训练时仍并行：teacher forcing 的常规做法，把 block-causal mask 加到 attention 矩阵，所有 block 一次性算完。
3. 生成质量 vs AR 的赌注：保留 diffusion 的"全 batch 同时 denoise"特性（block 内并行），同时获得 AR 的推理时 KV cache 加速

Block size sweep（来自他们 RQ2/RQ3）：

• block = 1 → 等价 token-level causality，太严格，结果差
• block = 16 → 最佳 Task Avg（他们默认）
• block = 64, 128 → 显著降级（block 越大，等价越接近全双向 + 失去 KV cache 收益）

9.6 Cola-DLM benchmark 数据（released checkpoint @ 2000 EFLOPs）

Cola 不报 Gen-PPL。他们用"generative few-shot"协议把多选题转成生成任务， 和 AR + LLaDA 在 ~2B 同 scale 下对比。来自 ByteDance-Seed/Cola-DLM GitHub model card 的 released 数字：

注意：blog 内 RQ2/RQ3 ablation 表给出更小的训练 budget 下数字（LAMBADA 31.1-34.6 / MMLU 5.4-10.1 / SIQA 11.1-23.6 等）， 但这些是消融区间，不是 headline。上面才是 released checkpoint 数字。

他们的 scaling 实验跑到 ~2000 EFLOPs。Blog 说 "Task Avg 在 ~2000 EFLOPs 还在 rising"—— 官方称仍有 headroom，没看到饱和。

9.7 Cola 的关键 ablation 发现（他们 RQ2/RQ3）

这里有个有意思的对比：Cola 通过 ablation 证明 joint VAE+DiT 训练在大算力下更优；ELF 通过 ablation 证明 frozen encoder 在小数据小算力下更优。两个结论不矛盾—— 它们对应不同的训练规模、不同的"哪个组件更值得优化容量"的判断。

9.8 客观差异汇总

• 规模与训练成本：ELF 105M / 45.2B tokens；Cola ~2B / 2000 EFLOPs（两阶段 VAE + DiT）
• 语义几何来源：ELF 用 frozen T5-small contextual embedding；Cola 用与 diffusion 联合训练的 VAE latent
• 评测对象：ELF 报 Gen-PPL / BLEU / ROUGE；Cola 报 LAMBADA / MMLU / SIQA 等 reasoning task
• 采样 serving 路径：ELF 非因果全局 attention；Cola block-causal + KV-cache，可按 block 增量推理
• 需要调的杠杆数：ELF 主要是 logit-normal schedule + denoise/decode 比例 + bottleneck dim；Cola 还多 VAE 质量 + latent dim + logSNR + block size + anti-drift KL + CFG + 评测协议
• 关于 scaling ceiling：论文未直接给出 ELF 在更大 encoder 下的 scaling 曲线（C.1 ablation 只到 T5-large 1024-dim）；Cola blog 报 curve still rising 至 2000 EFLOPs

10 · Q&A

10.A 关于 ELF 自身

10.B 关于 Cola-DLM / 两条路线对比

11 · 引用 & 资源

背景文献（用来支撑 punchline 的 framing）

• 离散 DLM 起源：D3PM [Austin et al. 2021], SEDD [Lou et al. 2024], MDLM [Sahoo et al. 2024]
• 2B+ 离散：LLaDA [Nie et al. 2025], Dream [Ye et al. 2025]
• Factorized gap 修补：CoDD [2026], CoDAR [2026], BD3-LM [Arriola 2025]
• Continuous DLM 旧路：Diffusion-LM [Li 2022], CDCD [Dieleman 2022], Plaid [Gulrajani 2023], LD4LG [Lovelace 2023]
• 训练时 CFG trick：Chen et al. "Visual Generation without Guidance" 2025
• Muon：Jordan et al. blog 2024

作者 Ruofeng Yang（杨若峰） (Shanghai Jiao Tong University, 2026-05)。文档由 ARIS (Auto Research in Sleep) 的生态 ARIS-in-AI-Offer 工作流产出，由 Claude Opus 4.7 整合 Codex GPT-5.5 xhigh + Gemini auto-gemini-3 跨模型讨论后撰写。本文是关于 ELF 等 continuous DLM 论文的第三方阅读笔记 / 综述，所有论文内容、图表、代码版权归各自原作者所有。 图片均截自 ELF arXiv PDF v1（2026-05-11）。代码片段来自官方 pytorch_elf 分支 @ b29d883。 中间审计 trace 保存在 .aris/traces/research-review/2026-05-26_run01/。