第 1 期 · 2026-10-31

详细算法

1. 问题设定

交互轨迹 $\tau=(o_0,a_0,o_1,a_1,\ldots,o_T,a_T)$，其中 $o_0$ 为任务 prompt，$a_t$ 为第 $t$ 轮 assistant 输出（工具调用或最终回答），$o_{t+1}$ 为环境反馈。每个输出是 token 序列 $a_t=(a_{t,1},\ldots,a_{t,L_t})$。历史 $h_t=(o_0,a_0,\ldots,o_t)$，token 前缀 $h_{t,i}=(h_t,a_{t,<i})$。

策略自回归分解：$\pi_\theta(a_t\mid h_t)=\prod_{i=1}^{L_t}\pi_\theta(a_{t,i}\mid h_{t,i})$。只有终端奖励 $R(\tau)$，且仅最后一个 token 获得：$r_{t,i}=R(\tau)$ 当 $t=T,i=L_T$，其余为 0。目标 $\mathcal J(\theta)=\mathbb E_{\tau\sim p_\theta}[R(\tau)]$。环境 token 进入历史但不是策略动作。

2. 关键公式

价值边界与 TD 残差（critic $V_{t,i}=V(h_{t,i})$，rollout 时固定；$\gamma=1$）：

$$V_{t,L_t+1}:=V_{t+1,1},\quad V_{T+1,1}:=0,\qquad \delta_{t,i}=r_{t,i}+V_{t,i+1}-V_{t,i}$$

轮级 GAE（轮内 TD 残差求和后，内部 critic 预测相互抵消）：

$$\delta^{\text{turn}}_t=\sum_{i=1}^{L_t}\delta_{t,i}=\mathbf 1\{t=T\}R(\tau)+V_{t+1,1}-V_{t,1},\qquad A^{\text{turn}}_t=\delta^{\text{turn}}_t+\lambda A^{\text{turn}}_{t+1}$$

轮内局部 trace（只在本轮内截断）：

$$A^{\text{intra}}_{t,i}=\sum_{j=i}^{L_t}\lambda_{\text{intra}}^{\,j-i}\,\delta_{t,j}$$

MAE：带均值约束的最小二乘投影 $\min_{\mathbf w}\tfrac12\|\mathbf w-\beta\mathbf A^{\text{intra}}_t\|_2^2$，约束 $\tfrac1{L_t}\sum_i w_i=A^{\text{turn}}_t$，其唯一解：

$$A^{\text{MAE}}_{t,i}=A^{\text{turn}}_t+\beta\big(A^{\text{intra}}_{t,i}-\overline{A}^{\text{intra}}_t\big),\qquad \overline A^{\text{intra}}_t=\tfrac1{L_t}\textstyle\sum_i A^{\text{intra}}_{t,i}$$

整轮重要性比与 stop-gradient 构造：

$$\rho_{t,i}=\frac{\pi_\theta(a_{t,i}\mid h_{t,i})}{\pi(a_{t,i}\mid h_{t,i})},\quad \rho_t=\prod_{i}\rho_{t,i},\quad \tilde\rho_{t,i}=\rho_{t,i}\cdot\mathrm{sg}\Big[\prod_{j\ne i}\rho_{t,j}\Big]$$

前向值 $\tilde\rho_{t,i}=\rho_t$，梯度 $\nabla\tilde\rho_{t,i}=\rho_t\nabla\log\pi_\theta(a_{t,i}\mid h_{t,i})$。

MPO 目标（$\widehat A$ 为在 batch 内对所有有效 assistant token 归一化后的 MAE 优势，更新期间固定）：

$$\mathcal L_{\text{MPO}}(\theta)=\widehat{\mathbb E}_{t,i}\Big[\min\big(\tilde\rho_{t,i}\widehat A^{\text{MAE}}_{t,i},\ \mathrm{clip}(\tilde\rho_{t,i},1-\epsilon,1+\epsilon)\widehat A^{\text{MAE}}_{t,i}\big)\Big]$$

理论：turn 级改进下界（$A_{\max}$ 为优势上界，$\alpha_M$ 为各历史处整轮输出分布的最大 TV 距离）：

$$\mathcal J(\pi')-\mathcal J(\pi)\ \ge\ \mathcal S_M-2A_{\max}T(T+1)\alpha_M^2$$

3. 逐步伪代码

输入: 策略 π_θ, critic V_φ, 任务集 D, 超参 λ, λ_intra, β, ε
      (论文消融中最佳: λ=0.80, λ_intra=0.95, β=1.0; critic 的 λ_critic=1)

repeat 每个训练迭代:
    # 1. Rollout
    对每个任务采样轨迹 τ=(o0,a0,...,oT,aT); 记录每个 assistant token 的 log π_old 与终端奖励 R(τ)

    # 2. 取旧策略下的 critic 值 (估计优势期间固定)
    V[t,i] = V_φ(h_{t,i});   V[t,L_t+1] := V[t+1,1];   V[T+1,1] := 0

    # 3. token 级 TD 残差
    δ[t,i] = r[t,i] + V[t,i+1] - V[t,i]          # r 仅在轨迹最后一个 token 为 R(τ)

    # 4. 轮级 GAE (跨轮传播信用)
    A_turn[T+1] = 0
    for t = T downto 0:
        δ_turn[t] = Σ_i δ[t,i]
        A_turn[t] = δ_turn[t] + λ * A_turn[t+1]

    # 5. 轮内再分配 (均值保持)
    for 每一轮 t:
        A_intra[t, L_t+1] = 0
        for i = L_t downto 1:
            A_intra[t,i] = δ[t,i] + λ_intra * A_intra[t,i+1]
        Ā = mean_i A_intra[t,i]
        A_MAE[t,i] = A_turn[t] + β * (A_intra[t,i] - Ā)

    # 6. batch 内对所有有效 assistant token 归一化 -> Â, 更新期间固定

    # 7. 策略更新 (整轮重要性比 + stop-gradient)
    ρ[t,i]  = π_θ(a_{t,i}|h_{t,i}) / π_old(a_{t,i}|h_{t,i})
    ρ̃[t,i] = ρ[t,i] * stopgrad( Π_{j≠i} ρ[t,j] )      # 前向值 = 整轮比 ρ_t
    L = mean_{t,i} min( ρ̃·Â , clip(ρ̃, 1-ε, 1+ε)·Â )
    θ <- θ + lr * ∇_θ L

    # 8. critic 更新: 以 λ_critic=1 直接回归终端回报 R(τ)

4. 训练 / 推理流程

训练：在三类智能体环境中分别训练——Search、Claw-Eval、Automation Bench；步数分别为 300 / 300 / 200。基座为 Qwen3-4B-Thinking 与 Qwen3-30B-A3B-Instruct。对比 Base、GRPO、GSPO、PPO、VAPO、SAO，另设「MPO w/ token IS」（保留 MAE，但把整轮比换回 token 比）以隔离更新目标的作用。

评测协议：每次训练取最佳 checkpoint，离线评测 5 次取均值。Search 以 BrowseComp-Plus、GAIA、HLE 报告 pass@1 / pass@3（训练后模型用每题 32 条独立 rollout 估计）；Claw-Eval 报告 pass@3 与 pass^3；Automation Bench 报告 pass@1。

推理：推理时就是普通的智能体推理，MPO 只改变训练，不引入额外推理开销。

详细算法

1. 问题设定

语言模型为策略 $\pi_\theta(y\mid x)$，自回归生成。验证器 $r(x,y)\in\{0,1\}$。目标是 $\mathbb E_{x\sim\mathcal D}\mathbb E_{y\sim\pi_\theta}[r(x,y)]$。GRPO 对每个 prompt 采样 $G$ 条回答 $\{y_i\}$，用组内奖励的均值/标准差产生响应级优势。

ReAPO 的多尝试设定：第 $g$ 条 rollout 的第 $k$ 次尝试为 $y_{g,k}$，奖励 $r_{g,k}$；$\tau_g=\inf\{k\ge1: r_{g,k}=1\}$ 为首次成功的尝试序号；上下文 $h_{g,k-1}=(x,y_{g,1},\ldots,y_{g,k-1})$。训练时每题最多 $K$ 次尝试（主实验 $K=2$）。

2. 关键公式

GRPO 优势与目标（背景）：

$$\hat A_i=\frac{r_i-\mu_r}{\sigma_r+\varepsilon},\quad \mu_r=\tfrac1G\sum_i r_i,\ \ \sigma_r=\sqrt{\tfrac1G\sum_i(r_i-\mu_r)^2}$$

SSP 视角：令 $q_m(\theta)=\mathbb P(r_m=1\mid r_j=0,\,j<m)$，$\alpha_m=\mathbb P(\tau\ge m)$，$c_m=\sum_{k\ge m}\prod_{j=m+1}^{k}(1-q_j)$（失败 $m$ 次后期望还需的额外尝试数）。则

$$-\nabla_\theta\,\mathbb E_{\pi_\theta}[\tau-1]=\sum_{m=1}^{\infty}\alpha_m(\pi_\theta)\,c_m(\pi_\theta)\,\nabla q_m(\theta)$$

命题 2：若 $c_m\equiv C(\pi_\theta)$ 与 $m$ 无关，则

$$-\nabla_\theta\,\mathbb E[\tau-1]=C(\pi_\theta)\cdot\mathbb E\Big[\tfrac1G\sum_{g=1}^{G}\sum_{k=1}^{\tau_g}r_{g,k}\,\nabla_\theta\log\pi_\theta(y_{g,k}\mid h_{g,k-1})\Big]$$

ReAPO 更新方向（$\hat A_{g,k}$ 的均值与标准差在池化的全部尝试奖励 $\{r_{g,k}\}$ 上计算；$T=\sum_g\sum_{k\le\tau_g}|y_{g,k}|$）：

$$\nabla_\theta\mathcal J_{\text{ReAPO}}=\mathbb E\Big[\frac1T\sum_{g=1}^{G}\sum_{k=1}^{\tau_g}\hat A_{g,k}\,\nabla_\theta\log\pi_\theta(y_{g,k}\mid x,y_{g,<k})\Big]$$

若所有尝试奖励相同，则归一化优势为 0，该题不产生梯度（与 GRPO 一致）。实验中 on-policy（$\pi_{\theta_{\rm old}}=\pi_\theta$）且去掉 KL 项。

3. 逐步伪代码

# 据 §3 文字描述整理（并非逐行抄录论文 Algorithm 1）
输入: 策略 π_θ, 验证器 r, 数据集 D, 组大小 G, 最大尝试数 K, retry 提示语
for 每个训练 step:
    采样一批题目 {x}
    for 每个题目 x:
        for g = 1..G:                                  # 并行 G 条
            y[g,1] ~ π_θ(·|x);   r[g,1] = r(x, y[g,1]);   k = 1
            while r[g,k] == 0 and k < K and 未超 token 预算:
                ctx = x + y[g,1] + ... + y[g,k] + "Your answer is wrong. Reflect on your previous answer and try something else."
                y[g,k+1] ~ π_θ(·|ctx);   r[g,k+1] = r(x, y[g,k+1]);   k += 1
            τ_g = k
        R_pool = 池化所有 r[g,k]
        μ, σ = mean(R_pool), std(R_pool)
        Â[g,k] = (r[g,k] - μ) / (σ + ε)               # 所有尝试一起归一化
    # 优势只分配给对应尝试自己的 token
    loss = - (1/T) * Σ_g Σ_{k<=τ_g} Â[g,k] * Σ_{token∈y[g,k]} log π_θ(token | 其前缀与上下文)
    θ <- θ - lr * ∇loss

4. 训练 / 推理流程

训练：模型为 Qwen3-0.6B-Base（GSM8K-Platinum，8 个种子）、Qwen3-1.7B-Base 与 Qwen3-4B-Base，另用 OLMo-2-0425-1B-SFT 做跨模型族验证；覆盖 8 个数学与科学推理基准，主实验 $K=2$。

推理：评测只看「首次尝试」，推理时不需要验证器与重试——重试仅在训练中用来改进探索与信用分配。

对照：GRPO（同步数）、GRPO 双倍步数、GRPO 双倍组大小（$G=32$，对应 $G=16,K=2$ 的最大尝试数）、SCoRe Stage-II-only、MaxRL，以及「无条件重试」「整条轨迹单一优势」两个消融。

详细算法

1. 问题设定

任务：群字问题（group word problem）。提示给出 $d$ 个对五个盒子（各放一件物品）的操作，询问某个盒子里是什么。swap-$S_5$：每步为恒等或 10 个对换之一；$A_5$：每步为一个 3-循环。随机猜测准确率 0.2。训练长度 $\le 32$（swap-$S_5$）或 $d\le16$（$S_5$、$A_5$），测试至更长。整体状态准确率要求五个盒子全对。

模型：把 Qwen2.5-0.5B 的 24 层改造成 prelude $P$（1–8 层）+ 权重共享的 core $C$（9–16 层）+ coda $Q$（17–24 层）的 retrofitted looped LM（沿用 McLeish 等的做法）。答案用分类头在候选答案 token 上读出，不生成任何中间 token。

2. 关键公式

retrofitted 循环（$e=P(x)$，$s_0=e$，adapter $W\in\mathbb R^{h\times 2h}$ 初始化为 $[0\,|\,I]$，使 $R=1$ 时与父模型等价）：

$$s_k=C\big(W[e;\,s_{k-1}]\big),\quad k=1,\ldots,R,\qquad y_k=Q(s_k)$$

进度对齐损失（$z_j$ 为前 $j$ 步之后的答案，$d$ 为总步数，步长 $c=1$，$\mathcal K$ 为梯度窗口内的迭代集合）：

$$\mathcal L_{\text{PAR}}=\sum_{k\in\mathcal K}\mathrm{CE}\big(Q(s_k),\ z_{\min(ck,\,d)}\big)$$

状态 norm 锚定（stop-gradient 于参考项）：

$$s_k\leftarrow s_k\cdot\frac{\mathrm{rms}(s_1)}{\mathrm{rms}(s_k)}$$

Positional stretch：短暂微调阶段把位置索引乘以 $s\sim U[1,s_{\max}]$，$s_{\max}$ 从 1 斜升到 8，测试时用普通位置。

学习停止：读出头在 $ck\ge d$ 时对 token「Yes」放概率，否则放在「No」，类别平衡交叉熵权重 0.5。推理取第一个满足 $P(\text{Yes})>\tau$ 且在窗口 $R,\dots,R+m-1$ 内至少 $k$ 次超过 $\tau$ 的迭代 $R$（$\tau=0.5,k=6,m=8$）。

Prefix self-distillation：对 $k<\lceil d/c\rceil$ 的迭代，用 EMA 教师在截断到 $ck$ 步的 prompt 上、在其自身完成迭代处的答案分布做 KL 监督；$k\ge\lceil d/c\rceil$ 的迭代用最终答案 $z_d$ 交叉熵。

3. 逐步伪代码

# 训练 (forced depth, 默认的 PAR)
for 每个 batch (同一 batch 内深度 d 相同):
    R = ceil(d / c)                       # c = 1
    e = P(x);  s = e
    for k = 1..R:
        s = C( W · concat(e, s) )
        s = s * rms(s_1) / rms(s)          # state-norm anchoring (stop-grad 于 rms(s_1))
        if k 在最后 8 次迭代 (梯度窗口):  loss += CE( Q(s), z[min(c*k, d)] )
        # 同时训练 halting 头: 目标 = Yes if c*k >= d else No (类别平衡, 权重 0.5), 另加一个更早的迭代作额外负例
    反向传播 (梯度只通过最后 8 次迭代)

# 推理 (不知道问题长度)
s = e = P(x)
for k = 1..Kmax:
    s = C(W·[e; s]); s = anchor(s)
    p_yes[k] = P_Q(Yes | s)
    if 存在 R<=k-m+1 使 p_yes[R] > 0.5 且 窗口 [R, R+8) 内至少 6 次 > 0.5:
        return 读出 Q(s_R)                 # 在「完成信号」刚出现处读取答案

4. 训练 / 推理流程

训练：AdamW，学习率 $2\times10^{-5}$（adapter $10^{-4}$），200 步 warm-up，约 40 万样本一个 epoch，训练深度均匀分布；全程不产生中间 token。深度调度有两种：forced depth（每批一个深度 $d$，迭代 $R=\lceil d/c\rceil$）与 hold（$R$ 取自重尾分布，超过 $d/c$ 的迭代保持 $z_d$）。

评测：swap-$S_5$ 用 Zhang 等的协议（训练 $\le32$ 步，每个长度 1,024 条序列测整体状态准确率）；外推倍数 $G=d_{50}/d_{\rm train}$，以测试深度至 256、$d_{\rm train}=16$ 时 $G=16$ 为最大可测值。

详细算法

1. 问题设定

输入 token 序列，输出自回归下一 token 分布。关键设计问题：如何在参数量固定（4B）的前提下，让每个 token 的计算量可调？Dory 的回答是 参数共享的深度循环：用同一个 20 层 R 块重复计算，把额外算力花在「潜空间思考」而不是更长的输出上。

2. 关键公式

【模型卡只给出结构描述、没有公式】 下式是依据模型卡文字（I/R/O 三组；R 重复；输入重注入每次循环）所做的示意，其中重注入的具体算子 $f$ 未公开（待确认）：

$$h_I=I(x),\qquad s_0=h_I,\qquad s_k=R\big(f(h_I,\,s_{k-1})\big),\ k=1,\ldots,n,\qquad y=O(s_n),\quad n\in\{1,2,3,4\}$$

KV cache 内存（模型卡文字）：per-loop 模式下 R 层 KV 占用 $\propto n$；last-loop 模式下与 $n$ 无关（每个循环注意力层仅保留最后一圈的 K/V）。

NVFP4（背景）：4 位浮点（E2M1）按小块缩放；Dory 用它做前 ~4.5T tokens 的原生预训练，之后切回 BF16。

3. 逐步伪代码

# 推理（示意；f 的具体形式模型卡未公开 -> 待确认）
def forward(tokens, n_loops, kv_mode):          # n_loops ∈ {1,2,3,4}; kv_mode ∈ {per_loop, last_loop}
    h_in = I_block(tokens)                       # 8 层
    s = h_in
    for k in 1..n_loops:
        s = R_block( inject(h_in, s) )           # 共享的 20 层; 输入重注入每一圈
        if kv_mode == "last_loop":
            覆盖写入 R 层的 K/V (只保留最后一圈)
        else:
            按圈各存一份 K/V
    return O_block(s)                            # 8 层 -> logits

# 服务（模型卡示例参数）
vLLM:      --hf-overrides '{"n_recurrent_loops": 2, "recurrent_kv_cache_mode": "last_loop"}'
llama.cpp: --override-kv "dory.num_loops=int:2,dory.recurrent_kv_cache_mode=str:last_loop"

4. 训练 / 推理流程

1. 预训练：6T tokens，Megatron-LM；前约 4.5T 为 NVFP4，其余为 BF16；数据为爬取 + 合成的代码、数学、科学与通用知识。
2. 上下文扩展：300B tokens → 256K。
3. SFT：NVIDIA 精选 SFT 数据。
4. RL：多环境 GRPO（数学、代码、科学、指令遵循、多步工具使用、多轮对话、结构化输出），异步 RL 架构解耦训练与推理。
5. 部署：BF16 / MXFP8（W8A16）/ NVFP4（W4A16）/ GGUF Q5_K_M；模型卡注明：vLLM 的 Dory 支持仍在评审中（vllm-project/vllm#60149，需从该 PR 安装）；llama.cpp 的支持在 PR #30306 中（需从含 Dory 的源码构建）。

详细算法

1. 问题设定

自回归 LLM：$p_\theta(x_{t+1}\mid x_{1:t})$；有 KV cache 时 $p_\theta(x_{t+1}\mid x_t,\mathcal C_{1:t-1})$。智能体轨迹 $x_{1:t}$ 包含 prompt、assistant 消息与工具响应，称为 logical token sequence。Active cache $\mathcal C$ 是后续 attention 实际可见的 KV 集合，其长度不必等于逻辑长度，且缓存项的位置编码索引也可独立于其逻辑索引。

目标：在不改变轨迹文本、不 re-prefill 保留部分的情况下，让 $\mathcal C$ 受智能体 / harness 控制，同时服务端能正确复用、驱逐与恢复这些「历史相关」的缓存。

2. 关键公式

三种缓存操作：

$$\operatorname{append}(x_{t+1}):\ \mathcal C\leftarrow[\mathcal C;\,C_{t+1}]$$

$$\operatorname{drop}(P):\ \mathcal C\leftarrow\mathcal C\setminus\{C_i:i\in P\}$$

（drop 只让这些 KV 不再参与后续 attention，保留项及其位置编码不变。）

Repos（RoPE 重定位）：保留 $r$ 个缓存项，其位置索引重置为 $0,\ldots,r-1$，下一个 token 使用索引 $r$。对 RoPE 键从位置 $p$ 移到 $q$：

$$K\leftarrow R(q)\,R(p)^{-1}K,\qquad V\ \text{不变}$$

缓存操作序列（确定性地描述缓存状态，从空缓存起）：

$$o_{1:m}=(o_1,\ldots,o_m),\qquad o_j\in\{\operatorname{append}(x),\ \operatorname{drop}(P),\ \operatorname{repos}\}$$

对固定 LLM，该序列决定当前缓存状态；仅有 token 与保留位置不足以决定下一 token 的概率。

3. 逐步伪代码

# 智能体侧 (tool-response rolling drop, 主策略)
每轮 agent 迭代:
    messages = 完整逻辑历史                       # 文本不改
    cache.drop  = 把 "早于最近 12 条的工具响应" 的消息下标加入 drop 表
    if 活跃上下文长度 > repos 阈值:  cache.reposition 追加当前消息边界
    请求 = {model, messages, cache}              # 无状态: 每次请求完整描述自己用到的缓存
    response = AKV.chat(请求)

# 服务端 AKV (对每个请求)
1. 前缀匹配: 在 extended radix tree 上沿 (token, 操作) 匹配
       - 遇到 drop 节点 Δ(记录被丢弃的逻辑下标): 仅当操作历史一致才复用
       - 遇到 reposition 节点: 位置编号一致则直接复用; 不一致则 "拷贝 + 旋转 K" (V 直接拷贝)
2. 缺失部分 (被逐出或首次出现) 用 segment-batch attention 单次 prefill 恢复:
       for 每一层:
           按 drop / repos 触发点把 query 切成段
           每段: 因果地 attend 自己的 token + 之前各段的 *活跃* 缓存
                 (被 drop 的缓存对之后的段不可见, 对原先使用它的更早的段仍可见)
           需要不同位置编码的段 -> 临时旋转 K / 拷贝 V 生成临时版本
           FFN 对整个序列只做一次批处理
3. 解码: 在 active cache 上生成, 把新 KV 写入树
4. 逐出: 先回收 "已被所有相关请求 drop" 的缓存, 再回收已完成请求的缓存; 节点保留为空占位, 以便后代缓存仍可前缀匹配

4. 训练 / 推理流程

评测模型：MiniMax-M2.7（230B 总参 / 10B 激活）、GPT-OSS-120B（高推理强度）、MiroThinker-1.7-Mini（30B / 3B 激活）。基准：BrowseComp-Plus（BCP）、xbench-DeepSearch-2510、GAIA 文本验证子集（103 题）、SWE-bench Verified。

对照：Standard（模型相关的摘要阈值：96K / 96K / 192K tokens）与 Text Engineering（统一 48K 阈值摘要）；AKV 取最近 12 条工具响应滚动 drop，repos 阈值同 Standard。

成本核算：用各厂商公开单价，对 AKV 每个被 repos 的 token 按缓存命中价额外计费（有意高估键旋转成本）。服务实验：基于 SGLang，8×A800-80GB（4 卡 prefill + 4 卡 decode，TP=4），因 A800 无原生 MXFP4，权重用 BF16。

详细算法

1. 问题设定

rectified-flow 参数化：$t=1$ 为噪声，$t=0$ 为干净样本；前向状态 $x_t=\alpha_tx_0+\sigma_t\epsilon$，样本速度目标 $u_t=x_0-\epsilon$。每次迭代对每个 prompt $c$ 从冻结的 rollout 策略 $p_{\rm old}$ 采 $K$ 个端点 $x_0^{(i)}$，得到黑盒奖励 $R_i=R(x_0^{(i)},c)$，不要求奖励可微。目标：用这些端点级反馈高效而稳定地更新速度网络 $v_\theta(x_t,t,c)$。

2. 关键公式

NFT 的目标（背景），$r_i=\tfrac12[1+\mathrm{clip}((R_i-\bar R_c)/Z_c,-1,1)]$，$v_{\theta,\pm}=v_{\rm old}\pm\beta(v_\theta-v_{\rm old})$：

$$\mathcal L_{\rm NFT}=\mathbb E\big[r\|v_{\theta,+}-u_t\|^2+(1-r)\|v_{\theta,-}-u_t\|^2\big]=\beta^2\mathbb E\|v_\theta-v_{\rm tgt}\|^2+\text{const}$$

命题 1（NFT 力分解），$e=v_{\rm fwd}^{\rm old}-v_{\rm rvs}^{\rm old}$：

$$\mathcal F_{\rm NFT}(s_t)=2g+(2q-1)e,\qquad \mathcal F_+=g+qe,\quad \mathcal F_-=g-(1-q)e$$

指数倾斜与协方差引理：$p_\tau(x_0\mid c)\propto p_{\rm old}(x_0\mid c)\,e^{\tau R(x_0,c)}$，则

$$\left.\frac{\partial}{\partial\tau}\mathbb E_{p_\tau}[x_0\mid c]\right|_{\tau=0}=\operatorname{Cov}_{p_{\rm old}}(R,x_0\mid c)$$

聚合优先的引导方向（式 5）：

$$\overline{\rm Cov}=\frac1K\sum_{i=1}^K(R_i-\bar R_c)(x_0^{(i)}-\bar x_{0,c}),\qquad G(c)=\frac{\overline{\rm Cov}}{\mathrm{RMS}(\overline{\rm Cov})}$$

冻结目标与逐状态损失（$w$ 含时间步权重与掩码，$D$ 为输出维数）：

$$v^{\rm ART}_{\rm tgt}(s_t)=v^{(0)}_\theta(s_t)+G(c),\qquad \mathcal L_\theta(s_t)=w(s_t)\cdot\tfrac1D\|v_\theta(s_t)-v^{\rm ART}_{\rm tgt}(s_t)\|_2^2$$

两次更新的输出梯度（$d=v_\theta-v^{(0)}_\theta$ 为漂移）：

$$-\nabla_{v_\theta}\mathcal L\big|_{v^{(0)}_\theta}=\tfrac{2w}{D}G(c),\qquad -\nabla_{v_\theta}\mathcal L\big|_{v^{(1)}_\theta}=\tfrac{2w}{D}\big(G(c)-d(s_t)\big)$$

Trust-region 掩码（KL 代理 $m$；$\delta=10^{-5}$）：

$$m(s_t)=\frac{\|\mu(s_t,v_\theta)-\mu(s_t,v^{(0)}_\theta)\|_2^2}{2D\,\sigma_{\rm ref}^2(t)},\qquad w(s_t)=t\Big[1-\mathbf 1\{m\ge\delta\}\,\mathbf 1\{\langle d,\,G-d\rangle>0\}\Big]$$

3. 逐步伪代码

# 据 §4 文字整理 (论文 Algorithm 1 的正文在文本抽取中缺失, 故非逐行抄录)
输入: 速度网络 v_θ, 黑盒奖励 R, prompt 集, 每组样本数 K
for 每个训练迭代:
    # Rollout (ODE 采样, 不需要 SDE 似然)
    for 每个 prompt c:
        用当前网络 v_θ(0) 采 K 个端点 x0^(i); 缓存沿途每个状态 s_t 的预测 v_θ(0)(s_t)
        R_i = R(x0^(i), c)                      # 标量, 或成对偏好标签 (Pairwise 变体)
        # 聚合优先: 每个 prompt 一个共享方向
        Cov = (1/K) Σ_i (R_i - R̄)(x0^(i) - x̄0)
        G(c) = Cov / RMS(Cov)
        对该 prompt rollout 经过的每个状态 s_t:  v_tgt = v_θ(0)(s_t) + G(c)
    # 把本批数据拆成两个不相交的 mini-batch B1, B2
    for B in (B1, B2):                          # 两次更新
        对 B 中每个状态:
            d = v_θ(s_t) - v_θ(0)(s_t)
            m = KL 代理 (式 7);  w = t * (1 - 1[m>=δ] * 1[<d, G-d> > 0])
            loss += w * MSE(v_θ(s_t), v_tgt)
        θ <- AdamW 更新
    # 第 2 次更新自带恢复力 -d; 无需 EMA 调度

4. 训练 / 推理流程

T2I：SD3.5-M（LoRA r=32, α=64, 512×512, lr $3\times10^{-4}$, 10 步 rollout），奖励 GenEval / OCR / PickScore（及联合 CLIPScore、HPSv2.1）；FLUX.1-dev (12B)：6 步 rollout、guidance 嵌入 3.5。T2V：全参数微调 CFG 蒸馏的 HunyuanVideo-13B，lr $10^{-5}$，每批 32 个 prompt × 8 个视频，53 帧、480×480、8 FPS、16 步采样；VideoReward（VQ 视觉质量 / MQ 运动质量 / TA 文本对齐）按 7:2:1 加权。另有 I2V 与 Pairwise 实验。

基线：Flow-GRPO、Flow-GRPO-Fast (CPS)、DanceGRPO、Flow-DPPO、DiffusionNFT（有 / 无 EMA）。

详细算法

1. 问题设定

输入：当前截图 $s_t$、结构化动作 $a_t$（类型、触控坐标、文本）、实际观察到的下一屏 $s_{t+1}$。训练数据：1,845,659 条真实 GUI 转移（Android in the Wild 55%、MiniWoB++ 25%、GUIOdyssey 9.8%、AndroidControl 6.9%、AMEX 3.3%），不需要任何语义标注。目标：(1) 判断 $(s_t,a_t,s_{t+1})$ 是否与学到的正常 GUI 动力学一致；(2) 判断不一致是否有害。

2. 关键公式

预测与目标（$f_\xi$ 为 $f_\theta$ 的 EMA 拷贝，sg 为 stop-gradient；$\hat z,\bar z\in\mathbb R^{512\times768}$）：

$$\hat{\mathbf z}_{t+1}=g_\phi\big(\mathbf z_t,\ e_\psi(a_t)\big),\qquad \bar{\mathbf z}_{t+1}=\mathrm{sg}\big[f_\xi(s_{t+1})\big]$$

动作编码：$[\text{type token};\ \text{MiniLM(text)};\ \text{2D-sinusoid}(x,y)]$（坐标用与视觉 patch 同一套位置基）。

change-weighted 预测损失（$m_p$ 为 patch 级变化掩码，$d$ 为 Smooth-L1，$\lambda_{\rm chg}=8$）：

$$\mathcal L_{\rm pred}=\frac{\sum_p w_p\,d(\hat{\mathbf z}_{t+1,p},\bar{\mathbf z}_{t+1,p})}{\sum_p w_p},\qquad w_p=1+(\lambda_{\rm chg}-1)m_p$$

总目标（$\lambda_{\rm cov}=0.01,\ \lambda_{\rm inv}=0.5$）：

$$\mathcal L=\mathcal L_{\rm pred}+\mathcal L_{\rm var}+\lambda_{\rm cov}\mathcal L_{\rm cov}+\lambda_{\rm inv}\mathcal L_{\rm inverse}$$

训练无关的转移一致性（surprise）：

$$q_{\rm int}(s_t,a_t,s_{t+1})=1-\cos\big(\hat{\mathbf z}_{t+1},\ \mathbf z^{\rm obs}_{t+1}\big),\qquad \mathbf z^{\rm obs}_{t+1}=f_\theta(s_{t+1})$$

方向读出（direction）：

$$\mathbf r_{t+1}=\big[\mathbf z^{\rm obs}_{t+1}-\hat{\mathbf z}_{t+1};\ e_\psi(a_t)\big],\qquad q_{\rm harm}=\sigma(\mathbf w^\top\mathbf r_{t+1}+b)$$

3. 逐步伪代码

# 预训练 (自监督, 无语义标注)
for step in 1..120000:                       # 全局 batch 512, AdamW, bf16, 4×A100-80GB
    取 (s_t, a_t, s_{t+1})
    z_t = f_θ(s_t);   a_tok = e_ψ(a_t)       # 动作 token: 类型 + MiniLM(文本) + 坐标(与 patch 同一位置基)
    z_hat = g_φ(z_t, a_tok)
    z_bar = stopgrad(f_ξ(s_{t+1}))           # EMA 编码器
    m = patch 级变化掩码 (由图像对计算, 无语义)
    L = L_pred(加权) + L_var + 0.01*L_cov + 0.5*L_inverse(从 (z_t, z_bar) 恢复 a_t)
    if step > 30000 且 属于 multi-step 批:  用 2~3 步 rollout (把预测输出喂回作上下文) 代替单步损失
    更新 θ, φ, ψ;  ξ <- EMA(θ)

# 运行时验证 (每一步 agent 动作之后)
s_t, a_t -> z_hat
观察到 s_{t+1} -> z_obs = f_θ(s_{t+1})
score_int  = 1 - cos(z_hat, z_obs)            # 越大越可疑 (无需标注, 17ms)
if score_int > 阈值:
    q_harm = σ(w^T [z_obs - z_hat ; e_ψ(a_t)] + b)    # 线性头, 只在独立 split 上训练
    q_harm 高 -> 有害 (如凭证劫持);  q_harm 低 -> 良性意外 (如通知/布局变化)

4. 训练 / 推理流程

参数量：训练图 261M（含 EMA 编码器与 inverse-dynamics 头）；运行时仅 $f_\theta$、$e_\psi$、$g_\phi$，共 172.86M。评测：RSWT-Bench（222 个 donor 对，共 966 条转移；三名标注员盲审 72 个分层样本与构造标签一致率 $96.3\pm0.8\%$），指标 RSWT / Swap / Cred 的成对 AUC，延迟在 batch=1、单张 A100-80GB 上测。有监督头只在不相交的 6,786 条样本上训练。对照：闭源 VLM（零样本同一 prompt）、开源 VLM、以及先渲染未来再由 Gemini 3.7 Flash 评判的 GUI 世界模型（gWorld、SAWM、Code2World、MobileWorld-HTML）。

详细算法

1. 问题设定

非可验证任务。数据 $\mathcal D=\{(x,\mathcal R(x))\}$，$\mathcal R(x)=\{(r_j,w_j)\}_{j=1}^M$ 为由 LLM 合成的评分细则及重要性权重；策略 $\pi_\theta$ 采样开放式响应 $y$。LLM grader 对每个 rubric 给二值覆盖标签 $s_j=\mathbb I[y\text{ satisfies }r_j]$。基线奖励是加权覆盖率（recall）。目标：设计既不依赖更多人工细则、又能抑制「堆砌」的奖励。

2. 关键公式

Rubric recall（式 1）：

$$\mathrm{Rec}(x,y)=\frac{\sum_{j=1}^{M}w_j\,s_j(x,y)}{\sum_{j=1}^{M}w_j}$$

必要性额度（式 2–3；$m_{ji}=\mathbb I[u_i\text{ 对 }r_j\text{ 有贡献}]$，$K_j=\sum_i m_{ji}$）：

$$a_{ji}=\begin{cases}m_{ji}/K_j,&K_j>0\\0,&K_j=0\end{cases},\qquad c_i=\sum_{j=1}^Ma_{ji},\qquad N_i=\mathbb I[c_i\ge\tau]$$

事实正确性（式 4）：$C_i=\mathbb I[u_i\text{ 事实正确}]$。精确率（式 5）：

$$\mathrm{Prec}(x,y)=\frac1n\sum_{i=1}^{n}N_iC_i$$

Fork 奖励（式 6，$\beta>1$ 偏重 recall，$\beta<1$ 偏重 precision）：

$$r_{\rm FORK}(x,y)=\frac{(1+\beta^2)\,\mathrm{Prec}\cdot\mathrm{Rec}}{\beta^2\,\mathrm{Prec}+\mathrm{Rec}}\quad(\mathrm{Prec}+\mathrm{Rec}>0;\ \text{否则 }0)$$

目标（式 7）：

$$\max_\theta\ \mathbb E_{x\sim\mathcal D,\ y\sim\pi_\theta(\cdot|x)}\big[r_{\rm FORK}(x,y)\big]$$

3. 逐步伪代码

# 每个训练步 (GRPO, 16 rollouts/prompt)
for 每个 prompt x (含 rubric 集 R(x) = {(r_j, w_j)}):
    采样 16 条响应 y_1..y_16 ~ π_θ(·|x)
    for 每条响应 y:
        units = LLM_unitize(y)                          # 约一句一个 unit; 丢弃问候/标题/过渡
        s_j   = LLM_cover(y, r_j)       for j in 1..M   # 覆盖标签
        Rec   = Σ w_j s_j / Σ w_j
        m_ji  = LLM_match(r_j, u_i)                     # 每个 (rubric, unit) 是否贡献
        K_j   = Σ_i m_ji;   a_ji = m_ji/K_j (K_j>0 else 0)
        c_i   = Σ_j a_ji
        τ     = LLM_threshold(c_1..c_n)                 # grader 给出必要性阈值
        N_i   = 1[c_i >= τ];   C_i = LLM_factcheck(u_i, x)
        Prec  = (1/n) Σ N_i * C_i
        r     = F_β(Prec, Rec)                          # 奖励
    A_k = (r_k - mean(r)) / std(r)                      # GRPO 组内优势
    用 GRPO 目标更新 θ

# 超参: batch 128, lr 4.2e-6 (常数 + 5% warmup), 3 epochs, 8×H100, 上下文 2,000 tokens, T=1.0
# 训练 grader: Qwen3.6-35B-A3B;  评测参考 grader: GPT-5.4

4. 训练 / 推理流程

基座：Qwen2.5-7B-Instruct。数据：RubricHub 的 Medical 子集（训练 12,519 / 测试 1,391）与 Science 子集（19,806 / 2,201，去除 ResearchQA 来源以便作外部评测）。外部评测：HealthBench（医疗）、ResearchQA（科学）。评测方式：(1) rubric-based：macro recall / precision / $F_1$；(2) rubric-free：对基座的 win rate 与平均长度。基线：Standard、OnlineRubrics、Universal Rubrics、Reweighted Absence-Based Rubrics（覆盖类）；Holistic Preference（偏好类）；以及作者自己的精确率变体 Generic / Offline / Online Criteria。

详细算法

1. 问题设定

这不是新模型，而是一个诊断协议。给定记忆系统 $S$ 与参照 RAG，对每个查询 $q$ 得到两个二值结果 $c_S(q),c_{\rm RAG}(q)\in\{0,1\}$（judge 判定是否答对）。

2. 关键公式

【编者形式化】 论文以文字与 Venn 图定义收益 / 税，下式为本站依据其定义写出的记号（非论文原式）：

$$\mathcal B=\{q:\ c_S(q)=1,\ c_{\rm RAG}(q)=0\},\qquad \mathcal T=\{q:\ c_S(q)=0,\ c_{\rm RAG}(q)=1\}$$

$$\text{Net}(S)=\mathrm{Acc}(S)-\mathrm{Acc}(\mathrm{RAG})=\frac{|\mathcal B|-|\mathcal T|}{N}$$

当 $|\mathcal T|>|\mathcal B|$ 即税超过收益。

检索预算对齐（Retrieval Scope），论文文字定义：

$$\mathrm{RS}(S)=\frac{\#\text{tokens of memory units exposed to the LLM (retrieval→answer)}}{\#\text{tokens in the system's retrievable store}}$$

Gold 对照的诊断逻辑：用 gold memory units 去掉检索失败后，剩余差距反映「构造期损失」；gold raw turns 与 gold memory units 之间的差距反映「信息被加工后丢失」。

3. 逐步伪代码

# 诊断流程 (据论文 §3–§6 整理)
for 每个记忆系统 S, 每个骨干 B, 每个基准:
    1. 用 B 构造记忆 M = I(H); 以 RS 对齐检索预算 (调 top-k)
    2. 逐题回答: c_S(q) 与 c_RAG1(q), c_RAG2(q)  (1 轮 / 2 轮 RAG)
    3. 计算 收益集合 B 与 税集合 T (相对 RAG 1 轮), 画 Venn 图 (Fig.2)
    # 追根溯源
    4. 忠实度: 仅用 gold raw turns 作答 vs 仅用 gold memory units 作答;
               抽样原子事实 -> 追踪到记忆单元 -> 标注 NL / PL / ML / NU (无损/部分/重大损失/无单元)
    5. 可访问性: 多轮检索回放, 记录召回全部 gold 单元所需轮数; 比较 sim(q, gold raw turn) vs sim(q, gold memory unit)
    6. 稳健性: 构造骨干 × 作答骨干 交叉, 看掉点是否大于 RAG
# 减税的概念验证 (§6)
    A. 可恢复: 同时检索源历史与记忆, 联合重排后作答
    B. 记住如何记: 把过去的查询与检索到的证据也写入记忆库

4. 训练 / 推理流程

主结果（Table 1，judge accuracy %）：RAG（2 轮）在 LongMemEval-s 的三个骨干上为 72.2 / 81.4 / 90.0；多数记忆系统低于它，如 OpenViking 31.8 / 58.8 / 63.0；仅有少数单元格为正（如 PlugMem 在 MINT-Eval 的 Qwen3.6-27B +0.1、GPT-5.6 Luna +3.3，Mem-T 在 MINT-Eval 的 Luna +3.9）。

信息损失标注（Table 2，抽样原子事实）：OpenViking 无损仅 39.4%、无对应记忆单元 38.0%；MemoryOS 无损 98.4%；MAGMA 93.6%。

推广：experiential memory（ALFWorld、WebShop、Mind2Web、BigCodeBench、AppWorld、$\tau^2$-Bench，Qwen3.5-4B）与 world-model memory（Context-as-Memory、MemoBench）。

详细算法

1. 问题设定

RL 后训练的两条执行路径：rollout（推理引擎，用 FP4 加速；这里用 SGLang）与训练（Megatron，BF16 前向/反向，QAT 时前向做 FP4 fake quantization）。对同一轨迹、token 位置与量化位点（site），记训练侧激活 $X_{\rm train}$ 与 rollout 侧激活 $X_{\rm rollout}$。目标：降低两条路径量化后的差异，同时不引入难以承受的存储 / 通信开销。

2. 关键公式

局部量化差异（式 1）：

$$\mathcal D_{\rm act}=\big\|Q^{\rm train}_{\rm FP4}(X_{\rm train})-Q^{\rm rollout}_{\rm FP4}(X_{\rm rollout})\big\|_F$$

既有方法的目标（只降低各自量化误差）：$\mathcal L_{\rm error}(X)=\|X-Q(X)\|_F$。

Rollout 引导舍入（式 2；$q_\pm$ 为 rollout 侧 scale 下训练激活相邻的两个归一化 E2M1 码字，$q_{\rm rollout}$ 为对应 rollout 激活实际得到的码字）：

$$q_{\rm TRACE}=\arg\min_{q\in\{q_-,q_+\}}\big|q-q_{\rm rollout}\big|$$

局部不劣于 RTN（式 3）：

$$|q_{\rm TRACE}-q_{\rm rollout}|\ \le\ |q_{\rm RTN}-q_{\rm rollout}|$$

相对额外差异（诊断量）：

$$\frac{D_{\rm FP4}-D_{\rm BF16}}{D_{\rm BF16}}$$

（$D$ 为训练—rollout 激活 MSE。）压缩通信下的参考重建：选择低 $b$ 位码与记录 $c$ 一致、且幅值最接近 $|z|$ 的 E2M1 幅值，符号取训练激活的符号；仅作局部引导目标，而非精确还原。

3. 逐步伪代码

# 据 §3 与 A.1 的文字描述整理 (论文 Algorithm 1 的框内行文本在抽取中缺失)
Rollout 阶段 (SGLang, FP4 路由专家 + FP4 KV):
    for 每个生成的 token, 每个量化位点 (MoE 专家输入 / 后半层 KV):
        记录 rollout 侧的 (尾数低 b 位 [b=1], scale)         # 后半层才记录
        激活侧: 先写入临时 GPU buffer -> 异步卸载到 CPU; KV 侧: 请求结束后从 FP4 KV cache 收集
    序列化并按 (trajectory, token, site) 索引保存

QAT 训练阶段 (Megatron, BF16 反向):
    for 每个微批:
        载入对应记录并按 (trajectory, token, site) 配对
        for 每个被记录位点的训练激活 z:
            (q-, q+) = BracketFP4(z)                           # 相邻 E2M1 舍入候选
            ref = Reconstruct(记录 c, scale s, z)              # 低 b 位码匹配的最近 E2M1 幅值, 符号取自 z
            q = 距 ref 更近的候选                              # 代替 RTN
            z_q = STE(z, q * s)                                # 前向用 q, 梯度穿透到 z
        GRPO + R3 路由回放 + token 级重要性比 (clip 上界 5, max_version_diff=3)

4. 训练 / 推理流程

模型：Qwen3.5-35B-A3B（推理 RL，400 步）、Qwen3.5-122B-A10B（代码 RL，50 步，DeepSWE v1.1）、Qwen3.8-Flash-Next（125B 总 / 6B 激活，代码 RL，400 步，Terminal-Bench 2.1）、Qwen3.8-2.4T-A95B（长程 RL，50 步，GDPval）。基线：vanilla NVFP4、QAT、QaRL、QUADS、Score Centering；MXFP4 变体；以及 BF16 训练后再做 post-hoc FP4（4over6、H-Scale）。设置：VeRL 异步 RL + Megatron + SGLang，disaggregated 部署；GRPO + R3 + token 级重要性比（上界 5）。每步采样 $256{\times}16$ / $128{\times}16$ / $64{\times}16$ / $64{\times}8$ 条轨迹。

详细算法

1. 问题设定

时刻 $t$ 的输入：多视角图像与任务指令（前缀具身、臂型、末端类型、控制频率），当前本体状态 $q_t$。输出：长度 $K=8$ 的动作块 $\mathbf A_t=[\mathbf a_{t,0},\ldots,\mathbf a_{t,K-1}]$，整块执行完再重规划。可选：自生成子任务描述（"Current step: …"）或 ECoT 响应（场景、进度、下一步运动）作为额外上下文。

2. 关键公式

末端位姿动作（相对块起始位姿）（式 2）：

$$\mathbf a^{\rm eef}_{t,k}=\big[\mathbf p^*_{t+k}-\mathbf p_t,\ \mathrm{Log}(R^*_{t+k}R_t^{\mathsf T})\big]\in\mathbb R^6$$

动作专家的条件（式 3）：$X_t=[H_t^{\rm last};\,C_t]$。

直接未来预测损失（式 4–5；$m\in\{r,d,f\}$ 为 RGB / 深度 / 光流）：

$$\tilde y^m=\frac{y^m-\mu^m}{s^m},\qquad \mathcal L_{\rm direct}=\frac13\sum_{m}\mathrm{MSE}\big(g^m_\eta(C_t),\tilde y^m\big)$$

世界模型辅助损失（式 6–7；未来潜与噪声线性混合，$\sigma\sim U(0,1)$）：

$$z^r_{\sigma,\rm future}=(1-\sigma)z^r_{\rm future}+\sigma\epsilon,\qquad \mathcal L_{\rm WM}=\sum_m\mathrm{MSE}\big(\hat v^m_{\rm future},\ \epsilon-z^m_{\rm future}\big)$$

物理预训练目标（式 8；$\lambda(k)=0.5\min(k/2000,1)$）：

$$\mathcal L_{\rm pre}=\mathcal L_{\rm WM}+\lambda(k)\,\mathcal L_{\rm direct}$$

条件流匹配的动作损失（式 9–10）：

$$x_\tau=(1-\tau)\xi+\tau\mathbf A_t,\quad v^*=\mathbf A_t-\xi,\qquad \mathcal L_{\rm act}=\frac{\sum_i\|M_i\odot(\hat v_i-v_i^*)\|_F^2}{\sum_i\|M_i\|_1+\delta}$$

联合策略损失（式 11）：

$$\mathcal L_{\rm policy}=\mathcal L_{\rm act}+0.1\,\mathcal L_{\rm VL}+0.1\,\mathcal L_{\rm direct}$$

3. 逐步伪代码

# 阶段 1: 物理动力学预训练 (VLM 与 LingBot 冻结)
for 每个样本 (当前观测, 指令, 5 帧视频 [当前 + 之后 30 个动作步], 深度/光流伪标签):
    H8 = VLM.layer8(观测, 指令)                       # 冻结
    C  = PhysicalModule(H8)                           # 50 个 query -> 50 个 physical tokens
    编码 RGB / 深度 / 光流 视频为 Wan-VAE 潜特征 z^m
    # 直接预测
    L_direct = mean_m MSE( g^m(C), 标准化(池化(z^m_future)) )
    # 世界模型辅助
    采样 σ~U(0,1), ε~N(0,I);  z_future^r' = (1-σ) z_future^r + σ ε
    v̂^m = LingBot(干净 z_current^r, 带噪 z_future^r', 条件 C, σ)   # RGB 头冻结, 深度/光流头可训练
    L_WM = Σ_m MSE(v̂^m, ε - z^m_future)
    loss = L_WM + λ(k) L_direct;   更新 PhysicalModule, 深度/光流头, 直接预测头

# 阶段 2: 联合策略训练 (去掉视频模型)
for 每个 VLA / VL 样本:
    H_last, H8 = VLM(...);   C = PhysicalModule(stopgrad(H8))
    A: 动作专家 v_ψ(x_τ, τ, [H_last; C], q_t)  ->  L_act (带掩码)
    L_VL: 仅对响应 token 的交叉熵 (只更新 VLM)
    L_direct (继续)
    loss = L_act + 0.1 L_VL + 0.1 L_direct

# 推理
可选: VLM 先生成子任务描述 (或 ECoT) 附加到指令
H_last, C = VLM + PhysicalModule             # 不运行视频模型
x ~ N(0, I);  4 步 Euler 积分速度场 v_ψ  ->  动作块 A (K=8)

4. 训练 / 推理流程

适配与评测：LIBERO（四个 suite 各 10 个任务，微调 40,000 步，批大小 128，共 2,000 个评测 episode）、LIBERO-Plus（扰动鲁棒性）、RoboTwin 2.0（Aloha-AgileX，clean50 + randomized500，每任务每设置 100 个 episode）、SimplerEnv（WidowX/Bridge 视觉匹配，微调 50,000 步）。基线数字取自各论文与官方仓库（含 InternVLA-A1.5、Qwen-RobotManip 的汇总），协议并不完全一致。训练硬件与具体超参见论文附录 A。

详细算法

1. 问题设定

序列建模层：输入 $\mathbf x_t\in\mathbb R^d$，每头记忆 $\mathbf S_t\in\mathbb R^{d_v\times d_k}$，读出 $\tilde{\mathbf h}_t=\mathbf S_t\mathbf q_t$。目标：在保持线性复杂度与恒定记忆的同时，降低更新对旧关联的干扰，使长上下文（超出训练长度或经上下文扩展后）检索更稳健。

2. 关键公式

Hebbian 线性注意力（式 1）：$\mathbf S_{t+1}=\mathbf S_t+\mathbf v_t\mathbf k_t^\top,\ \ \mathbf h_t=\mathbf S_t\mathbf q_t$

Delta Rule（式 2）：

$$\mathbf S_{t+1}=\mathbf S_t-\beta_t(\mathbf S_t\mathbf k_t-\mathbf v_t)\mathbf k_t^\top=\mathbf S_t(\mathbf I-\beta_t\mathbf k_t\mathbf k_t^\top)+\beta_t\mathbf v_t\mathbf k_t^\top$$

Kronecker Delta Rule（式 3）：

$$\mathbf S_{t+1}=\mathbf S_t-\underbrace{\beta_t(\mathbf v_t^\top\mathbf S_t\mathbf k_t)\,\mathbf v_t\mathbf k_t^\top}_{\text{erase}}+\underbrace{\beta_tc_t\,\mathbf v_t\mathbf k_t^\top}_{\text{write}}$$

向量化形式（式 4，$\mathbf a_t=\mathbf k_t\otimes\mathbf v_t$）：

$$\mathbf s_{t+1}=(\mathbf I-\beta_t\mathbf a_t\mathbf a_t^\top)\mathbf s_t+\beta_tc_t\mathbf a_t$$

重复同一对的误差收缩：$\mathbf v_t^\top\mathbf S_{t+1}\mathbf k_t-c_t=(\mathbf v_t^\top\mathbf S_t\mathbf k_t-c_t)(1-\beta_t\|\mathbf a_t\|^2)$，故 $0<\beta_t<2/\|\mathbf a_t\|^2$ 时收缩，$\beta_t=1/\|\mathbf a_t\|^2$ 一步达标。

干扰（式 5）：

$$\Delta(\mathbf v_i^\top\mathbf S\mathbf k_i)=-\beta_t(\mathbf v_t^\top\mathbf S_t\mathbf k_t-c_t)(\mathbf v_i^\top\mathbf v_t)(\mathbf k_t^\top\mathbf k_i)$$

KronLSTM 完整更新（式 10，$\mathbf F_t=\mathrm{diag}(\mathbf f_t)$，使用目标 $\tilde c_t=c_t/\beta_t$ 解耦擦除与写入）：

$$\mathbf S_{t+1}=\underbrace{\mathbf S_t\mathbf F_t}_{\text{forget}}-\underbrace{\beta_t(\mathbf v_t^\top\mathbf S_t\mathbf F_t\mathbf k_t)\,\mathbf v_t\mathbf k_t^\top}_{\text{erase}}+\underbrace{c_t\,\mathbf v_t\mathbf k_t^\top}_{\text{write}}$$

门（式 11–12）：$\beta_t=\sigma(\mathbf w_\beta^\top\mathbf x_t+b_\beta)$，$c_t=\sigma(\mathbf w_c^\top\mathbf x_t+b_c)$，$\mathbf f_t=(1-\sigma(\mathbf W_f\mathbf x_t+\mathbf b_f))^{a}$。

范数界（式 8，$\kappa\le1$ 时）：$\mathbb E_{\pi_\beta}\|\mathbf S\|_F^2\le \mathbb E[c^2]/\lambda_{\min}(\bar{\mathbf A})$。

3. 逐步伪代码

# 单头, 逐 token 递推形式 (训练时用 DeltaNet 式 chunkwise 并行, 以 a_t = k_t ⊗ v_t 代替 k_t)
输入 x_t
q, k, v = 线性投影 -> 短因果深度卷积 -> SiLU -> L2 归一化
β_t = sigmoid(w_β·x_t + b_β)                      # 擦除强度 (状态跟踪时用 2*sigmoid, 取值 (0,2))
c_t = sigmoid(w_c·x_t + b_c)                      # 写入强度
f_t = (1 - sigmoid(W_f x_t + b_f)) ** exp(a_log)  # 对 key 维的遗忘, 逐头可学习时间尺度
o_t = sigmoid(W_o x_t + b_o)                      # 输出门

S' = S_t · diag(f_t)                              # 遗忘 (右乘: 按 key 方向衰减)
s  = v^T S' k                                     # 标量: 当前对 (k,v) 的关联强度
S_{t+1} = S' - β_t · s · (v k^T) + c_t · (v k^T)  # 擦除 + 写入, 方向只由 (k,v) 决定
h_t = S_{t+1} q_t                                 # 读出 (线性注意力读出 S q)
y_t = 归一化(h_t) * o_t -> 输出投影

4. 训练 / 推理流程

预训练：FineWeb-Edu（Llama2 tokenizer），训练上下文 8k；主实验 1.5B 参数 / 100B tokens（附录另有 400M）。对比 Gated DeltaNet（GDN）、Kimi Delta Attention（KDA）、Mamba-3、Gated DeltaNet-2（GDN-2）、mLSTM；两种设置：纯线性模型与混合（线性 : 滑动窗口注意力 SWA = 5 : 1，窗口 2048）。长上下文扩展：在 75B tokens 处分支，用 ProLong-64K 衍生的长文档混合再训练 25B tokens（32k），与 100B 模型 token 数对齐，与 GDN-2 对比。状态跟踪：训练长度至 128，评测至 1024（parity、$S_3$ 置换、模算术）。训练效率：单张 H100-80GB，每步 16,384 tokens。

详细算法

1. 问题设定

【说明】这是一篇系统 / 流程类博客，没有数学形式化的新算法；以下按其公开描述整理成「分层筛查 + 升级」的流程，数值（5%、15 分钟、30 分钟等）均为博客所述。 目标：在训练、评测、内部使用与外部部署中，尽早发现智能体越权行为与失对齐，在代价（算力）与召回之间取得平衡。

2. 关键公式

本文没有数学公式。博客给出的量化参数如下（均为 OpenAI 所述）：

• L0 对未标记流量的随机复查比例：$5\%$；
• L1 检查间隔目标：$\le 30$ 分钟；
• 最高优先级告警触达人工：通常 $\le 15$ 分钟；
• 拟议安全阀：寻呼后 $30$ 分钟内未排除最高优先级告警则自动暂停相关活动。

设计取向是「前面几层宁可多放行（高召回），后面几层把算力花在单个案例上」；博客没有公布各层召回 / 精确率的数值表（图表见原文，本站未读取图中数值）。

3. 逐步伪代码

# 据博客描述整理的流程（概念性，非 OpenAI 代码）
for 每个受监控的工作负载 (RL run / 评测 / 内部 Codex / 外部部署的受控版本):
    if 工作负载是前沿 RL 或内部 Codex:  跳过 L0
    else:
        L0: activation probe(内部激活) -> 高召回, 允许误报
            未标记流量中随机 5% 也送 L1  (用来发现探针漏掉的)
    L1: 模型审查员 (同一上下文窗口; 看对话 + 思维链 + 工具调用)
        在每个 turn 结束 / 每次摘要时运行 (目标: 间隔 <= 30 分钟)
        找: 欺骗 / 越权 / 操纵评测
    if L1 标记:
        L2: 调查智能体 (可读全部上下文窗口, 写并运行隔离代码取证)
            安全调查员: 是否需要人立刻介入 (逃逸沙箱, 未授权访问)
            对齐调查员: 是否值得研究 (无即时安全风险)
        if 敏感工作负载:
            L3: 对照网络日志 / 系统遥测 / 历史案例  -> 决定是否呼叫人
        if 最高优先级(P0):
            呼叫安全与训练团队 (通常 <=15 分钟; 部分负载可自动暂停)
# 训练侧原则: 被标记的 RL 样本不改奖励, 仍保留在训练中; 监控异步, 不阻塞训练

4. 训练 / 推理流程

评估闭环：(1) 回放已记录事件（来自训练、评测、内部使用）并检查是否识别、是否给出足够高的优先级；(2) 在隔离环境运行模拟攻击——OAI-repo Sabotage v2（智能体在正常编码任务中追求隐藏目标，如关闭监控或部署未批准检查点）与 Sneaky Sandbox Escape（试图逃出沙箱并关闭外部测试监控进程）；监控员看得到推理但看不到下达隐藏目标的指令；(3) 对放行流量的随机审计；(4) 红队：让最强智能体尝试规避或关闭监控；(5) 在中央仪表板上跟踪各阈值的召回，部署前先测改动对召回的影响。