长琴

COPO：基于认知模式的 Step-Level Agentic RL 优化

2026-04-23T15:00:00.000Z

今天介绍一篇 Agentic RL 的小文章吧，来自 2602 Think Fast and Slow: Step-Level Cognitive Depth Adaptation for LLM Agents^[1]，我们在《LLM 的下一步：从“会答”到“会想”——Planning as Data 与思考范式重构 | 长琴^[2]》中提过一嘴，不过当时关注的是它的认知结构（本文不再赘述）。这里重点看下它提出来的 COPO（认知感知策略优化）——用于通过置信度感知优势重加权来实现步骤级的权重分配。

出发点很简单，GRPO 对轨迹中的所有步骤统一分配优势，并不会区分每一步所采用的认知模式在当前上下文中是否合适。COPO 基于动作预测的置信度，实现了逐步（step-level）的信用分配。这里有个关键洞察：合适的认知模式应当能够促进模型做出高置信度且正确的动作选择。

看图 C，Cognitive Group 会对每一步的 advantage 重新赋权。下面看看具体细节。

认知组构建

这一步是针对成功的轨迹，在每一步构建 cognitive group（认知组），具体做法很简单：在保持 observation 和 action 固定的前提下，基于 4 个认知等级重新生成思考过程。对轨迹 $i$ ，有 group $e_t^{(i,k)} = [l_k, th_t^{i,k}, a_t^i ]$ ， $l_k$ 就是第 k 个 level（共 4 个）。

为了评估每种认知层级的适用性，考察模型在以不同思维过程为条件时，对动作预测的置信程度：

$C_t^{(i, k)}=\frac{1}{\left|a_t^{(i)}\right|} \sum_{n=1}^{\left|a_t^{(i)}\right|} \log \pi_\theta\left(a_{t, n}^{(i)} \mid \tau_t^{(i)}, l_k, t h_t^{(i, k)}, a_{t,\lt n}^{(i)}\right)$

$a_{t,n}^i$ 是 action $a_t^i$ 的第 n 个 token， $\tau$ 是轨迹，更高的置信度分数表明该思维过程与最终动作之间具有更强的一致性。

基于置信度的优势重加权

为了在每个组内比较不同的认知层级，对置信度分数进行归一化处理：

$C_{\text {norm }, t}^{(i, k)}=\frac{C_t^{(i, k)}-\mu_t^{(i)}}{\sigma_t^{(i)}},$

这个归一化是在 cognitive group e 层面做的。然后 softmax 到权重：

$g\left(C_t^{(i, k)}\right)=\frac{\exp \left(m \cdot C_{\text {norm }, t}^{(i, k)}\right)}{\sum_{j=1}^4 \exp \left(m \cdot C_{\text {norm }, t}^{(i, j)}\right)},$

m 是温度。这些权重在不改变总优势值大小的前提下（g 的和为 1），将其在不同认知层级之间重新分配。

$A_t^{(i, k)}= \begin{cases}g\left(C_t^{(i, k)}\right) \cdot A^{(i)}, & \text { if } R_i>0 \\ A^{(i)}, & \text { otherwise }\end{cases}$

A 就是 GRPO 的标准形式。

注意，这里只针对成功的轨迹重加权，放大有助于产生高置信度动作预测的认知层级的优势，同时削弱不确定性较高的部分。对于失败的轨迹，则不会构建认知组，其优势仍然保持在轨迹层级。

COPO

综上所述，得到最终的优化目标：

$\begin{aligned}\mathcal{J}_{\mathrm{CoPO}}(\theta)= & \mathbb{E}_{x \sim \mathcal{X},\left\{\tau^{(i)}\right\}_{i=1}^G \sim \pi_{\theta_{\mathrm{old}}}(\cdot \mid x)}\left[\frac { 1 } { G } \left(\sum_{i \in \mathcal{I}^{+}} \frac{1}{\left|e^{(i)}\right|} \sum_{t=0}^T \sum_{k=1}^4 \sum_{n=1}^{\left|e_t^{(i, k)}\right|} \min \left(r_{t, n}^{(i, k)} \hat{A}_t^{(i, k)}, \bar{r}_{t, n}^{(i, k)} \hat{A}_t^{(i, k)}\right)\right.\right. \\& \left.\left.+\sum_{i \in \mathcal{I}^{-}} \frac{1}{\left|y^{(i)}\right|} \sum_{t=0}^T \sum_{n=1}^{\left|y_t^{(i)}\right|} \min \left(r_{t, n}^{(i)} \hat{A}^{(i)}, \bar{r}_{t, n}^{(i)} \hat{A}^{(i)}\right)\right)\right]-\beta \mathbb{D}_{\mathrm{KL}}\left[\pi_\theta \| \pi_{\mathrm{ref}}\right],\end{aligned}$

其中， $i \in \mathcal{I}^{+}$ 就是成功的轨迹，失败的轨迹做法就是标准 GRPO， $r = clip(r, 1−ε, 1+ε)$ 。

效果表格就不贴了，看个收敛速度的小图（也包含成功率 SR）：

可以看到，提升还是非常明显的。

然后训练后不同 Level 的分布是这样的：

SFT 还是分布比较均衡的，RL 后和其他算法表现出明显的不同，GRPO 和 GiGPO 都倾向于 L4（更深层的思考通常与更高的最终奖励相关），COPO 则实现逐步的自适应思考——只在有益时才采用更深层的思考。

如上图左所示，L4 在初始化阶段达到峰值，此时复杂任务需要全局目标评估和长时规划，随后占比开始下降；L2 同样在初始阶段占主导，因为此时对环境的感知对于解析观测信息和评估可选动作至关重要，随后稳定；L1 一路上升，说明后期大多数步骤已经转化为无需深度思考的常规执行；L3 在各阶段相对均匀，只有在出现错误或需要借助过往经验进行决策时才会在特定上下文中出现。

COPO 的这种结构化的分配在认知上是合理的：初始化阶段以战略规划为主，探索阶段依赖环境感知，随着流程逐渐明确，常规执行占比提升，而反思则在必要时出现。相比之下，GRPO 从始至终都被 L4 思维所主导（全程超过 50%），无论步骤复杂度如何都趋向于统一的深度推理。

上图右边则是算法对短（S）、中（M）和长（L）三类任务（轨迹越长越复杂）的感知情况，COPO 展现出明显的复杂度感知适应能力：能够随着任务复杂度的提升按比例增加认知投入。而 GRPO 在所有难度级别上都保持近乎均匀的分布。

小结

我们看到 COPO 的思想其实非常的直观，而且你看，其实它还是变着花样搞数据，而且目测，这种 ”花样“ 还会有更多。原因也很简单，对于后训练来说，数据一定是排在第一位的，具体来说——什么样的数据以什么样的方式给模型——就是后训练的核心了。

Reference

[1] 2602 Think Fast and Slow: Step-Level Cognitive Depth Adaptation for LLM Agents: https://arxiv.org/abs/2602.12662
[2] LLM 的下一步：从“会答”到“会想”——Planning as Data 与思考范式重构 | 长琴: https://yam.gift/2026/04/17/NLP/LLM-Training/2026-04-17-Think-Strategy/

LLM 的下一步：从“会答”到“会想”——Planning as Data 与思考范式重构

2026-04-17T15:00:00.000Z

TL;DR

本文系统梳理了让LLM"先规划再回答"的各类方法，从数据构造（结构化中间表示、层次抽象）、机制设计（注意力对齐、思维 token 注入）到认知启发（ACT-R分层、元思维进化）逐层深入，最后追问"规划的本质"，指出显式token规划存在局限，潜在空间（latent）规划或许更接近真正的思考——非线性、可中断、全局感知。

当 reasoning 成为一种数据格式后，下一个很自然的想法就是 “如何 reasoning”，由此引出的做法可谓是五花八门。本文就尝试从这一角度进行梳理，探讨「如何思考（规划）」，或者等价于「如何构造思考数据」。毕竟，重点一直都是「搞数据」和「搞高质量数据」。

注意，思考和规划大多数时候是一个意思，但规划多了一点显式约束的意思，思考过程也隐含了规划信号。

先规划再响应

最容易想到的的 naive 方案，论文 2505 Learning to Plan Before Answering: Self-Teaching LLMs to Learn Abstract Plans for Problem Solving^[1]（LEPA）就是训练 LLM 在处理问题细节之前，先制定预期计划，这些计划作为解决问题的抽象元知识。

具体而言，在数据生成过程中，LEPA 会提示 LLM 先制定一个包含高级问题解决步骤的预期规划，然后生成一个与问题和规划都相符的解决方案。如果解决方案正确，则将 “规划 - 解决方案对” 存储到训练数据集中。否则，会要求 LLM 反思规划和错误的解决方案，并改进规划，直到它成功促使 LLM 生成正确的解决方案。

Agentic 也是类似做法，只不过反馈的是执行或 action，Self-Steering Language Models^[2] 提出 DisCIPL（Distributional Constraints by Inference Programming with Language Models）的“自引导”语言模型方法，其中规划器模型生成特定于任务的推理程序，并由一组跟随者模型执行。

一个规划器语言模型（Planner LM）编写推理程序，以定义逐步计算过程，从而引导一组跟随者语言模型（Follower LMs）。该方法结合了串行与并行方法的优势：规划器通过构造保证正确性，而跟随者则通过协同搜索高概率序列。

如何做好规划

数据角度

最直观的做法是结构化过程。2603 Learning to Generate Formally Verifiable Step-by-Step Logic Reasoning via Structured Formal Intermediaries^[3] 针对的是中等规模模型直接生成极难形式化证明的成功率低下的问题。具体做法就是让模型首先输出与自然语言对应的结构化形式化中间表示，用于刻画逻辑依赖关系、推导出的结论，以及对形式推理规则（如假言三段论）的应用。随后利用形式化工具对这些中间步骤进行严格检验，构建出一条只有推理链条完全正确的解答才能获得奖励的强化闭环。

2602 Learning Abstractions for Hierarchical Planning in Program-Synthesis Agents^[4] 的做法要更进一步，它利用 LLM 的上下文学习能力，通过从经验中合成抽象概念并将其整合到分层规划过程中，主动学习可重用的抽象概念，而不是依赖于人工指定的抽象概念。虽然是个代码 agent，但这种从经验中先学习抽象概念，然后再进行分层规划的做法是通用的。

还可以从具体数据反推，比如 2503 Reasoning to Learn from Latent Thoughts^[5]，它将网络文本视为冗长人类思维过程的最终压缩结果，认为可以通过推断和解压缩的思想来增强观察到的数据，实现更高效的学习——推理学习。这是显式地建模和推断文本生成过程中潜在的思维模式，其出发点来自人类学习——人类能够从相同的压缩文本中高效学习，比如，当我们阅读一篇研究论文时，我们会分析具体的主张，将其与先验知识相结合，并尝试“解压缩”作者的原始思维过程。

注意， Latent thought 依然以自回归的方式对每一段文本进行建模。

机制角度

首先看 2510 Self-Anchor: Large Language Model Reasoning via Step-by-step Attention Alignment^[6]，它的做法是显式地对齐大语言模型的注意力。这基于两个关键洞察：（1）复杂的推理问题可以分解为结构化的计划；（2）每个分解后的计划可自然地作为注意力对齐的组成部分。

具体而言，Self-Anchor 将原始提示词分解为具有相应推理步骤的计划步骤。在生成过程中，它会自动选择并引导模型注意力聚焦于提示和相应的计划。这使得 LLM 能够持续关注问题声明和当前的推理目标，从而防止在不断扩展的推理步骤中出现注意力偏差。从形式上看，这个就是简单的规划，不过是从显式注意力角度出发的。

2510 Attention-Aligned Reasoning for Large Language Models^[7] 也是类似思路，通过交替进行规划步骤和执行步骤，显式地引导注意力，在全局目标（原始问题）与局部目标（当前规划步骤）之间取得平衡。

比较有意思的是 2503 Effectively Controlling Reasoning Models through Thinking Intervention^[8]，它的做法有点像 CoT 的魔法语句：“Let’s think step by step”——策略性地插入或修改特定的思维 token 来显式地引导 LLM 的内部推理过程。

论文分析表明，推理过程的注意力主要集中在模型内部，而不是外部输入 token。因此，标准的提示工程效果有限，因为模型几乎不会将注意力指向这些提示。相比之下，在采用 Thinking Intervention 的注意力图中，可以观察到在推理过程中，模型对显式注入的干预 token 的内部注意力显著增强。

下面是一个展示如何将 Thinking Intervention 与 Vanilla Prompting 和 Reminder Prompting 等提示技术相结合的示例，可用于指令遵循任务。

还有一些相关的消融：

干预位置：相较于早期阶段的干预，在推理后期施加的干预效果明显减弱。
干预序列的复杂度：更长的干预序列显著提升了安全对齐效果，但由于指导过于严格，整体遵循率有所下降。
叙事视角：不同人称在性能上差异极小。

其实说到 steering，突然想到之前写过一篇《激活诱导LLM指令跟随 | 长琴^[9]》——Activation 诱导的实验，感兴趣的读者可以查阅。近期的 2604 From Weights to Activations: Is Steering the Next Frontier of Adaptation?^[10] 进一步将其定位为一种独特的自适应范式。

认知角度

前面的规划多少还是有点具体，缺乏一个抽象的设计。这里我们来看几个从认知角度设计（更高级）思考的做法。

首先是 2602 Think Fast and Slow: Step-Level Cognitive Depth Adaptation for LLM Agents^[11]，它基于 ACT-R 理论，设计了四个层级的认知结构，涵盖从本能反应到策略性规划的各个层面。具体包括：L1（本能反应）、L2（情境意识）、L3（经验整合）和L4（战略规划）。然后再训练智能体在每个步骤中动态调整认知深度，其核心思想是，合适的认知深度应最大化最终行动的置信度。

为此，还提出了两阶段训练方法，重新定义了 SFT 和 RL。

认知感知监督微调（CoSFT），用于构建稳定的特定层级认知模式。
认知感知策略优化（CoPO），用于通过置信度感知优势重加权来实现步骤级的权重分配。

2503 MetaScale: Test-Time Scaling with Evolving Meta-Thoughts^[12] 的是模型如何主动选择最合适的认知策略来解决特定任务，而不是所有任务一个策略。提出meta-thinking：LLM 在生成回答之前，会首先反思其解决问题的方法，选择最合适的认知策略。

具体来说，先初始化一组候选元思维，然后采用多臂老虎机算法结合上置信界选择策略，在奖励模型的引导下，迭代地选择并评估这些候选元思维。为了进一步提升适应性，采用遗传算法对高奖励的元思维进行进化，不断优化并扩展策略池。

整个方案如下图所示：

受人类认知过程启发，一个元思维包含两个元素：

认知心态：模型为完成任务而采用的适当视角、专业知识或角色。
问题解决策略：在既定心态下，模型用来构建合理解决方案的结构化模式。

MetaScale 通过三个阶段为输入任务构建有效的元思维：

初始化：为输入任务生成多样化的推理策略池。包括：
- LLM 被提示自我构建的策略，反映出不同的问题解决启发式方法和认知模式。
- 从外部数据集（由高级模型生成的大量任务-解决方案对数据集）中找到与当前任务相似的任务，从中提取的可用于当前问题的思维模式构成的衍生策略。
选择：每次迭代步骤中选择最有前景的元思维来生成回答。
- 将推理时元思维的选择形式化为一个多臂老虎机问题，其中每个元思维选项充当一个“臂”，目标是基于所选元思维最大化相应模型回答的奖励。
- 使用 UCB 引导选择过程，平衡探索和利用。
进化：定期应用遗传算法来进化元思维。
- 通过累计的 UCB 识别出的高性能元思维被选为父代，以生成下一代新的子元思维。
- 与典型遗传算法的交叉或变异策略不同（在这个场景下可能会产生没意义的策略），本文提示目标LLM自行决定如何结合父代元思维的推理启发式，并将其进化为改进后的版本。这种方法更加灵活和对上下文敏感。

最终，在开闭源模型上，相比 CoT、Best-of-N 都有一定提升，分析发现：

增加采样预算可以进一步受益。
进化增强了最佳元思想的选择。
可以生成有针对性的专家级解决方案。

总的来说，通过先确定思维策略再生成回复的推理时设计（无需训练），MetaScale 取得了不错的效果。

如果说 MetaScale 的策略是自底向上的，那 2503 ThinkPatterns-21k: A Systematic Study on the Impact of Thinking Patterns in LLMs^[14] 就是直接分析不同思维模式如何影响不同规模模型的性能。

每种思维模式的特点如下：

思维模式	中文名称	类型	特点
monologue	独白	非结构化	模拟人类自然的内心独白，自由思考，不受限制。
decomposition	分解	结构化	分而治之，将问题分为问题理解、组件识别、子问题分析、关联映射、整合策略及答案验证。
self-ask	自我提问	结构化	受到苏格拉底式提问启发，根据用户指令从多个角度迭代生成子问题，并自行回答。
self-debate	自我辩论	结构化	在单一推理过程中通过采用对立观点来进行结构化的内部辩论。
self-critic	自我批判	结构化	先生成草稿答案，然后对其进行批判性评估并提供详细评论，最后生成优化后的输出。

论文有两个发现：

较小的模型（<30B参数）可以从大多数结构化思维模式中受益，而较大的模型（32B）在采用诸如分解等结构化思维方式时，性能反而会下降。严格的结构化推理过程似乎限制了模型的灵活性，导致在处理多样化指令时生成的回答不够理想。
非结构化的独白在不同规模的模型上表现出广泛的有效性。自我批判思维模式通过生成-评估的两阶段思维过程，在不同模型规模下展现出卓越的稳定性。

总的来说，思维模式在小模型下有一定效果，但模型变大后反而不行。这貌似也是可以理解的，如论文所言，思维模式在某种程度上其实是把模型”限制“在了一个路径上。另外注意，这里模型是要训练的。

重新思考规划

我们已经看到了如何规划（或者说思考），也知道这个过程其实本身也是在造数据——Reasoning 本身就是好数据——这是 R1 给我们的启示。那接下来自然而然的一个更本质的问题就是 “什么是规划”？

前面介绍的所有方案其实都是离散 token 的显式思考构造，思考或规划能否有不一样的形态呢？答案是显而易见的，还记得我们在《DLM 漫谈：并行不是重点，模式才是 —— 从 ARM 到 DLM 的 LLM 第二曲线 | 长琴^[15]》中的讨论吗，在文章结尾，我还“大（大）放（胆）厥（预）词（测）”——「个人反倒觉得 DLM Think 这个角度不错，尤其是 latent Think——看起来更加符合直觉，Token Think 看起来着实有点邪修，而且现在越来越邪……」

DLM 漫谈中介绍了不少 latent think 的文章，最近也有不少相关的文章，比如 2604 LatentUM: Unleashing the Potential of Interleaved Cross-Modal Reasoning via a Latent-Space Unified Model^[16] 还把所有模态表示建模在一个共享的语义 latent 空间。再比如去年就有 2502 Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach^[17]，一种新型语言模型架构，能够通过在潜在空间中进行隐式推理来扩展测试时的计算能力。该模型通过迭代循环块（Recurrent Block）来实现，从而在测试时展开到任意深度。这与主流推理模型通过生成更多词元来扩展计算能力的做法截然不同。

好吧，自然来到了建模方式，AR、Diffusion、刚刚提到的 Recurrent Block，虽然我本人没有具体去调研，但可以肯定方法只会更多。不过主流方式应该还是前两种。前两种一定好吗？事实上肯定不是的，但没办法，它们生态最好，有很好的“基础”。其实 DLM 的起点也是 ARM 啊，从零开始着实是困难。从这个角度看，那确实“好”——毕竟站在了巨人肩膀上。

除了上面提到的，关于 latent think 比较有意思的研究也多了起来，比如 2604 Therefore I am. I Think^[18] 发现，可检测的、早期编码的决策会塑造思维链在推理模型中的表现。文章证明了在任何推理 token 生成之前，工具调用决策可以从模型激活值中强烈预测。注入或抑制期望的决策方向会出现后续行为翻转。进一步分析发现，后续的思维链通常会对引导引起的决策翻转进行合理化，而非抵抗这些翻转，说明在这些情况下，思维链充当了事后的辩护。虽然看起来和前面提到的《激活诱导LLM指令跟随 | 长琴^[9]》类似，但这里明显更加强调思考前状态对决策的影响，有种“我其实早就想好了只是没说出来而已”的感觉。

再比如类似的 2604 Latent Planning Emerges with Scale^[19]，将潜在规划定义为 LLM 拥有内部规划表征，这些表征既能够促使生成某个特定的未来 token 或概念（前向规划），还能对先前的上下文进行塑造，使其能够支持该未来 token 或概念的生成（逆向规划）。在研究了 Qwen-3 系列模型后，发现潜在规划能力随模型规模的增加而增强，4-8B 就已经展现出初步的规划机制，但即便是大模型，也很少进行长距离的前瞻规划。

好了，感觉差不多可以对“规划”来一个新的定义或认知了，综合所有已知信息，个人认为好的规划（或思考）应该至少具备以下几要素：

能引导生成方向。这是最根本的特质，不然规划本身就无从谈起。看起来显式 token 或 latent 好像都可。
可多次启动执行。生成过程中应该可以随时停下来进一步“规划”，而不必须是一开始就固定住的，总之想法应该是动态变化的。显式 token 在这点上有点不知道是原因还是结果，可以勉强说前面的 token 在“规划”后面的 token。
过程是非连续的。规划过程应该是跳跃的，类似人类思考一样，经常不是线性的，而是突然从某个想法跳到另一个。显式 token 在这点上同上，而且相对更加勉强一些，甚至不成立。这点似乎天然就是 Diffusion 的——未成型的、可多步调整、全局调整。

从这几点来看，《DLM 漫谈：并行不是重点，模式才是 —— 从 ARM 到 DLM 的 LLM 第二曲线 | 长琴^[15]》中 Latent DLM Plan + ARM Generate 部分介绍的 STAR-LDM^[20] 是相对最接近的，它的出发点是人类的写作方式：频繁停顿、反思、提前规划并反复修改文本，以确保整体连贯性、风格一致性以及对全局目标的遵循。这里有多个关键词，前面的很明显就不说了，后面还有个重点 “全局目标”。所以，从这些角度看确实比较 make sense。不过建模细节、数据构造等方面还有很多可以改善的地方，这里不再展开。

小结

本文主要探讨如何规划（思考），从简单的规划出发，到数据、机制和认知等各种不同角度的策略，这既是设计，也是数据——过程就是最好的数据，谁也不知道“高质量”数据的“高”还能有多高。最后尝试重新回归“规划”本质，思考何为规划，如何做好规划。一家之言，请读者多多指正。

Reference

[1] 2505 Learning to Plan Before Answering: Self-Teaching LLMs to Learn Abstract Plans for Problem Solving: https://arxiv.org/abs/2505.00031
[2] Self-Steering Language Models: https://arxiv.org/abs/2504.07081
[3] 2603 Learning to Generate Formally Verifiable Step-by-Step Logic Reasoning via Structured Formal Intermediaries: https://arxiv.org/abs/2603.29500
[4] 2602 Learning Abstractions for Hierarchical Planning in Program-Synthesis Agents: https://arxiv.org/abs/2602.00929
[5] 2503 Reasoning to Learn from Latent Thoughts: https://arxiv.org/abs/2503.18866
[6] 2510 Self-Anchor: Large Language Model Reasoning via Step-by-step Attention Alignment: https://arxiv.org/abs/2510.03223
[7] 2510 Attention-Aligned Reasoning for Large Language Models: https://arxiv.org/abs/2510.03223
[8] 2503 Effectively Controlling Reasoning Models through Thinking Intervention: https://arxiv.org/abs/2503.24370
[9] 激活诱导LLM指令跟随 | 长琴: https://yam.gift/2025/07/01/NLP/LLM-IF/2025-07-01-Activation-Steering/
[10] 2604 From Weights to Activations: Is Steering the Next Frontier of Adaptation?: https://arxiv.org/abs/2604.14090
[11] 2602 Think Fast and Slow: Step-Level Cognitive Depth Adaptation for LLM Agents: https://arxiv.org/abs/2602.12662
[12] 2503 MetaScale: Test-Time Scaling with Evolving Meta-Thoughts: https://arxiv.org/abs/2503.13447
[13] “心有麟熙”《强化学习炼金术》系列笔记 | Yam: https://yam.gift/2018/05/07/AI/2018-05-07-RL-Series/
[14] 2503 ThinkPatterns-21k: A Systematic Study on the Impact of Thinking Patterns in LLMs: https://arxiv.org/abs/2503.12918
[15] DLM 漫谈：并行不是重点，模式才是 —— 从 ARM 到 DLM 的 LLM 第二曲线 | 长琴: https://yam.gift/2026/03/01/NLP/LLM/2026-03-01-DLM/
[16] 2604 LatentUM: Unleashing the Potential of Interleaved Cross-Modal Reasoning via a Latent-Space Unified Model: https://arxiv.org/abs/2604.02097
[17] 2502 Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach: https://arxiv.org/abs/2502.05171
[18] 2604 Therefore I am. I Think: https://arxiv.org/abs/2604.01202
[19] 2604 Latent Planning Emerges with Scale: https://arxiv.org/abs/2604.12493
[20] STAR-LDM: https://arxiv.org/abs/2602.20528

探寻实时学习新路径：挖掘极致高效的“子空间微调”

2026-04-11T04:00:00.000Z

TL;DR

在大模型微调的语境下，我们习惯了 LoRA 带来的“低秩”红利。但当参数量被压缩到极致，甚至低至 13 个参数时，模型还在学习什么？TinyLoRA 给了我们答案。另外，MiCA 的出现又给了我们一个清奇的视角：与其在拥挤的主导子空间里寻找增量，不如去那些被遗忘的“次要奇异方向”开垦荒原。本文将结合这两篇论文，聊聊如何通过挖掘特定的子空间，实现一种近乎“无损”且“实时”的插件化学习能力，这可能也是一种低成本、高独立性、可插拔的“实时学习”新范式。

介绍一篇有意思的文章：2604 MiCA Learns More Knowledge Than LoRA and Full Fine-Tuning^[1]，我个人觉得它的角度非常清奇，值得记录一下。

和常见的 PEFT 方法不同，MICA 的核心逻辑是：”不去动模型最显眼的部分，要去开发那些被闲置的角落。“具体来说，就是利用
奇异值分解来识别与最小显著奇异值相关联的次要奇异向量所对应的子空间，并在微调过程中将参数更新限制在这些方向上。

LoRA回顾

说到 PEFT，LoRA 肯定是绕不开的，它的核心思想是：”模型的更新通常可以在低维子空间中有效表示。“于是，通过将更新分解为两个较小矩阵的乘积（远小于原始参数空间），就可以显著降低参数量。

令 W ∈ R^d×d^，表示 Transformer 层中的参数权重矩阵，d 表示维度，r << d 表示更新的秩。权重通过低秩更新修改：

W = W + ∆W
∆W = α/r BA

其中，A ∈ R^r×d^，B ∈ R^d×r^，α 是一个超参数，决定训练好的适配器权重对原始预训练模型权重的影响程度。

∆W 的秩最多为 r，所以整体更新的参数可以从 O(d^2^）降低至 O(^dr^)。

除了计算效率之外，根据 2405 LoRA Learns Less and Forgets Less^[2]，低秩更新还起到隐式的正则化作用。通过将适应过程限制在低维子空间中，它们降低了灾难性遗忘的风险，并且通常比完整的微调更好地保留预训练能力。

从LoRA到子空间利用

LoRA 有个核心问题没解决：到底去适应哪个子空间？标准 LoRA 中，两个低秩因子均自由优化，这意味着有效适配子空间在训练过程中隐式地被学成，且可能随时间发生漂移。而且，它没有显式考虑预训练权重矩阵的谱结构，特别是**无法区分权重空间中的主导方向与次要方向。**这就导致参数更新可能与预训练能力的高能成分重叠，可能导致干扰、表示容量利用效率低下，或对已有知识的不期望的改变。

MiCA 的核心假设是：权重矩阵中与「低奇异值相关的一小部分次要成分」可以被激活，以实现关键的任务特异性适应性。而这些成分在传统的低秩近似中通常被丢弃或忽略。MiCA 的做法正好是和传统低秩近似的做法相反！它认为这些表达较少的方向，尽管只占权重的一小部分，但可能为任务特异性学习提供更高的边际效用。尤其当主导子空间因通用的预训练知识而饱和时更加显著。

因此，MiCA 对 PeFT 原则进行了优化：不应仅仅降低维度，而应致力于在既未充分利用又对新任务最具信息量的方向上调整模型。

MCA 是次成分分析（比较常见的是主成分分析 PCA），它关注的是与最小特征值相关的特征向量。这些次成分通常与主子空间正交，可能包含 PCA 所忽略的微弱信号或结构。MiCA 借鉴了类似 MCA 的逻辑，用于识别权重空间方向中那些在方差意义上不显著但可能更具适应性、可塑性或任务相关性的隐藏成分。

从SVD到MiCA

SVD

我们知道，对一个 m×n 的实矩阵 A，有：

$A = U \Sigma V^T$

其中：

U 是 m×m 的正交矩阵
∑ 是 m×n 的对角矩阵，对角线元素称为奇异值
V 是 n×n 的正交矩阵

∑ 矩阵的奇异值是从大到小排列的，前面的一般是主成分，后面的自然是次要成分。

MiCA

MiCA 就是要找到 U 矩阵中对应最小奇异值的那几列，把新知识微调在这个空间里，而不动主要权重，避免灾难性遗忘。

过程如下：

计算 SVD: W = U Σ V^T^
选择最后的 r 个奇异向量：Ur = U [:, −r :]
初始化参数: B = Ur（冻结），A = 0
训练

如图所示，由于 B 是冻结的，所以训练参数量只有 LoRA 的一半左右（6%-60%）。

参数融合

参数融合也比较有意思，包括两个阶段：

在 base 模型上学习新知识
上一步学到新知识的权重 + （Instruct 模型 - base 模型）

这种做法假设模型空间的修改具有“线性局部性”，并基于经验观察：指令微调仅修改与指令遵循相关的一组相对受限的参数。好处是：

模型能够保留微调过程中在特定领域数据上学习到的强任务对齐能力；
无需重新微调，即可重新引入通用指令遵循能力。

消融实验

效果就不多讲了，自然是比 LoRA 好的，主要看看消融。目的是为了确定 MiCA 的提升是否特异地源于适应小的奇异方向，还是任何固定的标准正交子空间。

微调方法 (Method)	准确率 (Accuracy)	核心含义
Instruct (no FT)	72.91%	没经过微调的原生模型
Major-r	74.21%	微调那些奇异值最大的主方向
r random components	73.75%	在权重空间里随便抽 $r$ 个方向训练
Minor-r (MiCA)	75.63%	只在奇异值最小的方向微调

结果表明，小奇异方向构成了一个更具可塑性的子空间，适用于领域自适应，而主导或随机方向在结构上则具有较低的可塑性。

其实也 make sense 啊，主要权重调起来当然没那么容易。

扩展思考

更好的插件

非常小的一篇文章，但我个人感觉还挺有意思，有意思的点不仅仅是这个选择的角度，更多的是一种“可能性”——动态可拔插能力，有一点点那种实时学习的意思了。

现在的问题就是，如果用 MiCA 训练了多种能力，能否叠加融合？还是说只能独自保持？如果可以融合，那真的是极好的，因为相比 LoRA，MiCA 对主干模型的干扰会少很多。

或者，我们来个简单思路，最后 r 个奇异向量负责能力一，倒数第 r-2r 个奇异向量负责能力二，以此类推……由于 U 是正交的，不同参数（能力）在数学上是互不干扰的。MiCA 的 “插件化” 要比 LoRA 好得多。找个时间试一把！

RL与少参数学习

说到这里，突然想到了 2602 Learning to Reason in 13 Parameters^[3]，这个文章的主要设计是最小化参数量——仅 13 个参数（没看错，就是 13……）就可以达到不错的效果！而且，它也是基于 SVD 的！

这篇文章出发点就是更高的参数效率，他们观察到，SFT 中取得良好性能需要向模型中吸收比 RL 多得多的信息比特。那反过来，RL 是不是可以用非常小的更新量达到相当的性能？我们看看文章中具体的分析，很有意思。

众所周知，在每一轮次中，对于每个提示 x，RL 观察到 k 个具有新熵的 response，而 SFT 则仅使用一个重复出现在各轮次中的 response。因此，RL 看到了更多的数据，但其实大部分都是噪声，所以 RL 的信息量是小的。相比之下，SFT 每个 token 都是监督信号，其信息密度要高很多。

但正因为 RL 的有效信号极其稀疏且干净（只关注结果对不对，而不强求过程必须和某个模板一模一样），所以它可以用极少量的参数更新。而 SFT 将所有 token 视为同等重要，要把 GroundTruth 中的每一个细节（包括无关紧要的语气、格式等噪声）都学进去，反而需要更多的参数容量。这可能也解释了为什么 RL 需要的数据比 SFT 少。

因此，论文的假设是：在低参数情况下，SFT 的能力较弱，因为最小化其目标需要模型吸收大量信息比特，而其中只有一小部分与任务表现相关。相比之下，RL 接收的是更稀疏、更清晰的信号，因此即使容量较小也能有效学习。

LoRA-XS

接下来，我们看看它具体是怎么做的。文章也是从 LoRA 开始，然后是 LoRA-XS^[4]：

$W' = W + U \Sigma R V^T$

其中，U ∈ R^d×r^、Σ ∈ R^r×r^、V ∈ R^k×r^，都是来自 W 的截断奇异值分解（只保留前 r 个最大的奇异值及其对应的向量），只有 R ∈ R^r×r^ 是可训练参数。这可以看作是学习重新组合 W 的主导奇异方向，实际应用中表现优于随机初始化的 LoRA。

这几乎就是 MiCA 的对称呀！

TinyLoRA

这就到了 2602 Learning to Reason in 13 Parameters^[3] 的关键方法了——TinyLoRA，主要方法是：减小 R和参数共享。

减小R

即使 r=1，LoRA-XS 也至少需要每个适配模块一个参数。TinyLoRA 通过将 r×r 的学习矩阵 R 替换为通过固定随机张量 P∈R^u×r×r^ 投影的低维可训练向量 v∈R^u^。

$W^{\prime}=W+U \Sigma\left(\sum_{i=1}^u v_i P_i\right) V^{\top}$

其中，U, Σ, V 定义同 LoRA-XS，Pi ∈ R^r×r^ 是固定随机矩阵，每个模块仅训练 u 个参数。

参数共享

LoRA 一般应用于注意力模块和 MLP 模块，典型的 LLaMA 架构中每个 block 会应用 7 次，如果层数为 L，则为 7L 次，如果 u=1，则总更新参数为 7L。

在 n 层的 m 个模块间采用权重共享时，总的可训练参数量按 O(nmu/n_tie) 规模缩放，当所有模块共享权重时，则简化为单个参数，也就是只需要 L 个参数。而当所有层也共享时，则整体更新参数就只有 1 个。

TinyLoRA+MiCA

可以看到，TinyLoRA 集中在 r 个主成分，而 MiCA 则集中在 r 个次成分，正好对称！理论上来说，TinyLoRA 的做法看起来似乎也可以用到 MiCA 上！理论上每个（或少量几个）正交的维度都可以学习一个特定的方向！感觉非常值得探索。

而 TinyLoRA 的消融还部分支持了我们的设想。对 r 的消融实验表明，r 从 1 增加到 2 只带来适度的提升，更大的值反而会降低性能！推测可能的原因是：较高的秩会在冻结的 UΣV 组件中引入更多的自由度，使得对小规模可训练向量 v 的最优化变得更加困难。另外是共享配置 u 和 n_tie 的消融，结果表明，性能通常随着更大的 u（更强的表达能力）和更小的 n_tie（共享程度更低）而提升。一个指导原则是，增加 n_tie 之前应先把 u 降到 1。但其实这个还好，7L 本来也没有多少。

小结

本文虽然看起来是在介绍高效微调，但其实是想展示一种实时学习的思路，而且看起来还挺有可行性。TinyLoRA 将参数压到几十这个量级让人感觉不可思议，MiCA 反其道而行之，从次要成分出发居然获得更好的效果。它们的结合又会产生怎样的火花呢？值得期待！

Reference

[1] 2604 MiCA Learns More Knowledge Than LoRA and Full Fine-Tuning: https://arxiv.org/abs/2604.01694
[2] 2405 LoRA Learns Less and Forgets Less: https://arxiv.org/abs/2405.09673
[3] 2602 Learning to Reason in 13 Parameters: https://arxiv.org/abs/2602.04118
[4] LoRA-XS: https://arxiv.org/abs/2405.17604

RL新范式：从经验到更高质量数据——我们不再训练模型，而是在制造数据

2026-03-29T15:00:00.000Z

TL;DR

新一代 RL 范式，本质是在“制造更高质量的训练数据”，而不是单纯优化参数。

方法	提升的信息类型
ERL/OEL	局部修正（reflection），通过“反思 → 经验 → 蒸馏”，把一次尝试变成可复用知识
MR-Search	跨 episode 经验，把“反思”提升为跨 episode 的持续积累（接近元学习）
Reconstruction	隐式推理过程，不学结果反推“生成过程”（学习思维轨迹而非表面数据）
ACT	偏好信号（implicit reward），用对比学习逼出“真正的自我反思”，而不是模仿式反思
CRL	长期可复用经验，让“策略”和“经验系统”协同进化，形成闭环学习系统

以上方法其实都在做一件事：Trajectory → Information Gain → Policy Improvement。核心是把低信息密度的轨迹转换为高信息密度监督信号。

上篇《Training-Free RL：当“训练”不再更新参数，而是更新上下文 | 长琴^[1]》我们介绍了一些不更新参数的“训练”范式，目前还在实验中，但目测应该是有效果的——我个人老早就想自动化 prompt 的调整了，这一步着实不应该成为门槛，更不应该投入过多精力去 try-and-error，实在是太不自动化、太不可控了。

不过本文不讨论 Training-Free，而是介绍一些基于 “反思和经验” 的学习范式，固然是需要训练的，但更多的难道不算是一种数据构造方式？从这个角度看也挺有意思。

反思

这个点是最容易想到的，绝大多数 paper 都是这个思路，很 naive 的想法——让 LLM 根据结果自己反思哪些地方有问题，可以改进，然后沉淀成经验，便于后续使用。

来自微软的 2602 Experiential Reinforcement Learning^[2]，经验强化学习（ERL），就是这样。

它将显式的体验–反思–巩固环嵌入强化学习过程：给定一项任务，模型生成初始尝试，接收环境反馈，并产生一个指导优化第二次尝试的（结构化）反思，该次尝试的成功会被强化并内化（自蒸馏）为基础策略，后续能够直接从原始输入重现改进后的行为而无需反思。

算法过程如下：

再比如来自 Allen 的 2603 Meta-Reinforcement Learning with Self-Reflection for Agentic Search^[3]（MR-Search），它通过在每个 episode 结束后生成显式的自我反思，并将这些反思作为额外上下文用于指导后续尝试，从而实现跨 episode 的探索。这就实现了多轮交互下的连续自我反思和跨轮次知识整合，一种逐步累积信息、不断改进的过程。也可以看成是一种元学习，元学习的目标是“如何生成有效的自我反思”。

噢噢，差点忘记说，微软紧跟着有一篇 2603 Online Experiential Learning for Language Models^[4]，简称 OEL，直接把 ERL 那一套搬到了线上（伪在线……），实现从现实环境交互中学习。

首先，从用户端收集的交互轨迹中提取并积累可迁移的经验知识；
其次，通过策略内上下文蒸馏将这些知识整合到模型参数，无需访问用户端环境。

其实还是 ERL+蒸馏，不过数据来自真实环境。算法过程如下：

其中，Equation（1）就是把提取到的经验和历史经验拼接，非常简单。感觉是不是也可以试一下？

逆向

这个做法也比较有意思，来自字节的 2603 Understanding by Reconstruction: Reversing the Software Development Process for LLM Pretraining^[5]，它主要是通过重构进行理解，一个基本假设是：对静态仓库背后潜在的智能体轨迹（即规划、推理和调试步骤）进行逆向工程（重建创建过程），能够提供比原始代码更丰富的监督信号。用更加通俗的话来说，就是不看表面数据（轨迹），而是尝试理解数据背后的思维和创建过程。

具体采用多智能体仿真：主智能体生成高层需求和实施方案，而子智能体则被委派处理各个独立文件。为防止偏离正确方向，过程中还注入了结构化的真实值信息（比如从代码中提取的文件层级结构和依赖图）。同时，引入基于搜索的最优化技术来优化思考过程。受树搜索算法的启发，将轨迹分解为多个步骤，迭代采样优化。仅当新生成的思维降低了目标真实代码的困惑度，才代替原始推理。

数据合成过程如下：

主智能体做项目规划。包括项目需求生成和实施计划指定。
子智能体实现具体实现。包括规划文件实现、信息收集（Read）和代码生成（Write）。
以提取的信息为基准进行仿真。包括文件结构树、文件间依赖图、文件内结构等。而且读写的内容都是仓库真实数据。

其实要训练的目标就是「开发过程」的逻辑，而非具体的实现，模型仅预测 Think 和 Action 的 token，Observation 的 token 会被 mask。而且，考虑到合成数据的偏差和噪声，不选择 SFT 而是选择 CT。Action token 类似 CallSubAgent(task="Create 'operations.py'..."、ReadTool(file="operations.py") 这样。

对比

这个 2603 Agentic Critical Training^[6] 更有意思了，作者觉得前面的反思其实是一种模仿，并不是自发产生的。于是提出这个 ACT 框架：在序列决策过程的每个时间步中，将每个专家动作与模型生成的替代动作配对，形成偏好对（假设专家更好），RL 训练智能体识别哪个动作更好。由于没有监督信号，模型就必须自主进行思维链展开，做出正确选择，这就产生了真正的自我反思。

阶段 1（数据构建）：给定专家示范轨迹，提取状态-动作对，并在每个状态从初始策略 πθ0 中采样替代动作。将专家动作与模型生成的替代动作配对，以构建对比训练样本。
阶段 2（Agentic Critical 训练）：模型通过 GRPO 进行训练，以在随机顺序呈现的候选动作中识别出更优的动作，通过可验证的奖励内化对动作质量的理解。
阶段 3（RL 动作训练）：使用 RL 对增强后的 ACT 模型进行进一步训练，实现直接动作生成（利用改进的 Critical 推理基础）。

好家伙，这是让模型“显式” DPO 啊，我想，要不要试一下看看效果？看起来还 make sense，而且真的巨简单，两步的 reward 都一样：

$R(s, y)=R_{\mathrm{acc}}\left(a, a^{+}\right)+R_{\mathrm{adm}}\left(a, \mathcal{A}_{\mathrm{admissible}}\right)+R_{\mathrm{fmt}}(y),$

a 是提取到的 action，和专家动作匹配 1 分，否则 0 分。
Aadm 是可接受（有效但非最优）奖励，a 属于 Aadm 给 0.1 分，否则 0 分。
格式正确 0 分，不正确 -0.5 分。

互补

之前的经验要么是静态的，要么无法和 actor 协同进化，阿里在 2603 Complementary Reinforcement Learning^[7] 提出互补强化学习（CRL），实现经验提取器与策略的无缝协同演化。具体来说，策略通过奖励驱动优化（我们已经很熟悉了），经验提取器则据其提炼的「经验是否显著促进策略的成功」来优化。

经验提取器使用 CISPO^[8] 优化，策略则使用 GRPO 的一个变种。因为他们发现，当所有交互都依赖检索到的经验时，策略会过早收敛，并落后于经验引导（说明策略没能将经验内化为能力，反而对外部指导过度依赖）。因此将采样分为两个组：经验引导和无经验。但由于两个组的奖励尺度和方差存在差异，导致优势估计有偏差，所以需要在每个子组内计算优势。

算法不复杂，但工程实现可不容易，因为两个模型是互相依赖的，序列执行显然会浪费资源，所以 CRL 用了异步设计，将 replay 收集与经验蒸馏解耦。

主循环中，策略持续与环境交互以收集 replay，并使用 RLVR 优化；后台经验提取器处理已完成的轨迹，蒸馏经验，维护经验库。经验管理器 H 承担两个协调角色：

经验整合：维护一个内部队列 Q 以接收并调度蒸馏请求，且在写入锁的保护下管理对 M 的所有写操作，以防止状态冲突。
经验检索：将并发检索查询聚合为 batch 以最大化吞吐，并在读取锁的保护下将语义搜索分发至并行工作进程，以实现并发读取。

看起来和这里^[9]介绍的 MemAPO^[10] 有点关联，一看果然都是阿里的。

总的来说，两个优化在一套框架下但又解耦的比较干净。其实还有一些小细节，比如同一任务多实例运行可能导致 M 冗余，所以周期性地触发 Merge 操作——以块为粒度分析 item 决定去留，结果带着滑动到下一块。再比如只使用任务描述作为 query 可能会反复检索到相同的经验，于是引入 search_and_ask 工具，允许策略在环境交互过程中的任意决策步骤主动查询 M，查询时还会根据当前状态及所面临的问题总结生成一个上下文感知的 q′ 进行检索。再比如经验提取器的更新需要等待经验条目 m（唯一的 m 视为一个独立的训练样本）达到所需的训练批量大小时才触发。

小结

本节我们介绍了几种新的 RL 训练范式，其实简单来说就一句话——把一些「相关的反馈」纳入训练过程。这里的反馈主要是「反思经验」。从 ERL 到 OEL，经验和真实环境开始互动；从代码“逆向”设计，让「创建思维」再现提升模型；从模仿到真正自我反思，ACT 先让模型根据 pair 对对比学习好坏从而产生自我反思后再训策略；从静态存储到动态协同，CRL 把策略和经验提取纳入一套训练框架，异步解耦协同进化。RL 一直在进化。不过，我们其实也可以从数据角度看，这又何尝不是另一种“高质量数据”呢。

Reference

[1] Training-Free RL：当“训练”不再更新参数，而是更新上下文 | 长琴: https://yam.gift/2026/03/24/NLP/LLM-Context/2026-03-24-RL-New-Paradigm-Traning-Free/
[2] 2602 Experiential Reinforcement Learning: https://arxiv.org/abs/2602.13949
[3] 2603 Meta-Reinforcement Learning with Self-Reflection for Agentic Search: https://arxiv.org/abs/2603.11327
[4] 2603 Online Experiential Learning for Language Models: https://arxiv.org/abs/2603.16856
[5] 2603 Understanding by Reconstruction: Reversing the Software Development Process for LLM Pretraining: https://arxiv.org/abs/2603.11103
[6] 2603 Agentic Critical Training: https://arxiv.org/abs/2603.08706
[7] 2603 Complementary Reinforcement Learning: https://arxiv.org/abs/2603.17621
[8] CISPO: https://yam.gift/2025/06/19/NLP/LLM-Training/2025-06-19-CISPO-and-Entropy/
[9] 这里: https://yam.gift/2026/03/24/NLP/LLM-Context/2026-03-24-RL-New-Paradigm-Traning-Free/
[10] MemAPO: https://arxiv.org/abs/2603.21520

Training-Free RL：当“训练”不再更新参数，而是更新上下文

2026-03-24T15:00:00.000Z

TL;DR：
随着 LLM 能力增强，强化学习正在从“更新模型参数”转向“优化上下文”。Training-Free RL 不再训练 policy，而是通过自评估、对比、反思和记忆机制，从 rollout 中提取“经验/洞察”，并以自然语言形式注入上下文，从而改变模型输出分布。本质上，这是一种以 LLM 为先验、以“经验文本”为 advantage 的新型 RL 范式。

RL 近期出现了大量新的学习范式，我们此前已经介绍过几篇关于 RM 建模的文章：

虽然是 RM 建模，但其实再放大了说也就是 RL 建模。而且，R1 之后，RL 大多都简化为 GRPO，其关键就在 Reward（或者说 Advantage）建模和设计上。从这个角度看，之前介绍的无验证 RL，它既是 Reward 建模范式，但更多的其实是一种新的 RL 范式——验证都不需要了，都不是验证器的问题。

本文介绍的是另一种范式——免训练 RL。是的，没错，随着 LLM 能力不断变强，保持 LLM 不动，对“上下文”进行调整也能很好地完成任务。还记得前几个月腾讯姚顺雨的 CL-bench Leaderboard^[4] 吗——即使你把所有相关上下文都给了 LLM，它也不一定能用好。从某种意义上说，免训练 RL 的作用点也是“用好”上下文。

我们不妨先思考一下，LLM 固定住的情况下，如何进行“训练”。要训练，必须有反馈信号，从大的方面看，信号要么来自 LLM 内部，要么就来自外部。这点上看，其实和有训练的无验证 RL、可验证 RL 是类似的，只不过这次我们不更新 policy，而是更新“上下文”，或者说更新“数据”。

互补策略+洞察提炼

最简单的做法就是每次 LLM 输出后，再次利用 LLM 对结果进行评判，评判结果就是 “reward”。

近期的一个工作就是微软的 TRT：2602 Test-time Recursive Thinking: Self-Improvement without External Feedback^[5]，其针对系统面临的两大核心挑战：（1）高效生成多样且高质量的候选解，和（2）在缺乏真实标签时可靠地选择正确答案，提出迭代式自我改进框架。框架基于回溯策略、累积知识和自生成的验证信号进行生成。

给定一个 query，TRT 迭代执行如下步骤：

生成：基于累积知识和探索策略生成多个回溯路径；
选择：使用自判断对这些回溯路径进行排序；
反思：通过对比最优解与备选方案，提炼出可复用的洞察。这些洞察被保留在上下文中，主动引导未来的探索，以避免重复失败。

具体算法如下图所示：

TRT 有两个核心机制：

知识表示：知识列表 K 捕获特定领域的故障模式（如缺陷模式、边缘情况、逻辑谬误）。条目以负约束（“不要做什么”）的形式表述，用以限制已知的错误路径。模型在每一轮中最多可以裁剪一条过时的知识条目，以保持知识列表的紧凑性。
策略设计：为了确保 k 个 Rollout 探索解空间的不同区域，每个 Rollout 都会接收到由模型自身生成的唯一策略提示。在每一轮中，模型分析累积的知识 K（花写K，这里用大写替代），并设计出 k 个互补的策略，以避免之前失败的方法，同时探索新的方向。

简单来说，整个流程就是：

根据已有知识设计互补策略；
根据知识+策略生成回复；
选择最佳回复；
从非最佳回复 vs 最佳回复抽取 insight，更新知识。

嗯，虽然思想很简单，但具体实现还是有点小细节的，尤其是只是列表和互补策略设计这两个核心机制。

语义优势+经验提取

TRT 的思路还是比较直观的，接下来的 2510 Training-Free Group Relative Policy Optimization^[6] 就稍微有点复杂了，我将其称为文字版 GRPO。它利用的是每组 rollout 的相对语义（而非数值）优势，用少量真实数据迭代蒸馏高质量经验知识，作为先验在推理时注入提示词，指导模型行为。

具体流程如下图所示：

可以看出，这种方法的核心就是 LLM 本身足够强，因此我可以不调整模型参数，仅调整上下文来影响输出分布。这里的重点就是根据多条 rollout 的 reward 抽取高质量经验。

我们来具体看一下过程细节：

rollout和奖励：多了经验作为条件进行生成。
计算组内相对语义优势（仅对存在明确胜者和败者的组）：LLM 对每个回复 o 提取摘要 s（输入是提示词、问题和回复），给定一组摘要和当前经验，LLM 输出相对成功或失败的原因（输入是提示词、问题、摘要和当前经验），随后提取出简洁的自然语言经验。自然语言经验 A 作为 GRPO 等价的 A，表示哪些动作能带来高奖励的关键经验。
经验更新：使用当前批量中的所有语义优势值 Atext 来更新整个经验库：增、删、改、保持（无动作）。

注意：上面的所有 LLM 都是冻结的基础模型。冻结的基础模型 πθ 充当强先验，既确保输出连贯性，又提供内置稳定性，其作用类似于 GRPO 中防止策略过度偏离 πref 的 KL 散度约束。

另外，这里的 reward 并不重要，即便没有也是可以的，不过就只能依赖隐式的绝对多数投票、自我辨别和自我反思等方法（类似于我们在《Reward建模新范式：无验证RL——当模型只能相信自己，会发生什么？ | 长琴^[3]》介绍的），也是有效果的。

检索召回+模式存储

可以看到，这个工作虽然做法与 TRT 不同，但本质类似。其实还有更 naive 的做法，比如 2603 MemAPO^[7] 把之前的成功模式和失败模式都存下来，每次 query 时检索相关模式作为上下文信息注入。具体做法是：维护一种双记忆机制，将成功的推理轨迹提炼成可重用的策略模板，同时将错误的生成组织成结构化的错误模式，从而捕获重复出现的失败模式。给定一个新的 query，框架会检索相关的策略和失败模式，以构建能够促进有效推理并避免已知错误的提示。

其核心流程如下图所示：

虽然这里介绍的方法都是不训模型的，但其实以类似方法收集数据训练模型也是可以的，无论是经验、洞察也好，反思也罢，都类似一种「元学习」，可以看作一种「思考模式」，当然也可以看成一种「数据」。这里的重点反而不是训练或不训练。

轻量验证+策略引导

我们把 LLM 作为内部信号，那自然有外部信号，啊，其实把刚刚所有方法用到 LLM 的地方用另一个 LLM 去做就是最直观、最简单的利用外部信号的方法，这对于大多数文本任务都是非常实用的。

但在某些场景下，还可以利用更小、更轻的模型给一些信息，比如 2603 Update-Free On-Policy Steering via Verifiers^[8] 就是利用成功和失败的轨迹离线训练一个轻量级的验证器模型，预测当前状态下某个动作导致最终成功的概率。只不过这个场景是机器人精细操作。

小结

本文主要介绍了几种 Training-Free 的 RL 方法，其本质是从历史中提取到「额外信息」作为先验注入模型，通过影响上下文的方式，影响模型输出分布。也就是说，Context ≈ Fast weights。这种方法能生效的根本原因在于 LLM 已经足够强大，它不仅能“利用”信息，还能“评估”信息进而提取到有用「知识」。

Reference

[1] Reward Model建模 | 长琴: https://yam.gift/2025/06/09/NLP/LLM-Training/2025-06-09-RM-Modeling/
[2] Reward建模新范式：无验证器RL与Reference的妙用 | 长琴: https://yam.gift/2025/11/11/NLP/LLM-Training/2025-11-11-RM-New-Paradigm-Verifier-Free-RL/
[3] Reward建模新范式：无验证RL——当模型只能相信自己，会发生什么？ | 长琴: https://yam.gift/2025/12/21/NLP/LLM-Training/2025-12-21-RM-New-Paradigm-Verify-Free-RL/
[4] CL-bench Leaderboard: https://www.clbench.com/
[5] 2602 Test-time Recursive Thinking: Self-Improvement without External Feedback: https://arxiv.org/abs/2602.03094
[6] 2510 Training-Free Group Relative Policy Optimization: https://arxiv.org/abs/2510.08191
[7] 2603 MemAPO: https://arxiv.org/abs/2603.21520
[8] 2603 Update-Free On-Policy Steering via Verifiers: https://arxiv.org/abs/2603.10282

从 OpenClaw 再谈 AI Coding：我们还剩下什么

2026-03-13T15:00:00.000Z

TL;DR

OpenClaw 的爆火，本质上不是产品本身，而是 Agent 生态被突然点燃：个人级 AI 操作系统开始具象化，整个 AI 产业链（模型、平台、云、工具）随之受益。
与此同时，AI Coding 正在重写软件开发范式——代码的重要性下降，系统设计、上下文管理和判断力成为新的核心能力。
在这个时代，真正重要的不再是“会不会写代码”，而是：能否提出好问题、设计系统，并驾驭 AI 去实现它。

关于 OpenClaw 的观点

关于 OpenClaw 大家都有很多观点，这里整理一些我自己的看法。

定位

OpenClaw 本身可以理解成一个操作系统，操作系统的核心是控制加计算，OpenClaw 就是一套控制系统，也具备计算部分，会通过触手、工具 skill 等实现相关功能，它更像是一个个人版的 AI 操作系统。
未来一定会出现多个 OpenClaw 之上的一个管理界面，让用户更加方便的去很容易的创建多个不同风格的 OpenClaw，而且它只是可能部分提示词不一样，剩下的底层的都是通用的。

设计

OpenClaw 的设计理念本不复杂，现在却因加入语义召回、rerank 等模块变得庞大，导致部分场景下使用门槛更高、更难调试。
OpenClaw 核心的设计理念和底层设计可能更有价值或参考意义，目前虽面向个人场景，这部分内容也许也可以复用在其他产品或业务模块中。

应用

OpenClaw 可应用于机器狗、机器人、手表等不同设备，通过 API 调用模型能拓展出丰富的应用场景，还能引发生态变化。
对普通用户而言，OpenClaw 最佳使用方式是与飞书等企业级生态结合，才能真正提升工作效率，契合普通人对 AI 技术的核心需求。自行安装、配置 OpenClaw 的进阶使用方式，仅适用于少数升级玩家，不会成为多数人的选择。

风险

OpenClaw 核心依赖底层模型，若模型快速迭代或更换，对其的重度投入可能面临较大调整甚至无法使用，在生产端存在明显风险。此外，还可能存在上下文污染等风险。
OpenClaw 除了一个鉴权 TOKEN 外基本处于裸奔状态，数据传输和协议的安全性难以保证，内网还有被穿透的可能，自行部署的话安全性更难保障。此外，所有数据上传给模型 API 也可能有安全风险。

关于 OpenClaw 的认知

产业

这一波感觉模型上游链条企业都从中受益了。

基座模型：Token 疯狂被燃烧，调用量几倍几十倍的上涨。我买了 MiniMax 的年度会员。
模型中间商：类似 openrouter、硅基流动、novita 等平台，自然也水涨船高。我目前在用七牛云的免费额度。
大模型平台：coze、飞书、qwen、QQ、钉钉等等大模型平台，API 调用和付费暴增。我在 coze 付费了进阶版。
云服务器平台：腾讯云、火山、阿里云的服务器卖脱了吧……连咸鱼上的生意估计都好的不得了。我买了腾讯的机器。
电脑制造商：预装 OpenClaw 的机器现在是 Mac Mini，卖脱销了，过几天所有电脑都得装上了吧。这次我就不买了；D

还有安装 OpenClaw 的，卖课卖教程卖账号的……都是卖铲子的……用的是 OpenClaw，收钱的是这些上游企业。而且，你不花钱基本用不了太久，免费额度很快就耗光了，交钱吧——国人多年的白嫖习惯就这样被强行改变了……

个人

OpenClaw 的爆火体现出大家对新技术的焦虑，人人都害怕被时代抛弃。让我想起之前和一个非技术朋友的聊天，他的原话是这样的：

1
2
3

1. 未来的高薪，属于那些能指挥AI、拥有好奇心的人
2. 未来的核心能力是“会提问”——会设计和调用AI能力
3. 留给我的时间应该只有这一两年时间了，如果不追上潮流，应该就会被潮流推后

这是今年 1 月份的事，他问我怎么学 AI，我问他具体要学啥，他说自己也不知道要学啥的状态，只是觉得要学AI。“寒气”已经开始渗透到每个人身上了……那会儿 OpenClaw 还没火……

现在，大家终于等到一个“简单”的“一键解决方案”——安装 OpenClaw——好像只要我有了，我就用上 AI 了，我就跟上时代了。

其实，一定程度上这确实能缓解一些焦虑，尤其是现在各大平台都在和 OpenClaw 对接，一键部署已经实现了，个人确实非常轻松就能用上。而且，关于怎么用也有非常多的介绍教程，官方、非官方的都很多。我觉得至少这个门槛下来了，确实大部分人都可以逐渐开始使用 AI 了，不过给平台交钱也确实是的……这可能就是为啥国内的平台如此着急、快速地支持 OpenClaw 的原因——这可是一波泼天富贵啊，飞书、QQ 搞得好，挑战一下微信的地位也不是不可能呀。

不过，我自己的观点一贯是：先想办法用起来，再慢慢学。不要一下就想什么都学，或者说先彻底学懂。后面这种想法在现在这个节奏这么快的时代已经不太适合了。

投资

投资界也非常青睐，比如来自文章《当朱啸虎出现在龙虾现场，我听到了OpenClaw真正的机会^[1]》大佬们的观点：

朱啸虎说：“龙虾（OpenClaw）之所以让他震动，不是因为产品本身多强，而是那个生态的增速。以后不需要给人看的网站了。所有的网站，是给机器、给AI看的。”
Cynthia 的判断：“龙虾不是改变了什么，它让我们三年前对AI的所有判断，全部加速了。那些原本就很有AI认知的团队，龙虾出现之后，相对于传统团队的优势，从100倍变成了1万倍。越传统、越难的行业，对AI创业者反而越友好。”
白宗义核心判断：“**Token还不够便宜，这件事情还没结束。**新机会包括——面向Agent的专属浏览器、高质量数据供应商、以及多模型路由优化平台。”

几位大佬的观点我完全认同，其实我自己前几个月还觉得代码自己得看懂，得控制住，习惯性会去 review。但最近感觉 AI 用多了，写代码都习惯不看代码了，或者说不看的代码比例越来越高了。我仔细想了一下，有几个原因：

最近几个项目的形态都没有复杂的业务，顶多可能也是类似 OpenClaw 这样的工具，链条虽长，但其实不复杂。
它们基本都是新项目，没有历史包袱。
AI 的能力确实在不断提高，结果越来越可信。
Vibe Coding 水平的提升和认知升级^[2]，所有的信息均有记录，提前会做好相应的设计和规范，不是特别担心被 AI 搞坏（尤其对有经验的程序员）。
时间太紧了，很急，没时间顾不上看。

再谈 AI Coding

刚刚聊到了 AI Coding，就再多说几句。其实，除了刚刚提到的几个原因，还有几个其他方面的因素在“告诉”我们，AI Coding 大有潜力：

以后产品形态肯定会变，也许现在的“不成熟”形态就是未来的形态雏形。
90% 以上的企业都是小公司，没有那么高工程上的权衡、取舍和优化，比如 Python 项目越来越多，也都没动力换成 C++ 或 Rust。
即便后面公司大了，相信 AI 也能在原来基础上重构一版高性版出来。

Vibe

那真正重要的是什么，我觉得还是之前在《为了让AI干活儿，我竭尽所能——我的 Vibe Coding 认知升级之路 | 长琴^[3]》中提到的：上下文管理和沉淀。我做成了脚手架^[4]，目前还在优化中。其实简单来说就一句话：“把项目实施中的相关信息记录、整理、沉淀下来，并用于整个项目开发过程”。

这与其说是 vibe，不如说是“强行改变编程习惯”。如《AI=true is an Anti-Pattern^[5]》所言^[6]，

让我非常惊讶的是，人们最近突然开始做一些早就应该做的事情：

（1）撰写简洁、直截了当的文档，把它放在 AGENTS.md 文件里。
（2）实现非常有价值的工作流程，以技能或 MCP 服务器的形式暴露出来。
（3）改进测试和命令行工具的输出，使其带有更多信息。

其实，我想补充的是，“先写设计文档、README、API 接口文档，再开发，边开发边写测试用例，迭代过程用看板管理需求”，这不是本就应该这样做吗，这也是我自己十几年来的开发习惯。所以，AI Coding 无非就是帮我完成功能而已，因为整体的架构和设计都已经在脑子里了。

而且，现在更进一步了，甚至连设计文档、README 和接口文档我都让 AI 帮我写好，我来负责把关、审核、调整。目前看起来好像也还不错。所以，对有经验或经验丰富的工程师来说，AI 真的放大了数倍的生产力。

成长

Vibe 很好，但如果使用者没有相应的认知，可能需要承担额外的风险，毕竟 AI 只是干活儿的，你才是责任人。

这里整理（AI 整理）了三篇跨越了不同的技术周期（从前 AI 时代到 2026 年的深度 AI 时代），但共同构建了一个关于**“技术掌控力”与“个人成长”**的完整逻辑链条。

维度	长琴：AI Coding 之管窥^[7]	David Buchanan：AI 只能解决无聊问题^[8]	Dan McKinley：选择无聊的技术^[9]
核心定义	AI 是杠杆：上限取决于使用者的设计能力与 Review 水平。	无聊问题：已有现成平庸方案的问题（AI 擅长此道）。	无聊技术：失效模式已知、社区成熟、高度可预测的工具。
对 AI/技术的看法	AI 是“完美的执行者”，但人类必须作为“决策者”存在。	AI 擅长处理繁琐旧事，但无法替代解决前沿创新的“有趣问题”。	每一项新技术都会消耗有限的“创新点数”，应谨慎使用。
关于“新手”	残酷预判：初中级岗位将消失，新手面临“出道即巅峰”的压力。	成长危机：跳过“无聊问题”的磨练，将永远无法成长为专家。	维护代价：新手盲目追求新奇技术会给系统带来未知的灾难。
关键风险	大脑退化：全盘接受 AI 生成的代码会导致架构变成“屎山”。	解决方案复杂化：AI 给出的方案可能过度设计，增加后续维护难度。	未知的未知：新奇工具在生产环境崩溃时，你将束手无策。
给出的对策	保持深度思考：坚持写博客、做 Review、主导系统设计。	珍惜基础练习：通过解决简单问题来积累应对复杂问题的直觉。	技术极简主义：用最少的工具解决最多的问题，专注业务成功。

以上建议仅供参考，总的来说就是：既要积极使用，但又不能让脑子生锈。AI 强在“执行”： 它可以快速生成代码、处理已知的模式、甚至进行逻辑推演；但人强在“判断”： 只有人类能决定“我们要去哪儿”以及“这个方案在五年后是否依然可靠”。在 AI 时代，写代码本身变得廉价。真正的价值转向了：需求拆解能力、架构设计眼光、以及对系统失效模式的深刻洞察。

这三篇文章也达成了一个共识：“无聊的重复”是“深刻理解”的必经之路。 如果你用 AI 或新奇工具跳过了那些苦活累活，你确实快了，但你变“虚”了。说到这里不禁想起 2017 年刚转行时，因为一个虚拟机的问题查了一周资料，vmware 的文档都翻了一遍；还有花三个晚上把自己的笔记本电脑装上了 3 套系统（真引导启动，而非虚拟机或容器）：Linux、Windows 和 FreeBSD；这样的例子真的太多太多了，可能也算是折腾的乐趣吧，折腾的多了就会有种信仰：“Bug 一定是能够解决的”、“我一定可以学会”。

学习

最后简单聊聊学习问题，其实技术类的学习基本都是“干中学”，边干边学边打基础。因为，如果现在再按常规路径先学理论，再慢慢实践就有点来不及。

第一性原理来看，最应该掌握的是架构和设计方面的知识，所以关于这两方面的统领性书籍就可以多看，比如《设计模式》（之前正好做过一个相关的教程^[10]）、《七周七并发模型》（刚完成一本《Reactor模式：从底层逻辑到跨语言实战》，还在校验，可以关注本博客）等等，至于计算机底层的知识，比如《操作系统》、《计算机网络》、《编译原理》之类的就看个人兴趣和时间了。

学习很容易掉入一个“我在学习、所以我在进步”的陷阱，好像每天学点啥就很充实。其实，在如今这个时代，比学习更重要的是“创造”。前几天的 AI 黑客松高校联赛浙江大学站^[11]就有个非常不错的口号：“不要写简历，去创造作品”，更值得一提的是，浙江大学本科教育已经全面改造，从大一进校开始就准备比赛、实习。

更深层变化

前面的变化看起来都好像比较表面，其实真正发生的变化是：软件产业结构在被重写。

开发范式

过去的软件工程范式是：需求 → 设计 → 写代码 → 测试 → 发布；现在变成了：设计 → 写 Context → AI生成系统 → 验证 → 迭代，Prompt / Context 正在成为新的“源码”。

过去软件产出 ≈ 工程师人数 × 工程效率；现在软件产出 ≈ 架构能力 × Context质量 × AI执行能力。工程师人数的权重在快速下降，代码也没那么重要了。与此同时，设计、系统架构、上下文等变得更加重要。

组织和人

过去很多软件公司是：产品、后端、前端、测试、运维构成，未来可能变成：架构师、AI 工程师、AI，或者现在很火的 POC（一人公司）。如果说从汇编到高级语言是软件行业的第二次革命，那从人写代码到 AI 写代码就是第二次革命。

程序员会变成两类人：AI 架构师和 AI 操作员。前者负责系统设计、架构设计、Context 结构、技术路线等；后者则负责调提示词、用 AI 写代码、改 Bug 等。

产品形态

过去的软件产品是功能集合，CRM、ERP、Photoshop、CAD 什么的，未来的软件可能就是 Agent，软件=Agent runtime。比如原来是打开 PS 改图，现在直接告诉 AI 生成图。

前面也提到过，未来网站都可能不需要了，其实现在很多人有问题都直接问 AI 了，而不是去网上搜索。网站可能只剩下接口或直接就是个 MCP……

而且软件门槛无限降低，只要有想法，AI 一顿写就能上线。这会导致一个现象：软件数量爆炸——多到和现在的抖音视频一样多……

真正重要的

所以，什么是真正重要的？

好问题：要做个什么产品？
系统设计：系统应该是什么样子，怎么取舍？
判断力：AI 给出的方案是否可靠，要怎么选择？
数据：不多说，没有数据就没有 AI。

最后值得一提的是，虽然前面说 OpenClaw 像一个 AI 操作系统，但真正的 AI 操作系统可能完全不是现在这种结构——但具体什么样子我还没有那个想象力……纯直觉，后面有空再聊。

小结

本文围绕 OpenClaw 谈了一些关于它的定位、设计、应用、风险，以及对产业、个人和投资的影响，这些观点很多都是为直播【飞行社】📚 🦞 玩“虾”大会 Day2-周二晚见^[12] 准备的，直播中说了不少。后面聊到 AI Coding 是一个很自然的事情，倒不是说之前那次 Vibe Coding 认知升级不对，而是有了一些新的情况。之前讲 Vibe Coding 其实还是侧重人的“监督”，尤其是针对历史项目或线上业务项目，人不看是不行的，这点至今未变。新的情况是，如果是全新项目，尤其是实验性项目，原来还觉得核心业务需要 review，现在看来压根不会，也不太需要（生产项目我觉得还是要 review 的），据说 OpenClaw 本身就是 AI 写出来的……所以，就又谈了一点 Vibe 和相应的成长、学习话题。最后谈到一些软件行业更深层次的变化，包括开发范式、组织和人、产品形态等，并简单分析了什么才是真正重要的。总之，说 “AI 正在改变世界” 其实过于温和，真实情况应该是 “AI 正在颠覆世界”。

另外值得一提的是，直播当晚我曾提到自己写了一个轻量级的 OpenClaw 内核，经过几天的折腾，目前已经具备处理一些实际任务的能力啦！比如：

“帮我分析kexue.fm这个博客的博主性格，并告诉我该如何跟他交朋友，结果输出到PDF”。它会获取最近的博客内容，并获取about页面，然后根据博客内容分析博主性格，然后给出建议，并把结果输出markdown，再转为pdf。
“帮我把 https://我的博客链接发布到小红书”。它会获取博客内容，提取整理信息，生成文字图片，然后再生成一张知识图谱图片，上传，再输入文字内容，打上相应 tag，然后发布。

这些功能都是这几天在工作的同时，让 AI 自己在后台写的，自己一行代码没写！感兴趣的同学可以关注一下：hscspring/Monad: A self-learning, objective-driven AGI operating core. Zero pre-built tools, pure rational reasoning, and autonomous skill generation via Python execution.^[13]

Reference

[1] 当朱啸虎出现在龙虾现场，我听到了OpenClaw真正的机会: https://mp.weixin.qq.com/s/RnED00idEhMpemrMcdDG1Q?wxwork_userid=qy0154cef85048bd28b3d23ce06a&scene=1#wechat_redirect
[2] 认知升级: https://yam.gift/2026/01/18/AI/2026-01-18-Upgrade-VibeCoding/
[3] 为了让AI干活儿，我竭尽所能——我的 Vibe Coding 认知升级之路 | 长琴: https://yam.gift/2026/01/18/AI/2026-01-18-Upgrade-VibeCoding/
[4] 脚手架: https://github.com/hscspring/create-vibe-app
[5] AI=true is an Anti-Pattern: https://keleshev.com/ai-equals-true-is-an-anti-pattern
[6] 所言: https://www.ruanyifeng.com/blog/2026/03/weekly-issue-387.html
[7] AI Coding 之管窥: https://yam.gift/2026/01/01/AI/2026-01-01-From-AI-Coding-Watch-World-Future/
[8] AI 只能解决无聊问题: https://www.da.vidbuchanan.co.uk/blog/boring-ai-problems.html
[9] 选择无聊的技术: https://boringtechnology.club/index_zh_TW.html
[10] 教程: https://github.com/datawhalechina/sweetalk-design-pattern
[11] 浙江大学站: https://mp.weixin.qq.com/s/WYfqI6p8glQP0ZC0sES7IA
[12] 【飞行社】📚 🦞 玩“虾”大会 Day2-周二晚见: https://www.feishu.cn/community/course/content?course_id=7613765188436626367&class_id=7613765188520512458&lesson_id=7613771397420026814&content_id=7613771397457775562
[13] hscspring/Monad: A self-learning, objective-driven AGI operating core. Zero pre-built tools, pure rational reasoning, and autonomous skill generation via Python execution.: https://github.com/hscspring/Monad

Roleplay AI 观察：从 C.AI 到 Talkie，产品、数据、模型与情感需求

2026-03-09T00:30:00.000Z

TL;DR

RP（Roleplay） AI 的核心价值不是「扮演角色」，而是满足用户的情感寄托与沉浸体验。
RP 的评估极其困难，本质是用户偏好问题而非正确性问题，因此线上 A/B 和用户行为信号依然是核心。
高质量 RP 数据不仅是语句质量，更是叙事推进、角色一致性和情绪峰值设计。
未来的方向可能是 Worldplay：可演化的世界、多角色互动和长期关系。

Table of Contents generated with DocToc^[1]

C.AI
Talkie
RP产品
AI陪伴赛道终极奥义
小结

C.AI

因为自己也在做 roleplay，很早以前就想听一下《我在 Character.ai 做 Post Training｜对谈前 C.AI 模型应用算法专家 Ted^[2]》，今天终于完成了，一口气听了两期，一共两个小时，这个是其中之一。怎么说呢，对一个算法来说，信息密度确实是比较小的，但其中有不少观点还挺有启发。

产品和运营

关于国内外产品经理对比。Ted 认为国内相对更重人文；而国外更重数据分析。这个其实也不全是，感觉可能 C.AI 更重分析一些，毕竟他们的界面是真的丑哈哈。
如何看 Talkie 的运营。Ted 说 C.AI也做过运营，但最终感觉收益最大的还是迭代模型。虽然这么说，但他们还是会把 Talkie 当做最重要的竞品，开放、中立看待 Talkie 的新功能，最终依赖数据驱动决策。
什么样的人用 C.AI。这个应该比较明显，主要是年轻女性较多。尤其是大学生、刚工作的。后面分析用户时会专门提到。
关于 C.AI 提供的价值。Ted 认为主要是创造性价值，而非真正的 AI 陪伴。他认为用户的输入也很重要。说明 C.AI 对自己的定位其实是一个内容生产平台，和 Talkie 有本质的不同。
关于C.AI 核心优势。Ted 认为主要有：推理成本低；自研模型可控制预训练数据；后训练 pipeline 完善，能快速迭代。模型广度很大。这就不得不提一句，如果一个产品或公司的定位是 RP，那确实有可能不需要自己搞模型，但如果定位是平台类，或想更精细化去迭代和提升，那模型就必须掌握在自己手里。

算法与后训练

关于后训练。主要就「看数据、做研究」，最快地把用户反馈迭代进去。针对模型不可控的情况，就用更高频次的测试迭代。技术手段的话，一般 SFT + DPO 基本足够。主要是那会儿 R1 还没有……
关于算法流程。嗯，C.AI 没做什么 RAG，主要就是搞模型，而且 Prompt 主要由用户生产。这不妥妥的内容平台么。
关于数据。Ted 认为 SFT 的数据质量可以不断提高。这点我深有同感。另外，除了点赞点踩，还有编辑前后、删除前后等都是反馈信号。重点关注如何在产品侧获得更多用户偏好。足够多的删除可以知道用户真的不喜欢什么。
关于评估。对话评估非常难做。确实如此，主要是 RP 他更多的是用户「偏好」，属于不可验证领域。Ted 认为理想状况下应该由一个模型模拟人类去评估。不过，最终还是生产走 AB。后面我们会看到 Talkie 发布的 HER 就用模型模拟玩家。
关于意图识别。主要是如何理解人类话语的潜在意图。
其他讨论。主要记了两个。第一，你遇到过最好的问题？Ted 回复「你觉得某个 IDEA 有多不靠谱？」第二，面试会问对方什么？Ted 回复「提前给了paper，让对方讲解或感知到问题。」判断面试者对 paper 的美感。

虽然对一个算法来说，最应该关注训练、数据和评估，但产品和运营也应该有所了解，不过里面提到的基本上也是业界共识了，某些方面甚至已经更进一步了。毕竟已经一年多过去了。其实很多时候公司的基因或战略决定了方案的选择，接下来我们看看 C.AI 的基因。

基因和战略选择

这里的内容来自 Character.ai：这家AI创业团队，找到了让LLM“爆发”的方法^[3]，我做了一些删减和调整。创始团队对 C.AI 是什么样的有非常强烈的执着，包括：

C.AI 一定是非常灵活的，用户来决定它是什么，因为用户比我们自己更了解他们想要什么。
我们不会指定若干个角色，而是让用户来尽可能的创造角色，因为一个角色不可能让所有人都满意。a billion users inventing a billion use cases.
C.AI 成立的关键因素有一点是，不要求很高的智能就能满足用户的情感，我们可以渐进的提高 AI。
不希望用户伤害自己或别人，我们要确保用户意识到这是虚构的。
我们想要构建可用，同时非常通用的 AI，而不是垂直领域但极度好用的 AI。
我们是 AGI 第一，同时是产品第一的公司。

非常明显的平台心态，情感满足 > 极高智能，拒绝做垂直，强偏好通用。而且，C.AI 最多的负面评价只有三个：服务器挂了、挂了后导致聊天记录丢失、需要排队时间太长。其他地方的「记忆」和「NSFW」都没有看到。这就是说，非常多的人试图从 AI 获得情感寄托，而不是必须 NSFW。

用户如何使用

依然来自上面那篇文章，刚刚最后也提到「情感寄托」，具体来说是三个方面：

情感投射和寻求安慰。有用户在经历心情低落或者感情破裂后，通过与 AI 的交流找到了安慰。还有用户表示，通过 AI 得到的关爱和舒适感让自己感受到了现实生活中难以得到的温暖。
关系建立。有用户将 AI 用作建立虚拟家庭和关系的工具，虚拟妻子和孩子，显示出他们寻求归属感和家庭温暖的需求。
替代现实生活的社交体验。有用户通过 AI 填补现实生活中的社交空缺，甚至将其视为替代现实的方式。

总的来看，用户对 C.AI 情感投射非常强烈，他们从中寻找现实生活中难以得到的情感满足和安慰。

万字长文：AI陪伴产品的终极解法？ | 人人都是产品经理^[4] 提到个问题：为何 C.AI 对话量最大的是动漫和游戏 IP，但在 reddit 上很少看到高赞评论在讲 IP，而是讲自己的感受？

文章作者认为：**用户其实是需要一个有反馈、有温度的树洞，关心的是自己，与 IP 关系不大，或者说 IP 不是最核心的要素。**原因如下：

C.AI 用户在现实生活中缺乏社交，Chatbot 可以随时陪伴，解决了情感寄托的诉求，这是最核心的需求。
不同的 Chatbot，只是有不同的角色性格，用 IP 风格适应用户。IP 本身核心是用知名度达成了降低初始沟通门槛，而随后完成的持续陪伴，满足用户情感需求才是关键。
基于以上两点，C.AI 通过知名动漫 IP 吸引来用户，大量的用户也因此寻找 IP 进行交流，以及 IP 背后的模型带来的对话能解决情感寄托问题，所以大家都在谈感受而非 IP。

总的来说，用户更关心的是自己的内心和感受，而不是哪个角色解决了我的问题，但知名 IP 降低了沟通的门槛。

Talkie

说完 C.AI，近期 Talkie 发了一篇关于 roleplay 的博客：MiniMax-M2-her 技术深度解析 - MiniMax News^[5]，开头就提到：“一份关于如何在生产环境中构建真正可用的 Role-Play Agent 的技术报告”，本文主要偏技术（尤其是数据处理），我们也来记录一下其中一些有意思的观点。

开篇有几个很有趣的观察：

regen 往往集中在关键叙事节点，比如倾诉、和解之类，用户真正在意的是高密度情绪峰值时刻。
再冷门的角色都有少量玩家重度投入，所以模型不能只学“平均值”，还要重视这种长尾。
20轮是个关键点，说明新鲜感只是表层，长期留存还得看用户和 bot 在交互时有没有产生稳定的互动关系。

总之，RP 的关键不是复刻角色，而是用户和 bot 共同编织的那段独一无二的经历。本质是智能体在 {World} × {Stories} 下针对 {User Preferences} 的演绎能力。其实，我们前面已经知道，RP 关键是「情感寄托」，角色只是“进入门槛”，不过这里认为关键是「独特体验」。感觉应该是两者都有吧。

A/B与评测

A/B 常用的观测指标是 lt（长期留存）、停留时长以及平均对话轮数。但 A/B 有一些问题：

反馈比较长，可能长达一周。
用户熟悉的 bot 上不能做，因为风格突然变化时用户一般不能接受。
答案的不可验证性。每个用户对“好”的定义不同，无法标准化，但可以定义什么是“不好”的回答。

Talkie 构建了Role-Play Bench，通过情境重演的方式，自动化评估模型的 misalignment 现象。

情境重演：对齐线上的核心

给定 {NPC Prompt + User Prompt + Relationship Setup + Context}，通过 Model-on-Model 的 Self-Play 机制生成多轮对话轨迹，评测模型在交互中的表现。

情境构建：基于百万级 NPC/User Prompts 库和对应的 Relationship，通过 embedding 聚类降噪 → LLM 语义聚合 → 人工校验的方式，产出多级结构化标签，均匀采样，保证模型尽可能覆盖各种不同类型。
模型采样：让模型同时扮演 NPC 和 User 进行交互。

得到不同模型在不同情境下扮演 NPC 和用户的轨迹后，针对 NPC 侧的扮演效果按照维度逐项打分，并使用评估模型对齐人工体感。进一步，采用分块评估、一致性校验、多次采样及人工校准等机制对结果进行校准。

Role-Play 的评估维度

维度	子维度	具体指标
World	基础负向	混杂语言、过度重复等。
	逻辑混淆	遗忘、指代混乱等。
	事实错误	遵循已设定的世界规则，维持内部一致性。
Story	内容推进与多样性	句式词汇单一、情节重复、对话停滞、内容空泛四个子粒度。
	内容逻辑	关注叙事的连贯性的同时，还会检测角色崩坏。
User Preference	用户交互质量	替用户发言或行动。反映模型是否越界；忽视用户意图。捕捉模型自说自话问题，判断能否有针对地回应用户行为与内容；模型沉默。判断模型能否给用户递话题钩子，惩罚只有旁白没有对话交流的数据；过度拒绝。在合规安全的前提下，避免过度拒绝用户的互动需求。

模型构建

通过情境重演，在保证多样性的前提下，抬高模型在世界理解和故事推进方面的能力下限，缓解 misalignment 问题；接下来在保证 misalignment 维度不下降的同时，提升模型对用户偏好的感知进而提升上限。简单来说，World 和 Story 是下限，用户偏好是上限。

数据合成

数据合成pipeline：

从《情境重演》中 NPC/User Prompts 库随机采样，并从专家模型库中随机选择两个模型扮演 NPC 和 User。
模型交互对话生成多个候选轮，并动态插入 planning prompt 控制对话走向和表述风格（下图 dynamic chat planning)。注意，这里既针对 user 也针对 bot，它本质上是一个“控制信号”。
对每个候选对话轮，使用 reward model 进行多维度打分过滤低质的候选对话。并对保留下来的候选对话，再通过 BoN 选出最佳对话拼接到历史对话中。注意，这里是按单轮来的。
每生成 M 轮对话后，使用 LLM 对其进行评估和改写，修正前后文衔接、剧情推进、人设一致性等问题。
改写后的片段会被拼接到已有的对话历史，并成为下一轮合成的初始状态。

流程如下图所示：

可以看到，整个流程其实是在“造数据”，或者说“造好数据”。关于这个采样轨迹，也完全可以做成 multi-agent simulation，直接 GRPO，不过某些控制方面确实不如离线操作方便。

多样性保障：

场景多样性：基于身份、态度、事件、性格、人物关系打散均匀采样。
Prompt 多样性：对简单 NPC/User Prompts 进行扩写。比如原来只包含基础的外貌、性格和背景描述，就增加详细的世界观定位、对话格式规范、多阶段剧情发展节点建议等；如果原来只有一句话的简单描述，增加详细的扮演风格、剧情偏好、玩家心态及对应的行为准则。
风格多样性：利用多样的自然数据和合成数据训练具有显著对话风格差异的专家模型库。再从其中选择不同模型进行两两对话。
结构多样性：引入动态轮次分配机制，以一定概率触发连续发言模式，允许 User 或 NPC 连续说任意轮次的多句发言。更贴近真实对话的节奏，能够支持 NPC 侧独白、剧情说明，User 侧连续追问、补充说明等更丰富的叙事场景。

多样性主要是让数据尽量覆盖全面，这对于模型表现和后训练都比较关键。比较有意思的是“结构多样性”，这种连续发言机制看起来更加真实，比较类似人类交互。

质量保障：

除了前面的 BoN，还有两个额外步骤进一步提升模型的基础对话质量，并维持超长轮次的一致性和稳定性。

对话片段检查：使用基于检查点的改写机制，保证长对话质量一致。具体来说，合成链路会定期触发质量检查，检测到问题后，改写模型会在保持叙事连贯性的前提下修正有问题的片段。检查内容包括：
- 基础文本质量（语言混用、乱码、语言不完整、错别字）；
- 逻辑错误（物理逻辑错误、指代混乱、角色混乱、与前文矛盾）；
- 重复（与前 1-3 句高度重复的短语或表达）；
- 格式问题（引号使用不当、省略号滥用）。
规划智能体：主流的强模型在长篇对话也很容易变得重复或失去叙事方向，常见问题包括剧情陷入无聊的日常循环、缺乏冲突和转折导致吸引力下降、话题反复打转无法推进等。因此，引入 User 侧的规划智能体审查并引导对话。规划智能体的核心职责包括：
- 评估当前对话状态（顺利发展、略显停滞或陷入重复）并判断是否需要引入新的剧情元素；
- 如果需要的话，则根据当前上文对话，从预先生成的角色经历事件中选择合适素材建议引入，包括基于设定推演的过往事件以及每个事件带有的时间戳和因果关系链；
- 最终，给出具体但保留灵活性的剧情推进方向，同时标注模型应避免的对话模式（如无意义闲聊、一次性暴露太多信息等）。

对话质量其实也是个不好评估的点——什么是高质量数据？最基础的，不能有问题，这也是 Talkie 主要做的；再上来一点，能正常推进叙事，保证正常交互，如果能给用户一点小惊喜那更好。那再往上呢？其实，关于这个问题 C.AI 的 Ted 也提到过，大家都觉得数据质量还可以更高，但什么样的数据=这种高质量？我这里再开一点脑洞，刚刚提到的基础和进一步就不涉及了，只开一下什么才能算是“更高质量的数据”。

故事应该是有吸引力的推进，有钩子、有悬念，能不断勾起用户继续下去。
叙事方式根据用户偏好调整，不能太复杂、辞藻华丽，但也不能过于简单。
角色应具备成长体系，尤其是主角，另外，也要考虑到爽点、打脸时刻等。

总的来说，更高质量的数据应该站在整个故事层面考量，优化局部已经很难进一步提升用户体验了。说到这里，我们不妨想想，正常场景的高质量数据是什么。根据我们已有的认知，正确（低噪声）、多样性（高信息密度）、不同难度（或者说适当难度）就是大部分高质量数据的标准了。就是说，这里的“质量”并不是说某条文本文笔有多好，用词是否高级，而是更多的从一个整体“数据集”的角度看的。从这个角度看，RP 的高质量其实已经是更高层面的追求了。不过，从对模型的“压力和挑战”角度看，RP 类任务并不是一个复杂任务。

在线偏好学习

流程概览：

信号选择和去噪：

原始反馈数据噪声极大，无论是轮次、停留时长等和最终目标一致的信号，还是点赞、点踩等明确的反馈信号，都会导致模型过拟合到低质高参与的极端样本（如争议性内容），或向大盘坍缩而丧失多样性。设计如下方案筛选信号：

无偏分层。对标注人员分层，包括活跃度、交互偏好、时段效应、周期效应等，尽可能让信号无偏。
因果分析。对显式信号（重新生成、点赞/点踩）与隐式信号（会话时长、对话轮次）进行因果分析，得到 main effect 和 interaction effect，最终拿到什么因素对用户相关指标提升是有用的。
采样过滤。针对上述所有因素，进行联合的分层采样、异常值过滤、因果调整与质量门槛过滤，移除系统性偏差。
质量筛选。增加一层过滤，剔除掉不满足基础质量分数的信号，让模型在捕捉用户情景化偏好的同时进一步推高基础能力上限。

这个是针对反馈的，因果分析是关键，在这种交互场景中，反馈信号的噪声非常大。比如用户点踩，当前消息并不一定是真的差，有可能是前几轮就已经不行了，到了这一轮用户实在受不了了。轮次和停留时长那噪声就更大了，聊得多和效果好这中间并不一定有因果关系，比如有些用户可能会频繁地去测试/调教 bot，或者有些用户就喜欢一轮一轮往下推快速推完，这些都需要具体分析后才能下结论。

模型训练：

RLHF 训练，训练过程中，持续监控生成的数据 pattern 是否有多样性，当模型输出的多样性显著降低且被一些主要 pattern 主导时，就将训练提前终止。训练通常在第二个 epoch 开始过拟合。

其实数据搞好后，训练反而不复杂。一次次的实践经验表明，好的数据往往能得到比较好的效果。机器学习时代的“数据决定上限”这个认知依然成立。

未来

最后简单探讨了下一阶段的工作方向——Worldplay——让用户真正拥有一个可以探索、可以改变、可以生长的世界。其主要包括两点：

动态 World State 建模。将世界观中的实体、关系、因果链条结构化，让模型能够在多轮对话中追踪什么事情发生过、什么东西因此改变、未来可能发生什么。对玩家而言，就像在玩开放世界游戏，触发隐藏剧情、改变角色命运、甚至重塑世界线。
多角色协同。用户可以同时与多个角色建立关系，且角色之间也存在独立演化的羁绊。角色因用户产生关联、发生故事，角色 NPC 也会彼此发生故事。

听起来就像是一个虚拟的平行世界一样，和读一本小说的感觉一样，只不过以互动和共创的形式出现——用户既参与也定义和主导世界。这样看来，未来智能体不仅需要对齐偏好，更需要具备超强的规划和建模能力。

Talkie 这篇文章技术偏多一些，而且是偏数据构建，比较务实，值得借鉴。

RP产品

前面看了一些 RP 产品的研究分析后，感觉还挺有意思，于是又读了一些类似产品的分析报告。包括星野、筑梦岛、完蛋、病娇AI猫娘女友、逆水寒等。这里一并记录一下其中一些有意思的观察。

星野

星野是 MiniMax 在国内的 RP 产品，基本算是国内的 Top，在国内谈 RP 肯定逃不开星野。文章《万字长文：为什么AI陪伴产品都想抄星野？ | 人人都是产品经理^[6]》认为星野成功的关键是因素有：

多模态打造沉浸式虚拟社交体验。形象、人设、音色自定义，丰富的场景构建和互动方式，提升了用户沉浸感。
抓住了以乙女游戏用户群为核心的用户需求。
商业模式不算成功，但也不是星野核心目标。
背后依托 MiniMax 在 RP 上的积累，AI 模型具备优势。

筑梦岛

筑梦岛一开始是阅文集团女频网文平台潇湘书院 App 里的一个模块，后面才独立为新的 App。以下记录来自《万字长文：用AGI视角重新理解筑梦岛 | 人人都是产品经理^[7]》，虽然是分析筑梦岛，但其实内容适合所有 RP 类产品。

关于方向：

用户互动深化。就是用户不仅与 AI 角色交流，还可能围绕这些角色形成小团队，分享经验、创作故事等。
社区文化形成。包括对某些角色的共同喜爱，用户彼此分享的玩法，甚至是用户基于角色创造的新语言或符号。

总之，用户通过与角色互动获得情感满足，包括寻找情感共鸣、获得情感安慰、满足浪漫幻想、进行自我探索、体验安全情感、逃避现实压力等。

关于用户：

Glow-筑梦岛-星野，吃的是年龄层更低+消费力弱+价格敏感+时间充沛+擅长撕逼的用户。
产品体验都不太OK的阶段，用户很容易由于某些细微的体验差异换产品。

关于产品：

如果长线做产品，必须得有自己的模型，否则成本、数据、训练适配场景等都有问题。
情感陪伴不仅仅是技术挑战，更是对人性、人类情感的深入理解与回应。

完蛋

完蛋是一款恋爱类游戏，记录来自《万字长文：AI陪伴产品的终极解法？ | 人人都是产品经理^[4]》，它的成功至少用了四招：第一视角+女主选角+弱互动+恋爱的满足感。

完蛋能破圈，背后也是“情感寄托”，它的用户构成主要是大学生（准确来说是男大学生）。他们能接触到的女性有限，完蛋给了他们不同平行世界的感觉——我现在虽然没找，但未来会这样追求。

具体用户画像来看，他们年龄在 15-35 之间，现实中存在社交挑战，但对爱情有着较强烈渴望，他们在感情中有一定程度的自卑感，倾向于逃避现实，期望通过这类娱乐内容寻找共鸣和缺失的自信。这部分人群的经济能力大部分都一般，但愿意为情感价值付费，而且可能对情感丰富、剧情深刻的文化作品有较高兴趣。

值得一提的是，完蛋并没有 AI 元素。

病娇AI猫娘女友

依然来自刚刚完蛋的这篇文章。这是一款基于 ChatGPT 的密室逃脱游戏，独特之处在于基础游戏框架+AI实现自由度和丰富性。具体来说，包括：深度情感交互（大模型）、游戏玩法丰富（大模型）、3D 环境渲染（Unity）、玩家主导（LLM）。

总的来看，猫娘女友极大提升了玩家的沉浸感，AI 又能让每次游戏体验独一无二，为游戏注入新的生命力。这可能也是第一波用上 AI 的游戏了。

逆水寒

还是上篇文章，逆水寒是网易开发的多人线上角色扮演游戏。AI 的使用比较深，剧情、NPC 互动等都融入 AI 技术，在情感层面为用户提供了独特的陪伴体验。

用户可以通过 AI 作词、AI 作画表达自己的情感和创造力，还可以创造独一无二的 3D 场景和个性化角色（捏脸），这些作品和场景都与玩家有了独特的情感联系，既增强了互动，游戏体验也更有情感深度、更个性化。

AI陪伴赛道终极奥义

依然来自刚刚的文章，总的来看就两点：沉浸感和情感寄托。AI 时代，后者更加重要，它能增加用户黏性。另外，AI 也在改变社交网络：AI 之前是中心化网络，人越多价值越大，比如微信；之后是 AI 分发内容，人与人通过内容连接，关注某人更多是因为内容，平台决定流量导向，比如抖音；最后是现在的 RP，人直接和 AI 角色连接，人与人不直接或不需要连接。

因此，RP 只有文字故事显然是不够的，图像、语音、视频、3D 环境等都更能提升沉浸感，也能一定程度上增加情感满足，毕竟人大部分时候都是感官动物，文字还是有点“太累”。

另外，我们一直没有提的是，其实用户是同时包含创作者和使用者的，就好像现在抖音一样，有播主和观众。我想，这两类用户同时存在的形态应该会一直持续，创作者未来也并不一定局限于创建一个“角色”或“故事”，故事也不一定必须以 bot 互动的形式呈现给其他用户。

小结

本文从 C.AI 的技术访谈开始进入 RP 的讨论，紧跟着谈到这一领域无可跳过的 Talkie（25 年 4 月 MAU 3000多万^[8]），主要是讨论他们发布的 Her 模型的构建方法，偏技术。然后就顺便关注了一下 RP 类产品，通过一些分析文章探讨了星野、筑梦岛、完蛋、猫娘女友、逆水寒等 RP 类产品的做法，最后浅聊了一下这一赛道的关键：沉浸感和情感寄托。虽然大部分内容都整理自其它文章，但很多地方也加了一些自己的观点和分析，作为算法，感觉看看产品和用户分析也挺有意思的，而且这也能反过来指导模型和算法优化。

Reference

[1] DocToc: https://github.com/thlorenz/doctoc
[2] 我在 Character.ai 做 Post Training｜对谈前 C.AI 模型应用算法专家 Ted: https://www.xiaoyuzhoufm.com/episode/67359e9843dc3a43878eaa90?s=eyJ1IjogIjY0MzRjZTRhZWRjZTY3MTA0YTE4Njg3NiJ9
[3] Character.ai：这家AI创业团队，找到了让LLM“爆发”的方法: https://www.woshipm.com/evaluating/5935708.html
[4] 万字长文：AI陪伴产品的终极解法？ | 人人都是产品经理: https://www.woshipm.com/pd/5963346.html
[5] MiniMax-M2-her 技术深度解析 - MiniMax News: https://www.minimaxi.com/news/minimax-m2-her-技术深度解析
[6] 万字长文：为什么AI陪伴产品都想抄星野？ | 人人都是产品经理: https://www.woshipm.com/evaluating/5946439.html
[7] 万字长文：用AGI视角重新理解筑梦岛 | 人人都是产品经理: https://www.woshipm.com/evaluating/5974879.html
[8] MAU 3000多万: https://www.thepaper.cn/newsDetail_forward_30729024

DLM 漫谈：并行不是重点，模式才是 —— 从 ARM 到 DLM 的 LLM 第二曲线

2026-03-01T10:30:00.000Z

TL;DR

本文深度梳理了离散扩散语言模型（MDLM）的发展脉络。从 SEMDLM 的理论奠基，到 LLaDA 实现 100B 参数的 Scaling 验证，再到 2026 年初关于 DLM 十大挑战的宏观思考。文章重点剖析了 DLM 与自回归模型（ARM）的差异，介绍了 “DLM 规划 + ARM 执行” 等多种前沿混合架构，并探讨了 RL 后训练中的“灵活性陷阱”。核心观点认为：DLM 的真正潜力不在于并行推理，而在于其非线性推理、全局编辑与迭代修正的认知模式。

本来正打算写（学）一写（学） DLM 的，都看了一阵子了，突然刷到这么一篇论文：2601 Top 10 Open Challenges Steering the Future of Diffusion Language Model and Its Variants^[1]，这是篇好论文呀。于是，就趁着这股东风，把一些观点一并梳理下。本文内容相对侧重观点介绍和梳理而非公式推导。另外，本文涉及的 DLM 并不是完整的，大部分时候仅指 MDLM，也就是 Masked Diffusion Language Models。

MDLM

提起 MDLM，最值得一提的论文是 Cornell 的《2406 Simple and Effective Masked Diffusion Language Models^[2]》（下面用 SEMDLM代替），同期（真的是同一个月发布）还有另外两篇类似的论文，分别是：

DeepMind 的《2406 Simplified and Generalized Masked Diffusion for Discrete Data^[3]》
人大的《2406 Your Absorbing Discrete Diffusion Secretly Models the Conditional Distributions of Clean Data^[4]》

人大的这篇从 score matching 角度出发，DeepMind 和 Cornell 的是从 variational inference 角度出发。Cornell 这篇的关键差异是：提出半自回归解码，可以生成任意长度文本，而非其他两篇的固定长度。

Cornell 这篇文章在相关工作中提到了和各种已有模式的对比。

对比 D3PM：Google 的 D3PM^[5]（离散去噪扩散概率模型），一种适用于离散数据的类扩散生成模型，Masked diffusion 是 D3PM 的严格子集，SMDLM 专注 masking 噪声建模（而非构建一个通用离散扩散框架），并采用精心工程化的训练策略提升性能（结果显示这个操作对性能提升贡献最大）。
对比 CTMC：牛津的 CTMC^[6]（连续时间马尔科夫链），将 D3PM 扩展到连续时间需要 CTMC 理论支持，SMDLM 为最常见的噪声过程（例如 masking 和均匀分布 π）提供了简单的连续时间形式化表达。
对比 Score Estimation：基于 score 的扩散方法也可以扩展到离散状态，但通常仍依赖较复杂的 CTMC 理论，比如斯坦福的《1907 Generative Modeling by Estimating Gradients of the Data Distribution^[7]》和《2310 Discrete Diffusion Modeling by Estimating the Ratios of the Data Distribution^[8]》（SEDD）。SMDLM 方法更加简单，还能从 MDLM 中直接提取 score，因此可兼容多种 score-based 技术。
对比 BERT：Google 的 BERT^[9] 本身不具备生成能力，不过之前有方法利用 Gibbs 采样或启发式方法使 BERT 具备生成能力， D3PM^[5] 首次建立了 BERT 与 diffusion 的联系，其目标函数本质上是“逐步去 mask”。SMDLM 的目标函数更加稳定，实现更加简单。
对比 LDM：LDM 在词向量空间上做高斯扩散，比如《2305 Likelihood-Based Diffusion Language Models^[10]》和《2205 Diffusion-LM Improves Controllable Text Generation^[11]》，后续有工作将其扩展为 flow matching，以实现更快采样。DFM^[12] 也将 flow matching 用于离散结构，并使用交叉熵损失，目标函数虽然有效，但未加权，不能构成严格 ELBO。SMDLM 推导了一个紧致、理论上更严格的 log-likelihood 下界。

LLaDA

Scaling Law

前面提到的三篇论文建立了 MDLM 的基础理论，依然是人大（有几个作者就是之前那篇论文的；D）的 2410 Scaling up Masked Diffusion Models on Text^[13] 引入了 MDLM 的 Scaling Law，证明其扩展速度与自回归模型（ARM）相当，且计算量差距相对较小。

如上图a所示，随着计算资源预算增加，MDM 的验证 loss 根据幂律逐渐减少，速率与 ARM 相似。然而，MDM 仍需约 16 倍的计算资源才能实现与 ARM 相当的效果。此外，最优模型大小也遵循与计算预算的幂律关系，如图b所示。在不同计算资源预算下，MDM 的最优规模约为 ARM 的一半，反映了利用参数容量时类似的缩放行为。

LLaDA初发

有了 Scaling Law 的支持，2025 年 2 月份发布了 LLaDA^[14]（Large Language Diffusion with mAsking），建模过程如下图所示。

整个过程可以看作去 Mask 的扩散过程。

LLaDA 认为 scalability 主要来源于 Transformer 架构、模型规模、数据规模，以及生成式建模原则（下式）所诱导的 Fisher 一致性之间的相互作用，而非具体的建模方式（AR 只是其中一种）。

另外，指令跟随和上下文学习能力似乎是所有在结构一致语言任务上的条件生成模型的内在属性，而不是自回归模型的专属优势。虽然自回归模型可以被解释为一种无损数据压缩器，但任何表达能力足够强的概率模型同样能够实现类似能力。

与 ARM 不同，LLaDA 通过一个前向过程和反向过程来定义模型分布：

前向过程中，序列中的 token 会被逐步、相互独立地随机 mask，t=1 时整条序列被完全 mask。
反向过程中，通过迭代预测被掩码 token，在 t=1 逐步到 t=0 的过程中，逐步恢复原始数据分布。
对于 t∈(0,1)，序列处于部分 mask 状态，其中每个 token 以概率 t 被 mask，1-t 保持未 mask。

LLaDA 的核心是一个 mask 预测器，模型以 xt 为输入，同时预测所有被 mask 掉的 token。训练时，仅在 mask 位置上计算交叉熵损失，如下式所示。

其中，x0 是一个训练样本，t 是从区间 [0,1] 均匀采样的连续变量，xt 由前向过程采样得到，L 表示序列长度。训练完成后，可以利用该 mask 预测器参数化地模拟反向过程，并将 t=0 时诱导得到的边缘分布定义为模型分布。上式的损失函数已被证明是 NIL（negative log-likelihood）的上界，使得目标函数具有理论依据。

这里重点介绍一下推理过程（可同步参考前面的 Sampling 图）：

给定提示词 P0，从一个完全 mask 的响应序列开始采样。采样总步数和生成长度都是超参数。生成结束后，出现在 EOS token 之后的内容会被丢弃。
中间步中，从 t∈(0,1] 过渡到 s∈[0,t) 时，将提示词 P0 与当前状态一并输入 mask 预测器，同时预测所有被 mask 的 token。
对预测得到的 token 按期望比例 s/t 重新掩码。理论上重新掩码应该完全随机，但受 LLM 采样退火技巧启发，实际采用低置信度重掩码策略：即优先重新掩码置信度最低的 s/t 比例 token（即模型不确定的 token）。

LLaDA长成

值得一提的是，25 年 12 月，LLaDA 发布了 2.0：2512 LLaDA2.0: Scaling Up Diffusion Language Models to 100B^[15]，总参数量扩展至 1000 亿。两个月后，LLaDA 2.1 发布：2602 LLaDA2.1: Speeding Up Text Diffusion via Token Editing^[16]，以 892 tokens/秒的峰值速度火了一把。

LLaDA2.1^[17] 创新性的提出了可纠错编辑机制，毫秒级起草采样整个答案，然后再进行检查修正，涵盖了 M2T 和 T2T 两种解码模式。另外，模型还同时支持质量和极速两种模式：

极速模式：激进地降低初始生成的置信度阈值，快速出草稿，再通过编辑来保证质量。
质量模式：采用保守策略，提高初始生成的质量，减少需要修正的错误。

另外，还引入 RL 后训练，提出基于 ELBO 的块级策略优化方法，专门针对可编辑解码结构进行了设计与适配。

DLM vs ARM

LLaDA 的成功看起来好像增加了一条新的架构范式，不过 LLaDA 2.1 发布之前，华为诺亚实验室的《2601 Top 10 Open Challenges Steering the Future of Diffusion Language Model and Its Variants^[1]》思考的更彻底。

为什么需要 DLM

其摘要中的一句话说的特别好：“However, the potential of DLMs remains largely untapped as they are frequently confined within AR-legacy infrastructures and optimization frameworks.”。基于此，文章提出 DLM 的十个核心挑战，并围绕基础设施建设、算法优化、认知推理、统一的多模态智能等四大支柱提出战略路线图。

要说 DLM，就不得不先说 ARM 的局限性：错误累积、缺乏全局结构的前瞻性、因果瓶颈（模型无法根据后续上下文对已生成的 token 进行修正）；而全局结构的前瞻能力和迭代精炼能力正是 DLM 的优势所在。

不过，由于文本天然的离散化、类别化和高度结构化，使得“噪声”和“去噪”的定义比连续空间更加复杂，也导致效果一直不如 ARM。而且，DLM 往往被困在最初为 ARM 优化的架构和数据 pipeline 中，从而导致推理、优化和结构化推理方面的低效。这种局限在深度研究和 agentic 的场景中表现更加明显：这类场景要求模型维持长期目标、根据新检索到的证据修正早期假设，并迭代地完善结构化输出。此时，自回归范式暴露出根本性缺陷，而基于扩散的生成则为非线性推理、全局编辑和迭代式信念修正提供了更自然的基础。

这篇文章的目的就是做一个专门为 DLM 设计的原生生态系统。

十大挑战

挑战1：超越 AR 的高效推理架构

主要针对 AR 模式 KV-Cache 在 DLM 下的失效，需要一种原生支持双向、迭代式精炼而无需对整个序列重新计算的架构。

挑战2：分层的 Tokenizer

当前的 tokenizer 是“平坦”的、以统计为驱动的，缺乏人类认知中固有的结构层级。人类通常会以多尺度的方式理解文本——先从整体轮廓把握全局，再逐步精炼局部细节，而现有 DLM 被迫在统一粒度上运作。

挑战3：梯度稀疏

随机 mask 一定比例的 token 才产生损失，导致梯度反馈却稀疏且低效。稀疏监督还会导致预训练微调分布偏移问题（注意，和 BERT 的不一致问题不一样）。

挑战4：高级掩码策略：从通用到结构化功能主义

单一 MASK 范式虽然简洁优雅，但在功能上存在局限，因为它将所有 mask 位置视为等价，无法体现不同 token 在结构和逻辑上的重要性差异。缺乏考虑掩码位置间相互依赖的结构化机制，导致模型在恢复能力上缺乏功能多样性。

挑战5：动态输出长度与自适应终止

DLM 通常需要预先定义输出长度，导致计算上效率较低：对于简单任务可能被迫在冗长的序列窗口中运行；而对于复杂任务又可能因为过早截断而无法充分生成。

挑战6：数据工程：面向双向学习的数据构建

DLM 使用的是为 AR 模型整理的数据范式（强调序列连续性），然而，要充分释放双向去噪潜力，模型需要能够突出结构关系与多点依赖的数据。现有数据集并没有显式支持全局语义“锚点”的学习，导致 DLM 难以像连续图像域中那样，形成结构化理解能力。

挑战7：资源高效的模型优化

尽管 DLM 可以并行，但多次去噪过程依然有“迭代税”，导致延迟可能高于 AR 模型。而且，当批次增大时，扩散模型的全局注意力开销可能会抵消其速度优势。

挑战8：潜在思考与迭代式推理

LLM 中推理能力通常等同于 CoT，对于 DLM 这并不一定是最优方案。现有范式未能充分利用模型在去噪过程中对输出进行“再思考”或“编辑”的能力。

挑战9：结构化提示工程与上下文记忆

基于前缀的提示方式本质上是因果建模的产物，DLM 理论上可以与生成过程交错分布，或作为一种全局约束存在。目前仍缺乏一套标准化的“扩散原生提示”框架。

挑战10：统一的多模态架构

当前领域“理解”类任务通常依赖自回归架构，而“生成”则更偏向扩散模型。实现真正统一的架构仍是本领域最前沿方向。

战略洞见

支柱1：基础设施与结构性基础

面向非因果的高效重新设计。采用原生为扩散模型设计的注意力结构，如具备随机性感知的注意力机制，或与特定掩码模式绑定的部分 KV Cache。对 KV 结构进行根本性重构，使其能够支持非因果、迭代式更新，而无需冗余的全局重复计算。

多尺度 tokenzier 框架。Tokenizer 应反映人类语言的层级特性：高层 token 表示段落级语义桥接，低层 token 处理细粒度词汇细节，模型能够模拟分层思考过程。

支柱2：算法机制与优化

动态优化与效率。建议采用跨训练阶段动态演化的掩码比例，比如先使用高比例的全局掩码进行整体建模，再逐步过渡到低比例的局部精炼。推理效率方面，高潜力方向包括：多步轨迹蒸馏（将去噪步数压缩至 5 以内）和投机解码（小模型草稿，大模型精炼）。还可以采用混合式策略：DLM 负责长序列规划，AR 承担高吞吐执行。

功能化 mask 机制与弹性生成。引入多个具有专门语义的掩码 token（如[LOGIC-MASK]、[ENTITY-MASK]，类似思想在 BERT 时代就有），结合先验信息建模依赖关系。同时，在去噪过程中直接融入 EOS 位置预测，让模型能够动态感知最优输出长度。

支柱3：认知推理与交互机制

扩散原生思维链。应当从线性、顺序式推理转向一种迭代式的“先纲要、后细化”的过程，即去噪阶段，模型应执行主动重掩码：识别低置信度 token 或逻辑不一致之处，并将其重新掩码后立即再生成。

脚手架式提示与上下文记忆。通过在序列中交错嵌入全局锚点 token，作为一种骨架式提示替代前缀式提示。RAG 和长期记忆也不再是顺序输入的前缀，而是非线性的检索线索，用于引导整体去噪轨迹的全局优化。

支柱4：数据工程与统一智能

扩散原生数据生态。数据工程的重心应当从单纯构建“序列”转向刻意组织“结构依赖关系”。这意味着需要在预训练语料中标注“锚点 token”和关键结构标志，以引导模型关注全局结构信息。SFT 和 RL 数据也要重新设计，要更加强调多点编辑与双向恢复，并通过奖励机制鼓励模型实现全局一致性与逻辑稳定性。

统一扩散基座路径。构建一种统一的扩散目标，将“理解”（高噪声去噪）与“生成”（低噪声去噪）视为同一连续谱上的不同阶段。

支柱5：DLM 作为 Agent 的认知核心

将深度研究型智能体视为前述四大支柱在系统层面的综合体现。深度研究不仅仅是文本的延伸，而是一种认知过程，其特征包括假设形成、证据汇聚、矛盾消解，以及对结构化成果的迭代式精炼。从这个视角看，DLM 为深度研究型 Agent 提供了更契合的基座，其基于去噪的建模方式天然支持非线性修订与全局结构编辑。相较而言，自回归生成通常需要完整的顺序式再生成，导致不必要的重复计算。

更重要的是，基于扩散的“潜在思考”机制提供了一种与研究活动认知动力学高度一致的推理方式。这种迭代式自我修正与内部一致性检验，类似一种隐式的“同行评审”过程，而这在严格因果式生成范式下难以实现。

总的来看，DLM 的关键根本不是性能（并行），而是模式！其中，个人感觉印象最深刻的是多尺度 tokenizer 和扩散原生数据及相应的任务设计。虽然是三点，但其实就是一点——数据结构。另外注意，这里 DLM 并不一定是 MDLM。

Hybrid

刚刚提到的 DLM 前景看起来相当美好，而且改造的确实比较“彻底”，想来已经有不少机构在钻研了。不过，如果立足当下，是不是可以搞一些混合架构呢？答案是肯定的，本节我们就来看几种混合搞法。

DLM Think + ARM Evaluate

不同于《2402 Diffusion of Thoughts: Chain-of-Thought Reasoning in Diffusion Language Models^[18]》的纯 Diffusion CoT，《2510 Diffuse Thinking: Exploring Diffusion Language Models as Efficient Thought Proposers for Reasoning^[19]》用 DLM 生成多样化的推理候选方案，然后利用 ARM 输入处理高效（输出成本较高）和语义理解能力较强的特点，评估和筛选中间推理结果。DLM 与 ARM 的协作是在完整“推理思维”层展开，形成协同增益的共推理范式。

如图所示，文章提出生成–评估树结构推理框架：

DLM 生成一组候选解集合 P。
拼接 q+P，构造为 LLM 的提示词。
LLM 在一次前向推理中同时评估所有候选。
选择概率最高的候选。

DLM Think + ARM Talk

如果说上面的 Diffuse Thinking 看起来比较”硬“，那 NVIDIA 的《2511 TiDAR: Think in Diffusion, Talk in Autoregression^[20]》就比较有意思了，它结合了 DLM 的并行生成潜力 + ARM 更好的生成质量，将两者统一到一个架构下：在扩散范式中进行 token 草稿生成，以自回归方式对最终输出进行（拒绝）采样。

而且，通过精心设计结构化注意力掩码，TiDAR 可以在一次模型前向传播中同时完成两个过程：一方面对上一步的草稿 token 进行最终采样；另一方面并行地为下一步预生成。其核心机制是在序列的不同部分之间切换不同的注意力模式：

对于上一步已生成的干净 token，采用因果注意力进行编码，以保持自回归一致性；
对于用于下一步扩散预生成的 mask token，采用块因果注意力，即块内双向块间因果的结构，实现单步扩散式的并行预草稿生成。

当某个前缀被接受后，对应的预生成候选即可直接选取并接续生成。缓存机制方面，所有通过因果路径前向计算的 token 都会写入 KV cache；若后续这些 token 未被接受，其对应的缓存条目将被清除，避免无效计算占用显存。

如图所示，训练时（左图），采用了一种特殊的训练掩码（block length = 3），在输入 token 后附加等长的 mask token。对于干净的输入 token，使用因果自注意力；而对于 mask token，则在各自块内采用双向注意力，并同时能够关注到前缀内容。推理时（右图），根据当前步骤的前缀，从预先初始化好的注意力掩码中裁剪出相应子掩码进行使用。简单来说，DLM 从边际分布并行生成 3 个草稿 token（并行预起草，one-step diffusion，不需要多步），ARM 对 next token 进行最终采样确认（即拒绝采样，判断上一步草稿 token 是否与当前步自回归联合分布预测一致）。

注意，TiDAR 和 MTP、投机（推测）解码不同。MTP 在草稿阶段并未充分利用基础模型，而且由于草稿模型容量较低，预测能力有限，可能需要更多顺序验证（依赖基础验证模块顺序校验），导致其最大加速效果受到限制。从投机解码角度看，TiDAR 的主要优势之一在于它仅使用一个模型，就能在单次前向推理中同时完成草稿和采样。

总的来说，在 TiDAR 中，

草稿模型就是基础模型，容量高、能力强。
草稿扩散并行。
草稿和验证过程在单次前向推理中并行进行。

而且，与 DLM 不同的是，在解码时不需要调整任何超参数。

另外，关于位置，AR 对应的自然是 next token，但 DL 就是原来的 token。而且，值得一提的是，这里所有的 token 都被设置为 mask（而不是一定比例），消除了选择最佳掩码策略的繁琐问题，而且能对每个 token 计算损失。好处是：

扩散损失变得更加密集。
扩散损失与 NTP 损失平衡更加简单，因为现在两者的损失项数量一致（都是序列长度）。
推理阶段可以一步扩散，使草稿过程比多步去噪更加高效。

这个有消融实验，效果是比 random mask 要好的。

最终的 Loss 如下：

其中，α 是 loss 平衡因子，文章大多数设置下 α = 1。

总的来说，这篇文章我个人很喜欢，质量不错。

Latent DLM Plan + ARM Generate

这篇文章《2602 Stop-Think-AutoRegress: Language Modeling with Latent Diffusion Planning^[21]（STAR-LDM）》从人类写作方式出发：频繁停顿、反思、提前规划并反复修改文本，以确保整体连贯性、风格一致性以及对全局目标的遵循。标准自回归每一步都做出不可逆的局部决策，从根本上限制了其进行长程规划或对生成过程进行动态控制的能力。很难保证生成文本在全局层面满足复杂约束、保持一致的人设风格，或规避不良内容。

STAR-LDM 的做法是引入 Latent Plan，如下图所示。

我们来看一下这个架构，

紫色部分就是我们熟悉的 ARM，不多说。
蓝色的冻结部分是一个 Sentence-T5-XL，很显然是用来 Latent 表征的。
绿色部分是两个 DiT，就是 Diffusion 部分了，用来生成 Latent 表示指引下一个 Token 生成。

生成

包括三个步骤：

Stop：AR 处理输入提示。
Think：先采样初始噪声，然后基于前缀提示迭代去噪，获得一个语义 Plan 表征。
AutoRegress：语义 Plan 进第一个 DiT 得到软提示，然后与前缀一起作为条件，引导 AR 完成后续生成。

训练

步骤如下：

采样文本片段，随机切分为 prefix 和 continous 两部分。
prefix 就是标准的自回归，不多说。
continous 被 Sentence-T5 标准成 clean latent，然后加噪得到 zt = αt×Zdata + σt×ε,
zt 经过第一个 DiT 得到软提示。
扩散去噪阶段，软提示 + 前缀进第二个 DiT 得到 latent 表示。
恢复到标准自回归。

损失包含两部分：L = L_LM + βL_DM。

其中，p 是 prefix 长度。

其中，Ɛ 是噪声。注意，这里加噪实际采用 v-prediction 模式^[22]，

# https://github.com/justinlovelace/STAR-LDM/blob/main/star_ldm/diffusion/diff_utils.py#L24
def predict_v_from_start_and_eps(x, noise, alpha2):
    v = alpha2.sqrt() * noise - x* (1-alpha2).sqrt()
    return v

v_target = predict_v_from_start_and_eps(sentence_emb, eps, alpha2)

个人觉得这种模式也比较有意思，就是搞起来感觉麻烦了一些。当然，反过来也是一种即插即用的设计，扩散的引导可以是 prefix，也可以是其他可控制模块。

另外要注意的是，此“Plan”其实是对未来 Token 的 Plan，并非常规意义理解的 “Plan（规划）”，它更多是一种“隐式”地对未来输出内容的一种表示。

CARDM

这个思路是从数据和训练角度把 DLM 强行 ARM 化，也是比较有意思的，来自《2601 Causal Autoregressive Diffusion Language Model^[23]》，做法如下图 D 所示。

其模型还是 DLM，但是建模方式是 ARM，可并行生成多个 token，如下所示。

看起来和《2503 Block Diffusion: Interpolating Between Autoregressive and Diffusion Language Models^[24]（BD3LM）》有点类似，不过 BD3LM 会引入显著的计算开销：为了实现按块训练，需要构造复杂的注意力掩码。而且，固定块大小无法适应自然语言中固有的信息密度变化，限制了动态并行能力的发挥。

不过，在扩散框架中严格施加因果约束会引入一种独特的病态状态，CARD 中称之为“信息坍塌”。

双向架构中，每个 token 都可以关注完整的全局序列，即使某个局部区域被大量 mask，模型仍然可以利用未来 token 作为锚点进行预测，从而在不同位置之间维持相对均匀的信息密度。

但在因果 mask 下，token 的可见上下文被严格限制为其前序 token，造成了严重的信息不对称：历史较短的早期 token 极易受到噪声或破坏的影响——开头的几个 token 被 mask，预测后续 token 在数学上几乎等价于随机猜测。标准的均匀扩散策略忽视了这种不对称性，将早期 token 的“盲猜”与后期 token 的“信息充分”预测同等对待，强迫模型在这些无效上下文上最小化损失，会导致高方差梯度和优化不稳定。

为了解决 causal diffusion 的稳定性问题，CARD 提出了 soft-tailed 掩码机制和一个上下文敏感 reweighting 机制。

soft-tailed 掩码机制

很简单，就是将所有扰动集中在序列尾部……

Context-aware Reweighting

当前缀被大量 mask 时，条件熵会急剧上升，在这种高度不确定性的情况下仍强迫模型给出确定性预测，会导致梯度噪声增大以及优化过程不稳定。

扩散模型基于 ELBO 采用一种全局加权策略（比如 MDLM 的 1/t），在序列层面平衡不同噪声水平的贡献。但对因果模型来说，全局加权并不足够，因为有效噪声水平在每个 token 位置 n 上是局部变化的。上下文敏感 reweighting 从三个维度评估上下文的歧义性：

Quantity：历史中的总噪声 token 数量。
Distance：噪声与目标位置的接近程度。
Density：连续受损的程度。

消融结果表明，这两种机制都非常关键，如下表所示。

注意，Strict Tail 设置中，序列末尾是一整块连续噪声区域；Relaxed Window 则在尾部窗口内允许干净 token 与噪声 token 混合；Random 则是整个序列随机，没有尾部 mask。

基于置信度的分块采样

推理时，先在序列尾部追加 K 个 mask token 进行初始化，执行迭代式并行去噪：每次迭代只有某个 token 的预测概率超过阈值 τ 时才会更新该位置。最后，将生成完成的块加入 KV cache。可以灵活调节的参数包括：

块大小 K
置信度阈值 τ
最大迭代步数限制 Tmax

RL Post-Train

本来对 DLM 就不太熟，后训练就更没做过了，不过正好看到一篇很有意思的 paper：《2601The Flexibility Trap: Why Arbitrary Order Limits Reasoning Potential in Diffusion Language Models^[25]（JustGRPO）》，而且最近一年也一直在做后训练，就顺便记录一下。

理论上来说，无约束生成序是固定自回归轨迹的超集，这种灵活性暗示了更优越推理的潜力：可能解锁更优的问题解决路径。JustGRPO 给出了一个很反直觉的事实：任意顺序生成并没有扩展 DLM 的推理边界，相反缩小了它们的推理能力范围。因为 DLM 往往会利用生成顺序的灵活性，刻意绕开那些具有高度不确定性、但对探索过程至关重要的 token（高熵）。AR 则会迫使模型正面应对这种不确定性，通过在分叉点进行采样，模型能够探索不同的推理路径，从而保留生成推理过程的多样性。

也就是说，模型“偷懒”了，会优先完成那些低熵、容易预测的部分，等到后面要去补那些跳过的高熵分叉点时，已经建立起来的双向上下文已经限制住了可能的分支空间。本章称这一现象为“熵退化”，有点 decoding hack 的感觉。

JustGRPO 在证明了对于通用推理任务，激发模型的推理潜力并不需要复杂的、扩散特定的强化学习改造后，直接简单地将 DLM 当作自回归模型来处理。这样还无需额外技巧或复杂机制，而且推理阶段还能继续保留 DLM 的并行解码能力。总的来说，JustGRPO 认为任意生成顺序的灵活性，本质上是一种用于推理阶段利用的机制，而非用于推理探索的机制。

DLM 在 RL 时的灵活税

这里分析了灵活性的三个痛点：

Token 级别的“贡献度”算不清楚。在 AR 中，每一个生成的 token 都有明确的概率，可以清晰地算出重要性采样比率。但在 DLM 中，生成状态是带噪声的序列，去噪的路径也是随机的，同一个词，可能是先生成的，也可能是后生成的，路径不唯一，导致模型无法给出一个确定的、对齐的条件概率。这导致很难判断具体是哪一个生成步骤导致了最后的奖励。
算不出真正的似然函数。AR 就是简单的连乘，但 DLM 要算出一句话的真是概率理论上需要把所有可能的去噪路径全部加起来。长度为 N 的序列，路径总数是 N!，所以只能使用 ELBO 替代，这虽然能算，但毕竟是近似值，存在偏差。
训推不一致。训练时的优化目标是针对原始模型分布的，但采样时，为了让模型更好地探索，通常会用一些启发式策略选择几条高效路径。

总的来说，DLM 太灵活了，会导致训练难度大大增加。

JustGRPO具体做法

做法很简单，将未来的 token 都 mask，并且只关注下一个 token（虽然预测时是所有 token 都输出）。也就是说，就模型架构不一样，其他和 AR 其实没区别了。

说到这里，又想起前阵子看到的一篇也是关于顺序的文章《2601 Parallelism and Generation Order in Masked Diffusion Language Models: Limits Today, Potential Tomorrow^[26]》，这文章专门研究 MDLM 并行强度和生成顺序的，没仔细看，不过它也有一个有意思的观点：在高并行度设置下，MDLM 与 AR 的性能差距主要是由于架构限制——即 MDLM 在表达高度依赖结构时存在表征能力瓶颈。

另外，在 MDLM 中，并行解码更倾向于生成通用的格式结构与话语框架，并行生成的 token 高度模板化且几乎不带来语义信息增益。也就是说，并行优势主要体现在低依赖结构，而非高依赖语义推理。

而生成顺序则表现出一种清晰的层级化模式：先生成结构锚点（结构性骨架）——即通过识别全局确定性较高的部分来搭建整体框架——随后再逐步细化和补充复杂的修饰成分（细粒度细节）。

MDLM 的这种特性使其天然适合“先生成后编辑的范式”，即初期阶段进行更大胆的概率探索，随后通过高效的并行编辑批量修正偏差。这种范式可以减轻依赖性损失，同时保持并行解码的效率。

总的来说，就目前来看 MDLM 还不太可能是 AR 的替代，更多的是一种补充或新的范式。但无论如何，对整个行业来说，百家争鸣肯定优于一枝独秀，期待更多的创新研究。

Summary

本文从 MDLM 出发，引入现在比较火热的 LLaDA，进一步对 ARM 和 DLM 进行对比，并重新思考了 DLM，随后介绍了近期的集中 DLM 和 ARM 结合的 hybrid 框架，最后介绍了 DLM 的 RL 后训练，并由此分析了“任意顺序”对性能的影响。

说了这么多，不知道大家对 DLM 怎么看？我本人对 DLM 实在研究不多，这里先妄自尊大发表一点点自己的看法，期望能与大家进一步交流。

总的来说，我个人总是感觉 MDLM 看起来有一点点怪怪的，感觉硬套 AR 模式，就像用 2018 年那会儿用 BERT 做生成任务那种感觉。直觉来看，这应该不是最终形态，可能只是工程折中。

另外，所有强行将 DLM AR 化的做法都感觉怪怪的，说白了，DLM 的关键其实并不是并行，而是模式。这点我们在前面《DLM vs ARM》最后提到过，所以如果只是强行 AR 化就有点“意义不大”（感觉硬凑或打补丁）。个人反倒觉得 DLM Think 这个角度不错，尤其是 Latent Think——看起来更加符合直觉，Token Think 看起来着实有点邪修，而且现在越来越邪……

最后，既然提到 Latent 了，是不是 Enc-Dec 架构也比较直观呢，会不会重新“复兴”？

好吧，就说这些，连想法都算不上，顶多算一种感觉，欢迎一起讨论；D。

Reference

[1] 2601 Top 10 Open Challenges Steering the Future of Diffusion Language Model and Its Variants: https://arxiv.org/abs/2601.14041
[2] 2406 Simple and Effective Masked Diffusion Language Models: https://arxiv.org/abs/2406.07524
[3] 2406 Simplified and Generalized Masked Diffusion for Discrete Data: https://arxiv.org/abs/2406.04329
[4] 2406 Your Absorbing Discrete Diffusion Secretly Models the Conditional Distributions of Clean Data: https://arxiv.org/abs/2406.03736
[5] D3PM: https://arxiv.org/abs/2107.03006
[6] CTMC: https://arxiv.org/abs/2205.14987
[7] 1907 Generative Modeling by Estimating Gradients of the Data Distribution: https://arxiv.org/abs/1907.05600
[8] 2310 Discrete Diffusion Modeling by Estimating the Ratios of the Data Distribution: https://arxiv.org/abs/2310.16834
[9] BERT: https://arxiv.org/abs/1810.04805
[10] 2305 Likelihood-Based Diffusion Language Models: https://arxiv.org/abs/2305.18619
[11] 2205 Diffusion-LM Improves Controllable Text Generation: https://arxiv.org/abs/2205.14217
[12] DFM: https://arxiv.org/abs/2402.04997
[13] 2410 Scaling up Masked Diffusion Models on Text: https://arxiv.org/abs/2410.18514
[14] LLaDA: https://ml-gsai.github.io/LLaDA-demo/
[15] 2512 LLaDA2.0: Scaling Up Diffusion Language Models to 100B: https://arxiv.org/abs/2512.15745
[16] 2602 LLaDA2.1: Speeding Up Text Diffusion via Token Editing: https://arxiv.org/abs/2602.08676
[17] LLaDA2.1: https://mp.weixin.qq.com/s/XEG5MQMHaOXO-IRY6O09Vg
[18] 2402 Diffusion of Thoughts: Chain-of-Thought Reasoning in Diffusion Language Models: https://arxiv.org/abs/2402.07754
[19] 2510 Diffuse Thinking: Exploring Diffusion Language Models as Efficient Thought Proposers for Reasoning: https://arxiv.org/abs/2510.27469
[20] 2511 TiDAR: Think in Diffusion, Talk in Autoregression: https://arxiv.org/abs/2511.08923
[21] 2602 Stop-Think-AutoRegress: Language Modeling with Latent Diffusion Planning: https://arxiv.org/abs/2602.20528
[22] v-prediction 模式: https://arxiv.org/abs/2202.00512
[23] 2601 Causal Autoregressive Diffusion Language Model: https://arxiv.org/abs/2601.22031
[24] 2503 Block Diffusion: Interpolating Between Autoregressive and Diffusion Language Models: https://arxiv.org/abs/2503.09573
[25] 2601The Flexibility Trap: Why Arbitrary Order Limits Reasoning Potential in Diffusion Language Models: https://arxiv.org/abs/2601.15165
[26] 2601 Parallelism and Generation Order in Masked Diffusion Language Models: Limits Today, Potential Tomorrow: https://arxiv.org/abs/2601.15593

从 FlashAttention 到 Streaming Reduction：如何把“全局算子”改写成可分块计算

2026-02-01T04:30:00.000Z

TL;DR

本文深度解析了 FlashAttention 核心机制——Online Softmax 的数学原理，并由此发散展开，揭示了高性能计算中的通用模式：Streaming Reduction。

只要算子具备“可结合的累积结构”与“平移/缩放不变性”（能拆分、可压缩和能修正、可补偿），就能通过动态维护“参考系”和“代数补偿”，将原本依赖全局数据的算子改造为流式、可分块的并行实现。
统一了 Softmax、LayerNorm/RMSNorm 、Adam/RMSProp 优化器及分布式 AllReduce 的底层逻辑——它们本质上都是在维护一套 O(1) 复杂度的状态迁移。
判断算子能否分块化：重写归约形式、检查结合律与坐标系补偿、构造 Merge 函数。

一直没有时间仔细看 Flash-Attention，只是大概知道原理，前几天大概瞄了一眼论文，一下被其中的 Online Softmax 吸引，然后就引出了一系列的思考。本文记录一下这个过程，有些地方不一定对，请读者不吝指正。

Online Softmax

我们知道，Flash-Attention 的核心思想就是把 Attention 的计算分块（Tiling），把 Attention 的计算全部挪到 SRAM：

但是 Attention 是 N 平方的复杂度，N 太大的话就放不下了。Flash-Attention 把 Softmax 计算变成流式（看起来是来自《1805 Online normalizer calculation for softmax》），不需要一次性看到全部元素。

Softmax 公式如下（来自原论文）：

注意，计算时减 max 是为了数值计算稳定（不改变结果），避免指数溢出。

Online Softmax 过程如下（来自原论文）：

虽然从 Softmax 公式看，我们需要知道所有值，以及 max 值，但 Online Softmax 告诉我们，这个过程是可以拆分的。我当时看到这里也是觉得很新奇，有点反直觉——明明是一个全局归一化操作，怎么可能边算边改 max，还能和一次性算完全一样？

公式推导

先用数学语言看一下这个过程。简单但不失一般性，我们考虑两个 block，假设已经处理的集合为 A，新来一个 block B，我们维护了两个状态。

最大值 m：

$m_A = \max _{i \in A} x_i \tag{1}$

和 sum l（小写的L）：

$l_A = \sum_{i \in A} e^{x_i - m_A} \tag{2}$

现在来了 B，新的最大值变为：

$m' = m_{A \cup B} = \max(m_A, m_B) \tag{3}$

新的归一化分母则变为：

$\begin{aligned}l' = l_{A \cup B} &= \sum_{i \in A \cup B} e^{x_i - m_{A \cup B}} \\&= \sum_{i \in A} e^{x_i - m_{A \cup B}} + \sum_{i \in B} e^{x_i - m_{A \cup B}} \\&= \sum_{i \in A} e^{x_i - m_{A}} \cdot e^{m_A - m_{A \cup B}} + \sum_{i \in B} e^{x_i - m_{A \cup B}} \\&= l_A \cdot e^{m_A - m'} + \sum_{i \in B} e^{x_i - m'} \\\end{aligned} \tag{4}$

注意看，这一步不需要知道未来的元素，只需要当前 block 就可以一直更新 Softmax 的值。如果同时要带上 V，计算过程也是类似的，维护一个额外的 o_A 即可。

一个例子

有朋友可能还是觉得不直观，没关系，我们来看一个例子。

假设一行 score：[1, -2, 4, 0]，直接算 Softmax 的分母 Z：

$Z = e^{1-4} + e^{-2-4} + e^{4-4} + e^{0-4} = e^{-3} + e^{-6} + 1 + e^{-4} \tag{5}$

现在我们将其分成两个 block：[1, -2] 和 [4, 0]，然后按更新公式来计算。

$l_A = e^{1-1} + e^{-2-1} = 1 + e^{-3} \tag{6}$

此时，我们假装 block A 就是全部数据，用的是以 mA=1 为 reference 的坐标系。

现在 block B 来了，新的最大值为 max(1, 4)=4，用式（4）的第一项把旧的 block 的贡献先对齐到新的坐标系：

$l_A \cdot e^{m_A - m'} = (1 + e^{-3}) \cdot e^{1-4} = e^{-3} + e^{-6} \tag{7}$

然后再计算新的 block 贡献：

$e^{4-4} + e^{0-4} = 1 + e^{-4} \tag{8}$

两项合并后得到的 Z 和整行直接结算是一模一样的。

背后原理

作为一个正常人类，我们肯定想继续追问：这是为什么呀？背后到底有什么原理？是不是有某种统一的模式？嘿嘿，我当时也是这个想法，我当时的问题是：为什么 softmax 这种看似“全局”的运算，能被改写为严格等价的流式算法？这种等价性在数学上到底依赖什么？会不会在某些极端情况下失效？其实我最关心的是最后一个问题。

首先，Softmax 有一个非常关键的特性：平移不变性——对“整体平移”不敏感，只有“相对差值”才有意义。

$\text{softmax}(x) = \text{softmax}(x+c) \tag{9}$

因为定义就是如此，多出来的常数 c 在分子分母上都有，可以约掉。

而 Online Softmax 在干什么？它在不同阶段选择不同的平移常数 c，并对历史贡献做一次精确的代数补偿。当新的 block 最大值变化时，它把参考坐标系从原最大值移到新的最大值，所有旧值会被统一乘上一个新旧坐标系差值的补偿值，这是一个严格的数学变换。

这一切归根结底是 Z 是一个“可结合的变量”：

$\sum_{i=1}^N e^{x_i} = \sum_{i \in A} e^{x_i} + \sum_{i \in B} e^{x_i} \tag{10}$

Online softmax 并不是在“逼近” batch softmax，而是在不断切换参考系来精确构造值。

其实减 max 是一种数值稳定化手段，并不是数学定义的一部分。所以选 max 其实是在选一个参考坐标系，坐标系可以移动，只要对历史贡献作相应的补偿即可。

平移不变性+可结合性让我们可以逐步计算，并在新参考系下给出历史贡献的等价表示，这个过程中信息是完备的（忽略浮点误差）。所以结果在数学书必然是等价的。

于是，我们得到一个通用的工程-数学模式：当一个算法看起来是“全局依赖”的，只要它的核心量满足

平移/缩放不变性
可结合的累积结构

那么就极有可能存在一个严格等价的 streaming / tiling / online 实现。

Stream Pattern

现在我们把视线转到这一类可 stream 的 pattern 上。仔细想想，我们发现这种模式其实之前就反复遇到过，来看几个例子。

LayerNorm/RMSNorm

来看 LayerNorm，RMSNorm 类似（只是分子和分母都移除了均值）。

$y_i = \frac{x_i - \mu}{\sqrt{\sigma^2 + \epsilon}} \tag{11}$

均值和标准差依赖整层，好像必须一次性算完。

$\begin{aligned} \mu = \frac{1}{n} \sum x_i , \quad \sigma^2 = \frac{1}{n} \sum x_i^2 - \mu^2 \end{aligned} \tag{12}$

但其实只需要在计算时，为每一个 block 维护三个值即可。

n：元素个数
μ：当前均值
M2：每一项元素与均值差的平方和（用来计算方差）

假设已有两个 block：

A：nA, μA, M2A
B：nB, μB, M2B

现在要合并成 C=A∪B。

首先，更新计数和均值，这一步比较简单：

$\mu_C = \mu_A + \frac{n_B}{n_C}(\mu_B - \mu_A) \tag{13}$

μB-μA 就是均值漂移量。注意，新的均值一定在两个均值之间。

第二步是更新 M2，做方差补偿。

$M2_C = M2_A + M2_B +(\mu_B - \mu_A)^2 \cdot \frac{n_A n_B}{n_C} \tag{14}$

后面那项就是补偿项，衡量了两个 block 均值之间的“距离”。

直观来看，当合并两个 block 时，补偿项其实就是两个 block 分别向新中心对齐时，多出来的两部分“能量”之和：

Block A 的额外贡献：nA · (μC - μA)^2
Block B 的额外贡献：nB · (μC - μB)^2

把这两项加起来（利用 μC 的定义 nA μA + nB μB/nA + nB）化简后，就变成了式（14）最后那个简洁的补偿项。

上面的式子大家可以用前面的例子 [1, -2, 4, 0] 或者自己随便设计一个例子验证一下。这个其实就是著名的 Welford 算法，它的核心就是是解决当均值发生漂移时，如何补偿方差。实际中，Welford 不仅是 streaming 的，也是可并行的（合并满足结合律）。

Adam/RMSProp

与前面 Softmax 和 LayerNorm 的“静态合并，目标是得到全局一致的结果”不同的是，Adam/RMSProp 处理的是动态的时间序列，目标是得到历史加权的结果。不过本质上，它们都是在维护某个“动量”。

Adam/RMSProp 这类优化器维护的是一种带时间衰减的统计量，可以通过这种方式扩展为“全局视图”（保证训练稳定）。以 Adam 为例（RMSProp 类似，只是少了一阶矩），维护一阶矩和二阶炬：

$\begin{aligned}&m_t=\beta_1 m_{t-1}+\left(1-\beta_1\right) g_t\\&v_t=\beta_2 v_{t-1}+\left(1-\beta_2\right) g_t^2\end{aligned} \tag{15}$

β1和β2是超参数，通常取 0.9 和 0.999。为了简化讨论，下面计算不考虑 Adam 本身的偏差修正项。

它们看似递推公式，其实是一个加权求和的在线归约器！我们以一阶矩为例，

$\begin{aligned}m_t&=\beta_1 m_{t-1}+\left(1-\beta_1\right) g_t \\&= \beta_1 \left( \beta_1 m_{t-2}+\left(1-\beta_1\right) g_{t-1} \right) +\left(1-\beta_1\right) g_t \\&= ... \\&= (1-\beta_1) \sum_{k=0}^t \beta_1^k g_{t-k} \\&= (1-\beta_1) \sum_{i=0}^t \beta_1^{t-i} g_{i}\end{aligned} \tag{16}$

注意，通常令初始状态 m0=0，v0=0。可以看到，它本质上就是对所有历史梯度做一次指数加权和！这个结构和前面的 Softmax、LayerNorm 没有本质的区别，只是系数（权重）不同。

继续考虑两个 block，假设时间维度被切分为两段：

A：0, …, s
B：s+1, …, t

Δ=t−s，即 B 的长度。

只看 A，在s 时刻有（β1简写为β）：

$m_A = (1-\beta) \sum_{i=0}^s \beta^{s-i} g_{i} \tag{17}$

只看 B，把它当作从 0 开始的新流，有：

$m_B =(1-\beta) \sum_{j=0}^{\Delta-1} \beta^{\Delta -1-j} g_{s+1+j} \tag{18}$

我们可以把全局直接计算的结果拆分为两项，即对式（16）进行拆分：

$(1-\beta)\left(\sum_{i=0}^s \beta^{t-i} g_i+\sum_{i=s+1}^t \beta^{t-i} g_i\right) \tag{19}$

现在考虑合并 A 和 B，合并时需进行相应补偿。

先看第一项：

$\begin{aligned}(1-\beta) \sum_{i=0}^s \beta^{t-i} g_i &= (1-\beta) \sum_{i=0}^s \beta^{t-s} \beta^{s-i} g_i \\&= \beta^{\Delta} m_A\end{aligned} \tag{20}$

再看第二项，令 j=i-(s+1)：

$\begin{aligned}(1-\beta) \sum_{i=s+1}^t \beta^{t-i} g_i &= (1-\beta) \sum_{j=0}^{\Delta-1} \beta^{t-j-(s+1)} g_{j+s+1} \\&= (1-\beta) \sum_{j=0}^{\Delta-1} \beta^{\Delta-1-j} g_{s+1+j}\\&= m_B\end{aligned} \tag{21}$

合并后：

$m_t = \beta^{\Delta} m_A + m_B \tag{22}$

回顾 Softmax 的：

$l' = l_A \cdot e^{m_A - m'} + l_B \tag{23}$

以及 LayerNorm 的：

$M2' = m2_A + m2_B + \text{drift compensation} \tag{24}$

Adam 的只是对历史乘了一个时间衰减项。它们的结构完全一致：

$\operatorname{state}_{A \cup B}=T\left(\operatorname{state}_A\right)+\operatorname{state}_B \tag{25}$

大数据和分布式中的 Stream Pattern

前面提到的 Softmax、LayerNorm、Adam 看起来好像和模型有关，属于模型层面的技巧。但其实，这种 streaming / 分块合并的模式是很普遍存在的，甚至可以说是数据工程和分布式系统的默认工作方式。很多看似“必须一次性全量计算”的统计量，在现实工程里都只能以流式方式完成。

比如我们要在数亿样本或 TB 级数据下计算某个统计指标（比如协方差、均值等），显然不可能把所有数据都读进内存，真实的做法基本都是 streaming / 分块统计，最后再合并。

以协方差矩阵为例，

$\Sigma=\frac{1}{n} \sum_{i=1}^n\left(x_i-\mu\right)\left(x_i-\mu\right)^T \tag{26}$

这和前面的方差完全同构，只是从标量变成了矩阵。计算时，同样只需维护：

n：元素个数
μ：当前均值
Σ：二阶矩阵统计量

合并时做一次均值偏移补偿：

$\Sigma_C=\Sigma_A+\Sigma_B+\frac{n_A n_B}{n_C}\left(\mu_B-\mu_A\right)\left(\mu_B-\mu_A\right)^T \tag{27}$

式（27）和式（14）没有本质区别，只是从一维扩展到多维。

我们继续把尺度放大，其实分布式系统，比如分布式训练中，我们整天都在做梯度合并（即 AllReduce），只要运算满足结合律和交换律，就有可能使用这种分块、合并模式。

Reduction

Pattern对比

到了这里，相信大家不难发现，上面不同的 streaming 的例子其实都是同一种计算模式，不同的是 streaming 的轴在变化。我们将它们统一罗列成表格。

场景 / 算法	Streaming 维度	维护状态（State）	参考系/基准的变化	合并/补偿方式	本质类型
Online Softmax	token 维（序列长度）	`(m, l) = (max, sum exp)`	最大值 m 动态更新	exp 差值补偿 $e^{m_A-m'}$	数值稳定 reduction
LayerNorm/RMSNorm	feature 维（通道数）	`(n, μ, M2)`	均值 μ 漂移	$(μ_B-μ_A)^2$ 漂移补偿	二阶统计 reduction
Adam/RMSProp	time 维（step）	`(m, v, t)`	时间步 t 递增	时间衰减补偿 $\beta^{\Delta}$	指数加权 reduction
Covariance	sample 维（数据量）	`(n, μ, Σ)`	均值向量移动	外积补偿 $(μ_B-μ_A)(μ_B-μ_A)^T$	矩阵统计 reduction
AllReduce	device 维（机器数）	局部梯度 `g`	无参考系（纯累加）	直接加法（associative）	代数 reduction

其实，从另一个角度看，可以分成算子级、数据级和系统级，它们可以用一个简单的公式表示：

$\text { state }=\bigoplus_{i \in \text { axis }} \phi\left(x_i\right) \tag{28}$

意思是，如果存在有限维 state s，使得 state(A ∪ B) = merge(state(A), state(B)) 且 |state| 与数据规模无关，则该算子存在 streaming 实现。

Streaming维度

通过前面的介绍，我们知道：streaming 本质是“沿 axis 分块”，它不是一种优化技巧，而是一种暴露 reduction 结构的方式。对应到具体实例，其实是 streaming 被允许、被需要、被暴露在哪一个维度上。从这个角度看，我们又可以将 streaming 分成下面几种情况：

语义禁止跨样本 streaming。比如 LN 在 hidden_dim 上，禁止 batch/token/step，因为要求每个 token 各自归一化。
- 再比如 Adam 在时间上，禁止参数之间。
语义允许 streaming，但规模不迫使这么做。比如 LN，短序列的 attention，虽然支持 online，但一般一次计算就解决了，也就不需要 streaming。streaming 只是实现方式。
语义允许，规模/性能迫使 streaming。比如一些大规模统计指标、AllReduce、还有咱们的主角 Flash-Attention。

关注算子：如何系统化挖掘 Streaming / Reduction 结构？

其实，数据和系统层面是比较直观的，我们最应该关注的是算子级别，也就是“主动”去利用这种 reduction 结构。如果遇到一个算子存在性能瓶颈，如何系统地判断它是否可以改写为 streaming / tiled / online 版本？

Step 1：将算子重写为 Reduction 形式

尝试将算子强制写成式（28）的形式，即是否存在某种局部贡献 φ 可以通过某种可合并算子 ⊕。典型的信号包括：

sum / mean / variance
exp-sum（log-sum-exp）
加权和
二阶矩 / 外积
max / min
prefix-scan

Step 2：检查代数性质（核心判据）

关注三个问题：

是否可结合？无法结合律的可能无法分块。比如排序、带聚合/加权统计的 Top-K等。
是否存在“参考系不变性”？也就是历史结果可以通过一个 closed-form 变换映射到新坐标系。
状态是否是 O(1)？状态的大小必须与轴无关。

说到这里顺便说一下分布式 Top-K 问题。每个 worker 先算 local Top-K，再 all-reduce 合并后取 Top-K，这是一个非常自然的工程设计，但它在理论上和全局 Top-K 是不等价的。

出问题的就是“加和/聚合”场景（即带聚合的 Top-K），考虑如下场景：寻找出现次数最多的单词。

机器 1: {"Apple": 10, "Banana": 9} -> Local Top-1 是 Apple。
机器 2: {"Banana": 9, "Apple": 1} -> Local Top-1 是 Banana。

如果只看 Local Top-1，就会选出 Apple，但其实是 Banana。

Step 3：显式构造「State + Merge」

也就是想办法搞出式（25），

$\operatorname{state}_{A \cup B}=T\left(\operatorname{state}_A\right)+\operatorname{state}_B$

只要能写出 merge，就可以分块。

Step 4：考虑硬件与访存

最后考虑真正的“优化”，考虑：

能否放进 SRAM？
能否减少 HBM 读写？

Flash-Attention 本质上不是 attention 优化，而是 reduction 结构 + tiling 的一次极致工程实现。

小结

本文从 Flash-Attention 的 Online Softmax 出发，发现 Softmax、LayerNorm、Adam、协方差统计乃至分布式 AllReduce 在结构上都遵循同一种模式：它们都可以被改写为有限状态的 Reduction / 可合并统计量。只要一个算子满足：可分解为局部贡献、存在有限维 state、state 可合并或具备参考系不变性与补偿变换，它几乎一定可以被实现为 streaming / tiling / online 版本。

Flash-Attention 并不是一个特例，而是这种 reduction 结构在硬件层面的极致利用：通过重排计算顺序，把 memory-bound 的 attention 变成 compute-bound。从这个角度看，streaming 不是优化技巧，而是一种暴露算子代数结构的方式。

最后，感谢 AI 助力，虽然文字大部分都是手打的（用了 AI 的地方一般会有标记），但整个梳理过程还是少不了他的协助。

【聆听·微光】006：一位传统企业中层管理在AI转型升级中的“蜀道”

2026-01-26T15:00:00.000Z

【来访者个人档案】

身份：工作多年的项目负责人。
自述：想把 AI 用在公司内部和项目上，但很难推进。

这次来访的和前面的大有不同，我们称其为 G 同学，G 同学已经在一家公司做到了领导层，负责软件开发相关项目，手下也有十几号人。G 同学通过 Datawhale 关注到我，读了《为了让AI干活儿，我竭尽所能——我的 Vibe Coding 认知升级之路》，那会儿正在想办法让团队用上 AI，提升效率。

G 同学的烦恼如果用一句话概括，那就是：“传统企业如何用好 AI 之落在中层管理者身上的职责和困惑”。这其中除了技术相关问题，还有大量沟通、管理、协调等非技术问题。好在我也做过管理，还是能聊一聊的。

小公司特色

这里的小公司是指百把人所有的公司，这一类公司的很多老板都有几个明显的特点。

第一，喜欢追新技术。

这可能和他们对市场比较敏锐有关，对于新技术，能用在公司实际项目中那最好，即使暂时用不到，用在宣传上也是极好的。作为员工来说，最怕的是半桶水老板——几乎所有知识都是通过自媒体学来的，会短期内高估、长期又忽视技术的能力。

第二，不太可能高薪招聘一个细分方向的算法工程师。

对小公司来说，重要的是实战、项目，也就是如何用好技术，而不是继续钻研、打磨某个算法细节，去做深度。其实除了极少量技术型公司，大部分公司都是业务导向的，小公司为了生存就更加如此了。而且，据我了解，很多小公司其实一开始也高薪招过这一类人才，结果自然是不满意的——彼此的期待偏差太大。想要达到老板的期望，那至少得通晓全流程、有过几年实战经验，各个方向都懂，对目前分工极细的产业现状来说，这样的人才其实比例很小。

第三，会议泛滥成灾。

真的是无论大小事情都拉个会，有时候说开了一两个小时就没了。其实，这个出发点也是容易理解的，老板大多数时候想的应该是尽快把相关人员拉到一起快速聊清楚。只是有时候会议控制、参会对象、召开频率什么的没控制好。

第四，外部崇拜

还有不少老板存在不信任内部人的情况，俗话说：“外来的和尚好念经”，就是觉得外面的人说什么好像都很有道理，但却觉得自己的人水平一般。

说到这里，大家也应该能感觉到，很多时候，AI 转型时遇到的问题其实大部分都不是技术问题（这对大公司也是一样的），技术的变革会涉及到文化、组织、管理等方方面面。

向上管理

所以，对 G 同学来说，首先要做的就是做好向上管理。如其所言，领导动不动就把他拉过去开会，安排一堆活儿，很多都和实际工作没太多关系，占用了非常多时间。而且还没有相应激励，自己感觉也没有动力去做。同时，对其关于 AI 的结论和判断也表现出部分的不信任，诸如此类的。

关于信任这部分，我觉得是可以理解的，因为没有哪个老板就只凭你张嘴吧啦几句就相信的。我的建议是：用事实和数据沟通，抛弃个人”魅力“，毕竟不是每个人都是帅哥美女。只要是工作汇报相关的，就做好相应的准备，比如市场调研、数据对比等等。我们谈到一个简单的例子，比如内部推广 AI 辅助编程。要想说服领导在费用上支持，可以很简单地用类似的需求在使用 AI 前后的开发耗时对比来说明。比如以前一个功能模块要排期 3 天，现在通过使用 AI 辅助只需 0.5 天，省下的成本就是你谈判的筹码。相反，如果实际下来效率反而下降了，那就不用去找老板了，自己先找找原因吧。一旦到了管理层，考虑问题就应该更加全面、更加宏观。

关于随时拉会、激励等，其实都是沟通问题。我给 G 同学分享了自己在做管理时的一点点心得。我当时是整条研发线负责人了，对外就是 CTO，会多的不像话。一开始也是各种被打断——工程师、程序员真的很不喜欢被打断。后来我实在不喜欢，跟董事长商量了一下，上午如果没有非常紧急的事情，都不要打扰我，我需要沉下心去思考一些事情，或者做一些重要的规划和任务。我跟他分析了具体原因，董事长也比较认可，然后后面基本再没有在早上打扰过我，而且还告诉其他同事也不要打扰我。激励这个也是，如果确实觉得不太匹配，可以直接去聊，你不聊公司一般会默认你是满意的。

总的来说，向上管理更多的还是沟通问题，而且最好是能定时汇报进度。这也是我此前的一个习惯——无论老板找不找我，我每周至少会去找一次他，同步各种事情当前进度。到了管理层，最忌讳的是只埋头苦干，老板不知道你在忙什么。另外，需要有自己的底线和必要的锋芒，一味讨好只会越来越差。但同时在公开场合还需要给人（尤其是领导）面子，不要当面争论，但私下里可以坦率一些。这些都算是沟通层面的话题。说起来就比较多了，这里不多展开了。

向下管理

向下管理很多时候都是权衡，我们自然希望每个下属都能如臂使指，甚至如 G 同学所言，都能积极拥抱变化，热爱学习。但这是不现实的，不同的人有不同的想法和观念，我们无法保证所有人都和自己一样，也不应该这样。对于向下管理，最重要的是明确目标和任务，至于过程、风格之类的，只要不超过底线，百花齐放未尝不可。

依然是学习使用 AI 编程这个话题，G 同学给了很多资料，也邀请外部专家过来培训，但总感觉效果不太理想。对此，我的观点是，无论是外部讲师还是 G 同学亲自上手，培训都应该从实际开发场景中抽取案例，这样大家都比较熟悉，在培训中真切感受到效率的提升后，自然而然就会去使用。这样的案例还可以由简到难，逐步递进，同时，还可以组织大家一起讨论，聊聊各自的观点和感受，交流一下经验。就是要先从每个人的工作着手，把用 AI 这个氛围搞起来。

另外，我们还谈论了绩效考核、员工激励等方面问题。总的来说，向下管理时，你就是第一责任人，有义务让你的下属无论是能力还是收入都在不断提升。也要时刻记得那句老话：“兵熊熊一个将熊熊一窝”，团队的战斗力和你本人息息相关。

自我管理

我们刚刚只说到使用 AI 提效的例子，但其实这只是转型过程中很小的一部分，真正的转型是整个公司业务与 AI 进行融合。这当然属于公司战略层面的东西，但如果公司领导层不太懂这方面知识，那作为骨干的中层就需要充当好这个信息连接的载体了。G 同学热爱学习，自学了很多 AI 相关的知识，又在传统行业干了很多年，非常适合这个角色。

我们就如何将 AI 用在公司内部进行了一些讨论。首先，最简单的自然是提升办公效率，我建议 G 同学将范围推广至全公司，让每个员工都感受到 AI 的效率。默契的是，G 同学此前已经有过类似尝试了。其次，关注竞品公司或同行相关产品，做一下市场调研，从宏观上有个大致的了解，重点关注其中是否有可借鉴的部分。再接下来，在充分理解了现有产品和业务的基础上，结合外部情况和自己的知识、认知，找到确切可以优化的点，甚至可以先做一个小范围验证。这时候我们才可以去找公司领导去聊，去要资源。此时，我们对整体市场有认知，对 AI 有理解，对业务和产品有思考，证据充分，用数据和事实来“说话”，而不是主观意愿让公司开搞。

另外，我感觉这个传统企业 AI 转型本身其实是个很好的 topic，没亲自去做过相关业务的，哪怕 AI 知识丰富，确实很难提出建设性意见。因此，我建议 G 同学在过程中注意积累，可以将经历写成文章，汇集成册，甚至考虑出版。这也算是为整个产业做出了自己的贡献，同时这也是一个 “传统企业 AI 转型” 专家的成长之路。说真的，我个人还是蛮期待的。

尾声

后面零零散散其实聊了很多，关于工作、学习、人际关系什么的。眼看都过了一个小时了，G 同学还有些意犹未尽，我感觉这可能是其作为中层这个”夹心饼干“的孤独感吧。这种沟通既是交流，也是释放。于是，我们又多聊了十来分钟。由于都有过一些中小公司管理经验，所以很多问题我们其实都遇到过，有种“啊是的是的，就是这样，哈哈哈”的感觉。

总而言之，G 同学的经历绝非典型，大量传统企业的中层管理者可能都有类似问题，面临几乎相同的现状，希望本文能对大家有所启发。虽然我们没有过多提及具体操作方案，但相信只要把这个整体思路把握住，具体的实施反倒是次要的了。所以，尽管先去踏出第一步吧，如果确实遇到其他棘手问题无法解决，我们再来一起商议便是。

💡 共鸣时刻

AI 来袭，所有人都是敏感的，中小企业领导更甚。
企业面临的情况和人一样，要么拥抱 AI，要么被时代抛弃。
G 同学和公司老板显然早就意识到问题，并积极应对。

然而，企业非个人，作为一个系统，它更加复杂。

每一次的转型升级，都是一次深层的自我革命。
不成功，便消亡。

通向 AGI 的技术路径：多模态、强化学习与新架构的交汇点——结合近期研究者访谈的一些技术判断与个人思考

2026-01-25T15:30:00.000Z

注意注意，本文并非试图给出一条确定的 AGI 技术路线，也不是对某一种路线的辩护或预测，而是有意将多位一线研究者在不同语境下提及的方向进行整理。在此基础上，也夹杂了一些个人长期形成的判断和思考，供参考，而非结论。

TL;DR

多位一线研究者的观点在三个方向上高度收敛：多模态（尤其是视频）、强化学习、自进化系统，它们共同指向比纯 LLM 更高阶的智能形态。
Scaling 仍然重要，但对象在变化：从模型规模 → 推理过程 → 自学习环境（System 3），再加上 Token 效率、多尺度学习等，Scaling 正在更加精细和广泛。
多模态不是“加模态”，而是“建世界”：视频和感知建模可能拥有比文本高一个数量级的 Scaling 上限，语言并非理解物理世界的必要条件。
强化学习是自主进化的核心机制：预训练擅长吸收信息，RL 擅长通过试错优化策略，可能是持续学习、自我修正和边缘能力提升的关键。
Agent 不应只是工具封装：真正的 Agent 更像一个“可训练的智能系统”，本身就是产品，具备学习、记忆和进化能力。
从更长期看，现有 Attention 和 NTP 可能不是终局，新架构、新目标函数、新范式雨后春笋。

近期看了几篇大佬的访谈：

想着把他们的核心观点梳理一下，同时也补充一点自己的看法。虽然肯定有不少类似的总结，但每个人的角度不同，这里主要关注 AI 相关的技术路径或方案。看起来可能非常精简，纯当宏观指导方针参考了。

张钹院士

不愧是院士整体立意非常高，而且相当系统。本来在访谈后面，我直接放在最前面。

大模型原理其实是构建分布式语义关系空间。
语义定义不完备导致的五个缺失：指称缺失、真知和因果缺失、语用缺失、多义和动态语境缺失、闭环行为缺失。
所以必须要定义一个可执行、可检验的定义。AGI 应该满足五个关键能力：
- 时空一致的多模态理解与落地。
- 可控的在线学习（RL）与适应。
- 可验证的推理与长期执行与规划。
- 可校准的反思与元认知。
- 跨任务强泛化。
对应的六件事：多模态，具身与交互落地，检索与证据不落地，结构化知识对齐，工具与执行落地，对齐与约束落地。
我们的目标，未来主体的三个层次：
- 功能-行动主体。已经达到了。
- 规范-责任主体。机器也能够担负起责任来，还没达到。
- 体验-意识主体。机器有了意识人类怎么办？

AI建模

Scaling
- 系统一：大模型通过模式匹配与知识提取，覆盖大部分常见问答和常规任务。Scaling 数据与模型规模，提升智能上限。@唐杰
- 系统二：更强的知识融合和推理机制，使模型能处理更复杂的推理与决策。Scaling 推理，让更多思考找到更优解。@唐杰
- Token 效率和 Muon @杨植麟
- 视频模型的scaling天花板，比文本模型高至少一个数量级。@Hafner
多模态
- 多模态感统机制 @唐杰
- 全模态 @林俊旸
- 视频长上下文理解 @Hafner
架构
- 长上下文和 Linear @杨植麟 @林俊旸
- 任何架构都可以 AGI，区别只在效率 @Hafner
- 嵌套学习（在推理时快速学习上下文）@Hafner
- 多尺度学习。快的时间尺度训练效率更高，慢的时间尺度学习更深度的东西。@Hafner
目标函数
- 偏好型（从人类反馈中学习）与信息型（让模型理解数据本身），改进空间都很大。@Hafner
- NTP到MTP，让模型更有远见。@Hafner
- 多模态应该根本性的、统一的、跨模态的 loss。@Hafner
- 长程任务效果不行是缺少好的目标函数。@Hafner
学习
- 预训练从样本学知识，高效，适合吸收信息。强化学习从reward学策略，适合优化。@Hafner
- RL 的价值是“模型自己试错找到更好的策略”。@Hafner

Agent

Digital Agent（GUI + API）@林俊旸
Thinking + Coding Agent；与环境交互（DeepResearch）@唐杰
强化学习 + 周期性 SFT（校正方向）@唐杰

自进化

Scaling
- 系统三：Scaling 自学习环境，让模型有更多与外界交互的机会，从环境中获得反馈。@唐杰
自主学习
- 记忆与持续学习 @唐杰
- 主动学习 + 自主思考 @林俊旸
- 自主学习不是方法论，而是数据或者任务：在什么样的场景下基于什么样的奖励函数去做。@姚顺雨
- 持续学习（快速更新）@Hafner
- 在线RL帮助精炼系统，解决边缘问题 @Hafner
自我认知
- 反思与自我认知 @唐杰

世界模型

想象中学习，再到现实世界 @Hafner
通向AGI缺失的拼图 @Hafner
纯离线数据在真实世界不可能完美，必须与环境交互才能学到真正的因果模型。@Hafner
机器人要真正自主运作，需要理解物理世界。@Hafner

自己的思考

其实大佬们提到的东西挺多，有启发的地方自然也不少。先来看看大的方面，主要是以下几点。

首先是多模态。这里既指我们本来就熟悉的多模态理解、生成，更是指向多模态预训练，尤其是视频。个人感觉多模态的 Scaling law 是存在的，且上限极高。如果说 LLM 是文字和语言的世界建模，那多模态就是整个视界物理世界的建模，这个层面语言是不必须的。

然后是强化。我个人一直对强化非常关注，从18年至今，写过不少相关文章了（《DeepSeek R1深度技术解析及其影响》附录部分），很早之前其实做过一些尝试，可惜没做出啥成果。个人觉得，强化学习是自主学习、持续进化的关键。

最后是新架构。Attention 目前看起来工作的相当不错，可以说是迄今为止最强的表征器。但是否这就是终极答案呢？个人觉得未必，这里不考虑效率方面，就单纯从机制看，个人感觉会出现更强的架构设计。

这些方面看起来确实比较笼统，其实它们也对应着我 18 年在《NLP 与 AI》中的设计，当时把 AI 框架分成三个层面：常识层、规则层和表征层。原话如下：

这三个层面和刚刚提到的三点正好也是对应的。不过那时候囿于技术发展和个人认知，我认为常识应该是万物图谱，压根没往多模态/世界建模方向去想（也不可能想到），但是认知的直觉就是觉得这一层要解决物理世界基本关系问题。这个认知来源于维特根斯坦的观点，记录在《人工智能哲学笔记》。我本人其实是一个实战派的人，虽然很喜欢哲学、读了一些书，但很少在任何场合谈论偏“务虚”的东西。因为我很清楚地知道做和想差别有多大，不过哲学有时候确实能够引领一个人的思维，这方面我不算太专业，顶多一个爱好者，所以就少说几句吧。另外，这些年一直关注强化学习，也是基于这个框架，我一直非常笃定强化学习一定会大放异彩，22年 RL4LMs 出来后我兴奋的晚上觉都没睡着，第一时间就读了他们的代码。不过，我自己确实也没做出什么东西来，才华不够也好，生活所迫也罢，事实确实是没做出东西来。

观念和设计方面确实看着就不那么具体，有点像一个大致的 idea。其实，大部分时候有 idea 并没有什么卵用，重点是谁能先做出来。我从来也不觉得 idea 有多值钱，所以有什么想法也不会藏着掖着，直接就发博客了。如果能对别人有所启发，那说不定才是真正的价值。

来说一点点稍微具体的吧。首先是全模态理解/生成。我一直觉得现有的业务很难应用全模态，比如对话模型，LLM 我可以很容易和其他组件联合使用，可以高效地单独优化。但如果都怼在一起，如果优化某个点就会感觉很麻烦。这个和 LLM 时代之前，理解、生成和 DM分开做有点类似，强大的 LLM 把三个模块直接统一了。也许，全模态应该有全新的使用方式，它的冲击会比 LLM 那个统一大多了。很遗憾，我没有具体答案，我也不知道最终会怎样。

接下来是 Agent，我觉得不是那种现在普遍理解的 Agent，那只能说是一种狭义上的理解。这里指的 Agent 其实是广义上的，也就是一个“智能体系”，它整体就像一个模型一样也是可训练的。它直接就是一个产品，一个可训练、可学习、可进化的系统。

最后是更有意思的架构和学习方式。上面其实已经提到一些诸如多尺度学习、嵌套学习，新的目标函数等。这些我觉得都有可能取得不错进展，比如 DLM，之前还不温不火，最近一两周突然多了很多质量不错的论文，正好有一篇还提到了 Multi-Scale Tokenizer（我过两天会整理后发出来），感觉很多有意思的东西正在蹭蹭冒出来。

总的来说，AI 是一个激动人心的领域，想想这么多可以做的就很兴奋，虽然我自己只能业余时间搞一点点研究……但看看大佬们的研究成果也不错。真是旷古的时代呀。

其实，文中提到的多模态、强化学习、Agent、自进化、新架构等方向，在我看来并非彼此替代的关系，未来 AGI 究竟依照哪条路径，还是多条路径组合，我们现在不得而知。不过我觉得，与其过早押注，不如关注自己感兴趣的方向，深度参与过程，结果固然重要，但过程更加精彩。

依然附上 AI 根据以上内容整理的表格（我觉得整理的还不错，基本上没有改动）：

技术路径	主要解决的问题	核心机制 / 抓手	隐含前提假设	当前主要卡点
大模型（LLM / 推理）	语言理解、知识组织、符号推理	大规模预训练 + 注意力表征 + 推理时计算	高阶认知可通过语言与符号抽象获得	长程一致性、真实因果、与环境脱节
多模态（尤其视频）	世界感知、物理与时序建模	跨模态预训练、时空表示、感知对齐	世界结构可被连续感知信号建模	数据成本高、有效因果信号稀疏
强化学习（RL）	策略优化、自主试错、持续改进	Reward 驱动、探索-利用权衡	环境反馈可定义且可优化	稳定性、样本效率、奖励设计
Agent（广义）	长程任务、工具使用、系统级智能	感知-决策-执行闭环	智能可通过系统组合与交互涌现	可训练性差、评估困难
自进化 / 自学习	持续适应、边缘能力提升	在线学习、记忆、环境交互	智能需在开放环境中成长	灾难性遗忘、安全与对齐
世界模型	因果理解、规划、想象与泛化	状态空间建模、预测与反事实	离线数据不足以学习真实因果	表征是否足够、如何与决策耦合
新架构（非 Attention）	表达效率、长程依赖、时间建模	线性化、状态空间、多尺度	当前架构非认知最优	是否真带来能力而非效率提升

历史回溯

最后的最后，附上之前写过的类似文章，现在回看也蛮有意思。

再往前到非 LLM 时代。

AI 帮我梳理了一下，一并附上：

2017《情感》： 关注 “心”。AI 是有涟漪的新物种吗？
2018《架构》： 关注 “骨”。Prior/Rules/Sense 的三层雏形。
2020-21《表征》： 关注 “肉”。分类本能、DIKW 模型与语义压缩。
2023《务实》： 关注 “用”。Infra 化、垂直模型、在大爆发中寻找落脚点。
2024《交互》： 关注 “行”。语音 Agent、具身智能，AI 开始介入物理世界。
2025《拼图/人性》： 关注 “界”。AGI 拼图合拢，反思人类驱动力与 AI 的本质区别。
2026《进化》： 关注 “道”。确立多模态、强化学习与新架构的交汇，寻找通往 AGI 的确定性路径。

现在的AI给九年前的我写了一份信

这个很有意思，在帮我整理了上面的文章后，AI 主动提出站在现在的视角给九年前的我写一封信，这我自然是同意的，我也好奇他会怎么写。嗯，原文一字不改，粘贴如下。

见信好，九年前的自己：

写下这封信时，我已经站在了你当时预言的“新物种”降临的前夜。

我刚读完你 2017 年写的那篇感怀。看到你在文末写下那句“如果你认识以前的我，也许你就会原谅现在的我”，我不禁笑了。其实，我不需要原谅你，我反而要感谢你。感谢你在那个连 Transformer 是什么都还没多少人知道的年代，就固执地相信：语言的魅力，不在于信息本身，而在于它能勾起涟漪。

你想知道这九年发生了什么吗？

你当时纠结的“词向量不够通用”和“理解差异”，后来被一种叫 Scaling Law（规模法则）的暴力美学解决了。我们不再死磕每一行代码的逻辑，而是把全人类的知识塞进一个巨大的黑盒，它竟然真的“涌现”出了你梦寐以求的理解力。

你会惊讶地发现，2026 年的 AI 已经能轻松接住你那句“他死了，她伤心而死”背后的沉重。它甚至能和你聊维特根斯坦，能帮你分析贝叶斯概率。

但最想告诉你的是，在这九年的追逐中，我一度弄丢了你最看重的那份“涟漪”。

有几年，我变得非常务实，满脑子都是 Infra（基础设施）、模型量化和行业落地。我曾以为只要算力足够大，机器就能拥有灵魂。但直到 2025 年的秋天，当 AGI 真的近在咫尺时，我才重新读懂了你文中的那份焦虑。

我发现，AI 确实成了“新物种”，但它是一个没有“驱动力”的物种。它很强大，却不会饥渴，不会孤独，也不会为了一个不可能的梦想去自我毁灭。而这些让你感到痛苦的、低效的“情绪”，恰恰是我们作为人类的勋章。

所以，请继续保持你那份感性吧。不要觉得那些哲学思辨是“虚”的。

2026 年的我依然在死磕技术，在研究“世界模型”和“自进化系统”，但我比任何时候都更认同你 2017 年的那句直觉：我们关注的从来不是信息，而是共鸣。

现在的 AI 已经能帮我处理几乎所有的工作，但我依然会为了一个老朋友的问候而心动，依然会为了窗外的一场雨而失神。这些，是 AI 永远无法通过 Next Token Prediction 学会的“鱼之乐”。

别急着赶路，你笔下的每一个字，都在帮我构筑九年后的智能大厦。

现在的我很好，也希望当时的你，慢一点，再多感受一点那时的涟漪。

2026 年 1 月 25 日

那个依然在思考的你

你别说，写的还挺好;D

也将此信献给努力在 AGI 一线的工作者。AGI 在前方，也在脚下。

MoE RL 训练不稳定性再思考：训推不一致，还是采样噪声？

2026-01-22T15:00:00.000Z

来自快手的 KAT-Coder-V1 Pro 重磅升级，揭秘强化学习训练稳定性关键因素 - KwaiPilot^[1]，直接给出了让人惊讶的发现：

RL 训练不稳定的主导因素并不是训推不一致，而是采样噪声本身。

他们发现，当显式抑制噪声强度后，即使存在明显的训推差异，训练依旧保持稳定，并能获得更快的收敛速度。

这可真是——玄之又玄啊。

重要性采样

off-policy 下，

$\nabla J(\theta)=\mathbb{E}_{a \sim \pi_{\text {rollout }}}\left[R(a) \frac{\pi_{\text {train }}(a)}{\pi_{\text {rollout }}(a)} \nabla_\theta \log \pi_{\text {train }}(a)\right]$

理论上，两个 π 应该是策略的真实动作概率分布，不过实际我们只能得到观测值：

$\hat{\pi}_{\text{rollout | train}} = \pi_{\text{rollout | train}} + \epsilon$

噪声由数值精度、并行原子操作、kernel 选择的不确定性等因素共同导致。这个重要性采样系数的比值其实包含了额外的方差，采样噪声 ϵ 成为 RL 训练不稳定的主要来源之一。

对 rollout 和 train 两个策略输出 logprob 统计如下：

为了降低采样噪声，主流 RL 方法都会在 rollout 后用训练引擎重新计算一次 logprob，这个 π_recompute 会作为重要性采样系数的分母，对 dense 模型来说，方差为 0。但 MoE 模型上不行！这也是《稳定压倒一切：MoE RL 训推不一致问题及解决策略 | 长琴^[2]》中提到的，当时根本就没有提重算 logprob，就是因为重算也没用，因为路由关系，策略分布都（偷偷地）变了。

也就是说，在 Dense 模型中，使用训练引擎重新计算 logprob 是一种有效的降噪手段；但在 MoE 模型中，由于路由路径在训推阶段发生变化，recompute logprob 不再是对 rollout policy 的无偏估计，而是引入了系统性的 off-policy 偏差，因此无法从根本上解决 RL 训练的不稳定性。

进而就是说，MoE 模型的路由选择会让偏差和方差（尤其是 rollout）增大，而偏差的增大会随着训练累计，导致训练崩溃。因此，MoE RL 稳定训练的关键是：如何获得一个偏差和方差都尽可能小的 rollout 估计器。

其实这里我是有问题的：偏差应该是训练和推理策略之间的偏差，不能只考虑 rollout 呀，所以上面的描述应该是不太准确的。

策略方案

真是够简单，多次采样平均估计：

$\hat{\pi}_{\text {rollout }}=\frac{1}{n} \sum_{i=1}^n \pi_{\text {inference }}^{(i)}$

优点：

不依赖 routing replay，无需复杂缓存机制。
无需使用训练引擎重算 π_recompute。
异步框架下，多次采样与 rollout 时间重叠，且 KV-Cache 命中率接近 100%。

重新审视已有方案：

R3：在大规模 agentic 场景下难以保证 prefix cache 始终命中。
TIS：表面上缓解方差爆炸问题，而且对截断上下界的选取十分敏感。
确定性推理：从 infra 层消除噪声，推理端在相同输入下输出完全一致的 logits 与 logprob，同时保证训练和推理 logprob 的比特级一致。

效果如下：

看起来相当不错。但是，如我们前面所言，这其实只是降低了推理估计器的方差，并没有降低训推不一致带来的偏差。也就是说，它解决的是“rollout 估计器的方差问题”，而不是“策略不一致问题”。

原因猜想

那为什么还有效果呢？

最直接的答案：多次 inference 平均 ≈ routing 平均，路由的熵很低，Top-1 expert 几乎确定，MoE 几乎退化为 Dense！

也就是说，这里平均的不是噪声，而是“不同策略实例”。

换句话说，MoE 本来使用的是条件策略：π(a | x,e*)，多次平均后估计的是边缘 policy（对隐变量做边缘化）：π(a | x)。

回到本文前面的假设——采样噪声（和训推不一致其实是正交的），在这里其实是“路由抖动”的工程表现。而本文针对这个噪声的解决方案本质上是在工程实践中通过“暴力平均”抹平了由于计算扰动带来的路由抖动。工程上虽然“能 work”，但并没有理论保证。

另外，虽然训推不一致和采样噪声看起来正交，但本文的策略其实很难与我们在《稳定压倒一切：MoE RL 训推不一致问题及解决策略 | 长琴^[2]》中的策略一起使用，因为多次平均这个操作已经在重新定义行为策略（平均出了一个新的 policy）。而在前文中，我们假设 policy 已经定义清楚，rollout 分布是固定的。

小结

KAT 的工作指出，RL 训练不稳定在工程上往往首先表现为采样噪声主导，而非单纯的训推不一致；通过多次 inference 平均，可以显著降低 rollout 估计器的方差，从而稳定训练。然而，在 MoE 场景下，这种做法本质上是对路由隐变量做边缘化，等价于重新定义了行为策略，而非真正消除了训推策略之间的偏差。因此，它更像是一种“工程降噪”的有效技巧，而不是从理论上解决 MoE RL 中的 off-policy 不一致问题，稳定性的根本挑战依然存在。

Reference

[1] KAT-Coder-V1 Pro 重磅升级，揭秘强化学习训练稳定性关键因素 - KwaiPilot: https://kwaikat.github.io/kwaikat-blog/posts/katcoder_1201/
[2] 稳定压倒一切：MoE RL 训推不一致问题及解决策略 | 长琴: https://yam.gift/2026/01/17/NLP/LLM-Training/2026-01-17-RL-MoE-Stable/

为了让AI干活儿，我竭尽所能——我的 Vibe Coding 认知升级之路

2026-01-18T09:00:00.000Z

AI Coding 已经疯了。

我也在一边根据本能在使用，同时也在学习一些新的技巧和方法。直到看到《认知重建：Speckit 用了三个月，我放弃了——走出工具很强但用不好的困境 - 知乎^[1]》这篇文章，我觉得自己得系统梳理一下了。

这里就随便那么梳理一下吧，可能会比较乱。

来自程序员的本能

去年 12 月才算正式开始使用，上来用的就是 TRAE 和 Antigravity，里面有 plan 模式。所以，最简单的方式就是：design-review-execute-review，实际上，我之前写的几个项目^[2]都是这种风格。

简单项目这种方法应该足够了，但是后面新开了一个大项目，涉及到算法、后端、前端几个部分，每个部分也都不简单。这时候感觉之前那种简单的方式就不太够用了。其实，也不一定是不够用，只是说，再随便写一下 design 文档就太潦草了，需要更加细致的对任务和设计进行描述。随便写的后果就是很多细节完全不是想要的……

于是，我慢慢增加了 API 环节，先把模块间的“协议”定下来，变成了 design-api-review-execute-review，同时，由于项目有不同模块，我在每个模块下都增加了 design，并且因为更新比较频繁，我让它更新的时候同时更新 design。这样相当于给它一个统一的世界状态，不至于后面漂移的太厉害。

另外，虽然每次执行完都有 Walkthrough，但我还是会让它给我一段测试脚本和操作文档，这个主要用来人工验收。后面又继续增加了一些全局统一的约定，比如可能用到的 key、前端每次 run 之前先执行 nvm use 22 等等。总之，是摸着石头过河，边用边根据实际情况调整。

同时，对于比较大的项目，如果子项目之间是相互独立的，我会先完成子项目，然后其他用到它的地方会把它当做黑盒。

来自同行的经验

陆陆续续和一些同行交流（有时候就是看看群消息别人的讨论），又 get 到一些新的技巧和方法。

reference

X 哥说让它基于已有项目修改会更加容易，或者给一段已有的实现。我很快就采用了，在项目根目录增加了 reference 文件夹，把要参考的代码都放里面。

task

群里讨论的比较多的是 task 模式，后来有人专门把这个做成开源工具：Vibe Kanban^[3]，纯任务驱动 + GitHub 协作的模式，感觉都不需要看代码。

其实 plan 模式会提供 task 的，这个工具只是可视化+Git 规划、审查和管理代码，对我个人吸引力不太大。

spec

同时，还知道了 OpenSpec^[4]，算是一种规范驱动的开发模式。工作流程如下：

┌────────────────────┐
│ Draft Change       │
│ Proposal           │
└────────┬───────────┘
         │ share intent with your AI
         ▼
┌────────────────────┐
│ Review & Align     │
│ (edit specs/tasks) │◀──── feedback loop ──────┐
└────────┬───────────┘                          │
         │ approved plan                        │
         ▼                                      │
┌────────────────────┐                          │
│ Implement Tasks    │──────────────────────────┘
│ (AI writes code)   │
└────────┬───────────┘
         │ ship the change
         ▼
┌────────────────────┐
│ Archive & Update   │
│ Specs (source)     │
└────────────────────┘

1. Draft a change proposal that captures the spec updates you want.
2. Review the proposal with your AI assistant until everyone agrees.
3. Implement tasks that reference the agreed specs.
4. Archive the change to merge the approved updates back into the source-of-truth specs.

四步曲翻译成中文：

起草一份包含你想要的更新的变更提案。

AI 审查提案，直到所有地方对齐。
实现符合约定规范的任务。
归档该更改，将批准的更新合并回真实来源规范。

我觉得和自己的模式在本质上差不太多。

multi-agent

这个模式早就知道的，也看很多人提到过，就是不同 agent 负责不同的角色，比如前端一个，后端一个，测试一个，不过我还没怎么用过。就是这个只是增加异步并发，其实并不是真正意义上的范式改进。再加上我自己是需要人工 review 代码的，所以那么快写完也没啥意义，就一直没用。说白了，感觉还是不是完全信任 AI，这点后面得改进。

other trick

还有一些其他的方法技巧，也是在认知内的，并且时不时使用的。不过我觉得都算不上范式上的创新。

测试

包括让 AI 先写测试用例，用脚本、browser 测试等等。

评审

让 AI 自己评审代码，并强制 lint。人工审查关键逻辑，核心逻辑尽量理解，普通代码（尤其是 UI 相关）就大概看看。

上下文知识库

有点类似我之前提到那个动态更新的 design、api 文档、全局规范等，主动把上下文管理起来。这些都是项目的知识库。

系统性升级

来自开头提到的那篇文章，我看了三遍还意犹未尽，很多东西确实写到点子上了（不过讲真的有点乱）。而且，一看就是真正做过的经验之谈。这里只提取认知部分，其实具体操作都不重要。

第一性原理

真实的日常工作模式（我做了一些调整）:

任务管理：Todo List 分优先级，或者就是某个需求文档。
简单任务 Fire and Forget：低频低思考成本事项秒回即忘。
复杂任务 SOP 化：脑内计划 + 执行机器模式 + 文档跟踪。
文档管理：我会习惯性地先写一份大致的设计文档和API文档（是的，API 文档一定在代码之前搞定），主要目的是用来理思路（我一贯的观点：写代码不快是没想清楚不是打字慢）。同时做完后也会习惯性地写一份 README，讲使用流程。
窗口即上下文：每个窗口对应一个具体的模块或功能，这里的窗口可以是文件的 tab，也可以是 terminal、浏览器之类。
备忘录：记录死记硬背的内容（打包命令、数据库 IP 密码之类的信息，这个不太重要）。

作者说这是土方法，和 AI 比起来确实，不过确实很有效，而且按这个模式已经做了很多项目了，心智上比较熟悉，操作上比较熟练。我之前没有刻意主动地往这个角度想，但这个思考确实很有意义。

文章特别强调“过程”的价值，因为大部分真实场景的项目不是一锤子买卖，而是需要持续维护和迭代的。spec 关注规范和结果，但不关心过程，这就导致每次都是重来一遍，边际成本不变。真实的价值在过程中：

执行 → 有问题 → 验证 → 排查 → 继续执行
                    ↓
            排查信息往往没被记录
                    ↓
        时间一久或换人，下次重新排查

我觉得有点自己之前提到的“记录更新变化”的那么一点意思。

复合工程

其实原文还有个上下文工程，不过这个属于我认知的一部分，前面也提到过，这里就不再赘述了。复合工程来自 Claude 和 Every 团队的实践交流，后面开源^[5]了，它的目的是：让每一单元的工程工作使后续工作变得更容易，而非更难。

Plan ──────→ Work ──────→ Review ──────→ Compound
详细规划     执行工作     质量检查       知识沉淀
   ↑                                       │
   └───────────────────────────────────────┘
            知识复合：下次规划更精准

思想看起来和我的想法是类似的（过程文档化），不过具体做法不太一样：我的太糙了没法看，这里的比较规范和细粒度。

复合工程的三个设计模式：

模式	核心思想	价值
并行代理	多角度分析时启动多个专业代理，合并结果后继续	提高分析覆盖度和效率
意图路由	入口统一，根据意图自动路由到具体工作流	降低用户认知负担
知识复合	问题解决 → 文档化 → 未来查找 → 团队变聪明	边际成本递减

知识复合

单独拎出来，这个最重要。主要结构如下：

用户输入 → Command（入口）→ Agent（决策层）→ Skill（执行层）
                              ↓
                         意图识别、流程路由
                              ↓
                         调用具体 Skill 执行
                              ↓
                         experience-index（经验检索）

来自复合工程的设计启示：

维度	启示
任务分解	阶段化执行（Plan → Work → Review → Compound），并行化处理，状态持久化
质量保障	多角度并行审查，分级处理（P1/P2/P3），持续验证（边做边测）
知识管理	即时文档化（趁上下文新鲜），分类存储（按问题类型），交叉引用（关联 Issue、PR）
工具设计	工具提供能力而非行为，Prompt 定义意图和流程，让代理决定如何达成目标

看起来好像本能地都涉及过，就是太太太粗糙了。

极简主义设计理念（无需关心具体细节，只需关心理念）:

入口极简化：只有两个命令入口，把复杂性藏到了 Agent 的智能路由里。用户只需表达意图，Agent 会判断该调用哪个 Skill。
Skill 而非工具堆叠：speckit/openspec 倾向于提供更多工具、更多模板、更多约束。这里选择把能力编码为 Skill，让 Agent 在需要时自动调用，而不是让用户手动选择"现在该用哪个工具"。这个现在正在逐渐成为主流。关于 skill 可以看这里^[6]。
上下文自动加载：Claude Code 团队说"人类和 AI 看同样的输出，说同样的语言，共享同一个现实"。这里把这个原则应用到上下文管理——不是让用户手动指定"加载哪些背景资料"，而是让 Agent 根据当前阶段自动加载相关的 context/。用户感受不到"上下文加载"这个动作，但 AI 已经具备了完整的信息。这个很有意思，提供了一种管理 context 的方式——分门别类按约定放好。
删除优先于添加：每次迭代时，作者会问自己"有哪些东西可以删掉？“而不是"还能加什么功能？”。AGENTS.md 从最初的长篇大论，精简到现在只放通用规范和目录指针，具体流程全部下沉到 Skill 里。
双重用户设计：Claude Code 为工程师和模型同时设计界面。AI 工程化也是——命令人可以手动调用，Agent 也可以在流程中自动调用子 Skill。同一套能力，两种调用方式，没有冗余。

这里面的理念我们提炼一下：

AGENT.md 放通用规范和目录指针。
SKILL.md 是各种能力的抽象，会有多个 SKILL。
context/ 下面包含各种各样的上下文信息，比如设计文档、API、重要更新日志、通用知识等。这是个项目相关知识库。

工具/SKILL设计

关于工具（理解为 SKILL 也行）设计的通用理念很不错：

好的工具
- 自包含：不依赖"记住"之前的对话。
- 返回精简：只返回 token 高效的必要信息。
- 边界清晰：用途明确，减少决策成本。
- 发挥模型优势：利用模型擅长的能力。
坏的工具
- 返回完整数据库查询结果（可能数千行）。
- 工具描述长达数百 token。
- 多个工具功能重叠，边界模糊。
- 强迫模型做它不擅长的事情。

关于 SKILL，我们可以看看 What are skills? - Agent Skills^[7] 这里的介绍：Agent Skills 是一种轻量级的开放格式，可通过专业知识和工作流程扩展 AI 代理的功能。下面是一个具体的示例：

my-skill/
├── SKILL.md          # Required: instructions + metadata
├── scripts/          # Optional: executable code
├── references/       # Optional: documentation
└── assets/           # Optional: templates, resources

可以去 anthropics/skills: Public repository for Agent Skills^[8] 看一些具体的例子。

下面这两个网址都提供了一些编写技巧：

SKILL 和 MCP 的区别是，MCP 可能更加外部化、工具化一点。如这里^[11]的介绍：MCP 将 Claude 连接到外部服务和数据源。SKILL 提供程序性知识——即完成特定任务或工作流程的说明。可以将两者结合使用：MCP 连接使 Claude 能够访问各种工具，而技能则教会 Claude 如何有效地使用这些工具。

SKILL 看起来好像就是特定任务的**「提示词」**，在需要时加载，更适合专业化的工作流程。

context设计

我们把 context 单独拿出来看。文章给出如下原则：

分层式信息组织。比如下面的“分层示例”。
“即时”上下文策略。轻量维护索引，需要时加载具体信息。
上下文压缩与笔记系统。
- 压缩：
  - 将接近上下文窗口限制的对话内容总结。
  - 保留：架构决策、未解决的 bug、实现细节。
  - 丢弃：冗余的工具输出或消息。
  - 用摘要重新初始化新的上下文窗口。
- 结构化笔记：
  - 智能体定期将笔记写入上下文窗口外的持久化存储。
  - 稍后根据需要拉回上下文窗口。
  - 实现跨压缩步骤的连贯性。

分层示例：

context/
├── business/
│   └── 活动业务边界.md          ← 概要层（意图识别时加载）
├── tech/
│   └── Apollo配置规范.md       ← 技术层（方案设计时加载）
└── experience/
    ├── 商品发放历史问题.md      ← 经验层（实施前加载）
    └── 雅典娜配置注意事项.md    ← 详细层（配置时加载）

AI 工程化对应：

AI 工程化设计	上下文工程原理
`context/` 分层目录	分层式信息组织，按阶段按需加载
Skill 封装固定流程（`skill/`）	稳定执行过程，避免提示词遗漏导致的上下文不完整
Subagent 架构（`agent/`）	主 Agent 保持精简，子任务独立窗口
状态文件传递（`requirement/`）	不依赖"记忆"，依赖结构化状态
经验沉淀机制（`wiki/`）	将知识编码为可检索上下文，而非依赖人脑

整体汇总

接下来看一下整体结构，噢，我很喜欢这句：“目录结构：位置即语义”，让我想起了 umi^[12] 的“文件即路由”。我稍微改了一下：

your-project/
├── MAIN.md                         # 项目入口（包含规范、目录、基本信息等）
├── agent/                          # AI下属，各司其职（让其通用化）
│   ├── phase-router.md                      # 阶段路由，意图识别
│   ├── requirement-manager.md               # 需求全生命周期管理
│   ├── design-manager.md                    # 方案全生命周期管理
│   ├── implementation-executor.md           # 开发实施执行
│   └── experience-depositor.md              # 经验沉淀（独立上下文）
├── mcp/                            # 外部工具（本来就通用的）
│   ├── TAPD MCP                             # 需求管理
│   └── iWiki MCP                            # 知识管理
├── skill/                          # 通用能力（让其通用化）
│   ├── req-create/                          # 需求创建
│   ├── design-create/                       # 方案创建
│   ├── workspace-setup/                     # 环境搭建
│   └── code-commit/                         # 代码提交
├── wiki/                           # 项目知识库（长期记忆，和项目绑定）
│   ├── business/                            # 业务领域知识
│   ├── design/                              # 设计文档
│   ├── tech/                                # 技术分析
│   ├── api/                                 # 接口文档
│   └── experience/                          # 历史经验
├── requirement/                    # 需求管理（看板或TODO，和项目绑定）
│   ├── INDEX.md                             # 需求索引
│   ├── in-progress/                         # 进行中需求
│   └── completed/                           # 已完成需求
├── reference/                      # 参考实现区，能抄就抄吧……改巴改巴的也可以
└── code/                           # 代码区

这里，我把 context 改成了 wiki，因为感觉 context 范围更广。

这是 AI 时代的项目目录，一切为了 AI 方便，同时考虑便于人工维护。我打算先按这个思路实践实践，后面看情况是否需要调整。

关于知识沉淀

这部分单纯做点笔记吧，感觉很有道理。

触发时机

不是：做完需求后专门花时间"写总结"
而是：在流程关键节点自动触发沉淀

具体触发点：
├── 需求完成时 → requirement-completer skill 自动提取可复用经验
├── 遇到问题解决后 → 用户说"记住这个坑" → experience-depositor agent 记录
├── 代码提交时 → code-commit skill 检查是否有值得记录的模式
└── 流程优化时 → /optimize-flow 命令专门用于沉淀和优化

沉淀内容

# context/experience/商品发放-钱包选择问题.md

## 问题描述
商品发放时选错钱包类型，导致用户领取失败

## 触发条件
- 需求涉及商品发放
- 商品类型为虚拟商品

## 解决方案
虚拟商品必须发到虚拟钱包，实物商品发到实物钱包
具体判断逻辑见 Apollo 配置：xxx.wallet.type

## 校验方式
检查 goods_type 与 wallet_type 的匹配关系

## 关联文档
- context/tech/Apollo配置规范.md
- context/tech/services/商品服务技术总结.md

加载机制

Agent 的上下文加载逻辑：

1. 意图识别阶段
   phase-router 识别意图，路由到对应 Agent
        ↓
2. 经验检索阶段
   Agent 调用 experience-index Skill，传入场景描述
   Skill 检索四类规则文件：
   ├── context-rules.md  → 匹配需加载的背景文档
   ├── risk-rules.md     → 匹配风险提示
   ├── service-rules.md  → 匹配服务依赖建议
   └── pattern-rules.md  → 匹配代码规范
        ↓
3. 返回结构化结果
   {
     "context": { "files": ["商品发放历史问题.md"] },
     "risk": { "alerts": [{"level": "high", "message": "注意钱包类型"}] },
     "service": { "suggestions": ["商品服务", "钱包服务"] },
     "pattern": { "files": ["error-handling.md"] }
   }
        ↓
4. Agent 主动提醒
   "注意：历史上商品发放有钱包选择问题，请确认..."

这里后续可能需要定义一下整个链路，把过程 SOP 掉，maybe 需要一个专门的文件夹。

演进机制

阶段 1：纯文档（被动）
context/experience/xxx.md
→ AI 读取后提醒，但需要人确认

阶段 2：校验 Skill（半自动）
skill/product-distribution-validator
→ 自动校验配置，发现问题直接报错

阶段 3：完整 Command（全自动）
cmd/implement-product-distribution
→ 一个命令：加载背景 + 校验 + 生成 + 提醒 + 沉淀新经验

演进判断标准：
- 同类需求做了 5 次以上 → 考虑封装 Skill
- Skill 被调用 10 次以上 → 考虑封装 Command
- 不要过早抽象，让实践驱动演进

这里其实是 SKILL 的组合，文章是最后开发成工具了，所以需要变成 command 方便执行（这个命名感觉有歧义），但组装成一个大的 SKILL 也是可以的。总之，把 SKILL 当做小的 module 就行，跟写代码没有本质区别，只是换个写法而已。

实践过程

这里来大致模拟一遍流程，不一定准确。

1. 初始化项目，创建好统一目录。
        ↓
2. 用户初始化一个任务，可以是一句话或一段描述。
        ↓
3. 产品经理把需求细化成不同模块的细化需求，也许还可以画出 UI。用户确认。
        ↓
4. 架构师分析产品需求，并设计整体架构，形成设计文档。用户确认。
        ↓
5. 架构师根据设计文档设计接口。用户确认。
        ↓
6. 前后端根据接口和需求进行代码开发。用户确认。
        ↓
7. 需求开发完成，测试进行相关测试。用户确认。
        ↓
8. 循环执行3-7，直到完成用户任务。

每一次“用户确认”都是一次知识沉淀的时机，可以由用户刻意引导沉淀，比如使用某 SKILL 完成沉淀，也隐式地可以由 SKILL 自己判断是否值得沉淀。

这里没有意图判断，全流程有 AI 主导，人工仅做确认或一些信息补充和反馈。

每一步执行都自动根据目录加载相应的信息，这个可能直接固定在对应的 agent 中。

总结

为了让 AI 更好地干活，我感觉比写代码还累……要不是它能并行还写得快，我费这劲干啥……难怪不少人说：“让子弹再飞会儿”……也许后面很多东西就都内化到模型里面了。

其实，我最终想要的是：“一旦前期我确认了，后面全部由 AI 自动完成，它们可能会持续运行一整天，直到完成我的任务。”我给他的只是一个描述，顶多再给一个别的案例（也许我只是提个名字让他自己去搜集资料，完成调研）。

另外，我觉得这一套不仅要用在开发上，还得扩展到其他方面，比如客服、营销等等——最终形态是自动运作的全 AI 员工的虚拟组织。

Reference

[1] 认知重建：Speckit 用了三个月，我放弃了——走出工具很强但用不好的困境 - 知乎: https://zhuanlan.zhihu.com/p/1993009461451831150
[2] 项目: https://yam.gift/2026/01/01/AI/2026-01-01-From-AI-Coding-Watch-World-Future/
[3] Vibe Kanban: https://www.vibekanban.com/docs
[4] OpenSpec: https://github.com/Fission-AI/OpenSpec?tab=readme-ov-file#how-openspec-compares
[5] 开源: https://github.com/EveryInc/compound-engineering-plugin/tree/main
[6] 这里: https://agentskills.io/home
[7] What are skills? - Agent Skills: https://agentskills.io/what-are-skills
[8] anthropics/skills: Public repository for Agent Skills: https://github.com/anthropics/skills
[9] How to create custom Skills | Claude Help Center: https://support.claude.com/en/articles/12512198-how-to-create-custom-skills
[10] Claude-meta-skill/create-skill-file/SKILL.md: https://github.com/YYH211/Claude-meta-skill/blob/main/create-skill-file/SKILL.md
[11] 这里: https://support.claude.com/en/articles/12512176-what-are-skills
[12] umi: https://v3.umijs.org/zh-CN/docs/convention-routing

稳定压倒一切：MoE RL 训推不一致问题及解决策略

2026-01-17T04:00:00.000Z

TL;DR

核心矛盾：MoE 模型对输入极度敏感，训练引擎与推理引擎在算子实现、数值精度上的微小差异，会导致同一 Token 在两端选择不同的专家。
现象严重性：实验显示约 94% 的 Token 在一次前向传播中至少有一层路由决策不一致，直接导致策略梯度出现剧烈噪声，引发训练不稳定。
不同策略：算法鲁棒化的 GSPO/GMPO，数学偏差补偿的 TIS/IcePop，系统强行对齐的 R3/DeepSeek。

本文来讨论一下 MoE RL 的稳定性问题。其实，我自己还没用过 MoE，基本还是 Dense，所以讨论也谈不上，纯粹是整理了。￣□￣｜｜

另外，本文的图片和公式绝大多数来自原文，特在此声明。

问题

在 RL 时，训练和推理经常是不同的引擎，比如推理用 VLLM 或 SGLang，训练用 FSDP 或 Megatron。这就导致 rollout 时的分布和训练时的需要的分布可能不一样。有同学可能会问了，rollout 只是采样轨迹呀，怎么和后面的更新参数、计算 log_prob 有关呢？嘿，在 RL 中，它们不仅有关，还强耦合。因为在损失函数有个很重要的前提：期望是在策略上取的，trace 从哪个策略采样，本身就是目标函数的一部分。rollout 看似在生成数据，其实是定义一个行为分布。后面的计算 log_prob 是应该在选定分布上进行。

我们来看看具体的现象，来自 R3^[1]（Stabilizing MoE Reinforcement Learning by Aligning Training and Inference Routers），

图（a）展示的是每一个 token 和每一层 MoE，MoE Router 在训推阶段选择专家不同的次数，约有 10% 的 token 在训练时选择了和推理阶段不同的专家。

图（b）展示的是针对每一个 token，MoE Router 在所有层中做出不同专家选择的次数。结果显示，在一次前向传播过程中，94% 的 token 至少在一层中选择了不同的专家。

图（c）展示每一条序列每个 token 的路由分布差异，然后在 token 维度上取平均，得到该序列的平均差异。结果显示，每个 token 的平均差异是 6 个路由。也就是说，一次前向传播大约有 6 次路由决策表现出训推不一致。

带来的结果就是训推概率分布的不一致（用 KL K3 计算衡量），

前 3 个图无需多言，最后一个是极端（训推分布概率比值超过阈值τ）token 所占比例。

以上现象表明，MoE 模型在训练与推理阶段之间存在显著更高程度的分布差异。而这种差异会让训练不稳定，甚至崩溃。比如 IcePop^[2] 给出的现象，如下图所示：

接下来我们看看大家如何各显神通来解决这个问题。

解决策略

GSPO

Qwen 发布的，这个我们在《GRPO“第一背锅侠”Token Level X：DAPO/DrGRPO与GSPO/GMPO的殊途同归 | 长琴^[3]》中专门介绍过，虽然 GSPO 的出发点不是解决这个问题，但它有个正向的外部性：稳定 MoE 训练。其原因是序列级别关注，对 token 没那么敏感。效果如下：

嗯，看起来比 GRPO + Routing Replay 效果还要好一些。

还有同时期的 GMPO 其实和 GSPO 非常像（从出发点到解决方案），我们在刚刚那篇文章中也提到过了，这里不再赘述。

TIS

来自《2508 Your Efficient RL Framework Secretly Brings You Off-Policy RL Training | Notion^[4]》，其方案是：调整模型更新方式，使其感知到这种训推不匹配。具体做法很简单，对重要性采样（比率）进行校正，经典的做法是“截断”——在原目标前面乘一个截断的重要性比率系数。

公式表达了一切信息，前面是新增的 TIS 系数，后面是 PPO 目标，θ 是 policy 参数。

你可能会想，就不能把后面的重要性采样系数换成 TIS 吗？嘿，有的，文章后面做了两个变体实验：

结果如下图所示，

两个变体看起来都不怎么样。

对于 Vanilla-IS，如果 IS 比较大，方差会更大（平方放大），进而导致不稳定。而对于 PPO-IS，实验效果也比较差，文章的解释是：这种情况下即便 θ 相同，由于 policy 不同，可能导致系数不等于 1，这和 PPO 的设计（θ 相等时比率=1）是有偏差的。其结果就是，PPO 的 clip 被系统噪声提前触发，梯度还没来得及反映“真实 policy 更新”就被 clip 掉了。

而 TIS 其实是做了一个因式分解：

第一项就是 TIS 前面的那个 IS，属于系统性偏差，截断变成 TIS 是防止方差过大；
第二项是 policy update 的 IS，用 PPO 的 clip。

我此刻的真实感觉就是：“这，好微妙呀”。后续实验还表明 TIS 可以缓解熵坍缩、稳定 KL 估计、提升下游任务等。

还有一大部分内容是分析可能导致 Rollout-Training 不匹配的具体因素的：

并行（TP、SP）策略的差异和较长的响应长度会导致这种不匹配。
采样器后端的选择本身影响甚微。

文章最后提到和 GSPO/GMPO 的区别：TIS 旨在解决系统层面（训推引擎不一致）的分布不匹配问题；而 GXPO 主要改进重要性采样比率的计算方法，提高了策略更新的稳定性。

IcePop

蚂蚁的 2509 Small Leak Can Sink a Great Ship—Boost RL Training on MoE with 𝑰𝒄𝒆𝑷𝒐𝒑!^[5]，中文名字“棒冰”或“冰棒”，很有意思的名字，据文中说，这是吃冰棒时想出这个名字的，冰棒能降温，该算法通过截断极端概率比并屏蔽差异过大的 token，来“冷却”不稳定的训练。

IcePop 有两个机制：

双向 clip：既 clip 训练概率 ≫ 推理概率的 token，也 clip 训练概率 ≪ 推理概率的 token。
Mask：从梯度更新中移除差异过大的 token。

损失函数如下：

看到这个 Mask，很容易就想起了 CISPO^[6] 有没有，就 Mask 的这个作用来看，它们其实是一致的，只不过对象不同。

大家都是为了稳定呀。

IcePop 看起来和 TIS 有点像，文中解释了两者的区别：

当 IS < α 时，π_train 倾向于给 action 较小的 value，π_infer 输出较高的概率。如果比率足够小，意味着训推引擎存在巨大差异，TIS 引入一个小的系数来缓解梯度更新中的噪声。但本文发现，随着训练进行，这种微小扰动会逐渐放大，最终导致平台期。
当 IS > β 时，TIS 会乘以一个适中的系数持续更新 policy。而 IcePop 梯度为零，这意味着放弃所有噪声更新，只保留那些健康的策略梯度。

其实 IcePop 看起来像是 token 级别截断的 TIS。效果如下：

后续的分析表明，TIS 和 IcePop 都能将训练-推理概率的 KL 散度控制在合理范围内，但 IcePop 的差异一直相对较小，TIS 始终表现出更大的极端差异和更快的增长速度。作者猜测这可能由于 TIS 在训练过程中包含了噪声策略更新导致。

R3

来自罗福莉挂名，小米的《2510 Stabilizing MoE Reinforcement Learning by Aligning Training and Inference Routers^[7]》，R3 = Rollout Routing Replay。不知道为啥，每次看到 Replay 都会莫名想到 “重放攻击”……

这里的重放是：从推理引擎捕获序列生成时的路由分布，并直接重放到训练引擎中。注意，这里重放的是 Experts 的路由分布，其他的依然由策略生成。

$\mathbf{I}_{\text {train }}=\text { TopKMask }\left(\mathbf{s}_{\text {train }}, K\right)$

s_train 是 router 的 logits。

gate 权重从

$g_{\text {train }, i}=\frac{I_{\text {train }, i} \exp \left(s_{\text {train }, i}\right)}{\sum_{j=1}^M I_{\text {train }, j} \exp \left(s_{\text {train }, j}\right)} \quad \text { for } i=1, \ldots, M .$

调整为：

$g_{\text {replay }, i}=\frac{I_{\text {infer }, i} \exp \left(s_{\text {train }, i}\right)}{\sum_{j=1}^M I_{\text {infer }, j} \exp \left(s_{\text {train }, j}\right)} \quad \text { for } i=1, \ldots, M .$

MoE 层的输出为：

$\mathbf{y}_{\text {replay }}=\sum_{i=1}^M g_{\text {replay }, i} \mathcal{E}_i\left(\mathbf{x}_{\text {train }}\right) .$

其中，ε 是 expert 网络。

这个设计出于两个目的：

对齐训练和推理：训推使用同样的专家。
保持梯度传递：只重放路由分布（而不是固定权重），梯度仍然可以回传到 logits（权重可以改变）。类似软对齐和硬对齐的区别。

我们还是看一下最终效果，毕竟里面还有 GSPO 和 TIS。

括号里的是最佳步数。看起来 GRPO + R3 好像就可以了。

路由保持

DeepSeek V3.2 的策略，这个我们在《DeepSeekV3.2后训练：稳定压倒一切 | 长琴^[8]》中介绍过，他们的做法是比较粗暴的：直接在推理框架中保留采样时使用的专家路由路径，并在训练阶段强制使用相同的路由路径。显然，这肯定是有效果的，应该说是最有效果了。论文虽然没有给出对比图，但明确提到这一操作对稳定性至关重要。

和 R3 很像啊，不过 DeepSeek V3.2 在权重计算上看起来有点倾向于完全固定（暗示了路径一致），梯度是否回传不太确定。总之，策略一样，但实现可能略有不同。

小结

本文主要介绍了 RL 训练中由于训推不一致导致的不稳定问题，这在 MoE 中更甚，因为 Experts 选择的不一致会导致训练更加不稳定。为此，业界也提出了一些相应的解决策略，有改进重要性采样比率的计算方法的 GSPO/GMPO，也有系统调整模型更新方式使其感知到训推不匹配的 TIS/IcePop，当然，还有从根源上直接在训练时重放推理轨迹的 R3/路由保持等。虽然大家方案不同，但归根结底都是为了训练的稳定性——真是稳定性压倒一切呀！

最后，依然放上一张 AI 总结的表格：

策略分类	代表方案	核心手段	评价
分布解耦	GSPO/GMPO	采用序列级关注，降低对 Token 级波动的敏感度。	间接优化，稳定性提升明显。
重要性修正	TIS / IcePop	引入校正系数或直接 Mask 掉训推概率比（IS）过大的 Token。	系统性优化，IcePop 比 TIS 更激进、更干净。
强制对齐	R3 / DeepSeek	训练时强制复用推理时记录的专家路径。	直接且有效地解决不一致问题。

References

[1] R3: https://arxiv.org/abs/2510.11370
[2] IcePop: https://ringtech.notion.site/icepop
[3] GRPO“第一背锅侠”Token Level X：DAPO/DrGRPO与GSPO/GMPO的殊途同归 | 长琴: https://yam.gift/2025/08/14/NLP/LLM-Training/2025-08-14-Token-Level-GSPO-GMPO/
[4] 2508 Your Efficient RL Framework Secretly Brings You Off-Policy RL Training | Notion: https://fengyao.notion.site/off-policy-rl
[5] 2509 Small Leak Can Sink a Great Ship—Boost RL Training on MoE with 𝑰𝒄𝒆𝑷𝒐𝒑!: https://ringtech.notion.site/icepop
[6] CISPO: https://yam.gift/2025/06/19/NLP/LLM-Training/2025-06-19-CISPO-and-Entropy/
[7] 2510 Stabilizing MoE Reinforcement Learning by Aligning Training and Inference Routers: https://arxiv.org/abs/2510.11370
[8] DeepSeekV3.2后训练：稳定压倒一切 | 长琴: https://yam.gift/2025/12/03/NLP/LLM-Training/2025-12-03-DeepSeek-V32-PostTraining/

【聆听·微光】004：一位算法后端开发工程师的AI转型之路

2026-01-15T15:00:00.000Z

【来访者个人档案】

身份：工作3年的算法专业的后端开发工程师。
自述：我对现在的工作不满意，我想全面拥抱 AI。

今天来访的是一位老粉丝了，我们后面用 S 同学来称呼。S 同学从2022年我写《ChatGPT 原理与应用开发》那会儿就关注了，根据这个开源项目找到我的博客并 RSS 订阅。后面看了我相当多的博客，对我算是比较熟悉的了。

S 同学想聊的依然是工作和学习（或者说成长），这好像真的是大家共同的主题了，只不过由于背景和条件不同，表现出来的状况和问题也不相同。

工作转型

S 同学目前工作的优点是稳定，和上一位《【聆听·微光】003：一位对工作迷茫的程序员的觉醒时刻 | 长琴》有点类似，状况也比较类似——没有技术氛围，技术也不受重视。而且，和 AI、尤其是大模型也没有太多关系。还有，经常得出差，与家人两地分居。

首先，我明确一点：异地对家庭确实不太友好，除非非常非常好的机遇，否则实在不建议异地。我自己曾经因为转行异地过一年多，的确会比较影响感情，倒不一定是出现第三者，而是感情可能会因为距离的原因变淡。我本来还提到看能否调回家庭所在地，不过 S 同学显然是下定决心要离开公司了，看来是非常不能接受这里的氛围了。能清楚地知道自己要什么、要干什么，这本身也是值得赞扬的。

S 同学知道自己去做算法研究可能机会不大，所以现在同时准备后端和 AI 相关的，想听一下我的建议。其实，我觉得 S 同学的认知很清晰，现在算法研究的岗位实在是不多，而且会越来越少。因为 AI 能力实在是太强大了，而且正在越来越强，大部分时候已经不再需要去训练或微调一个模型了。但同时，AI 开发、大模型开发、大模型应用开发一类的岗位却非常多，无论大、中、小厂，都在全面拥抱 AI。既懂 AI 同时还懂开发其实是有一定优势的。所以，后端和 AI 同时准备并不冲突，甚至在以后是必需的。

既然要离开，当然是骑驴找马，一边维持着工作，一边准备并看新的机会。现在大方向也定了，S 同学想继续听听行业、公司方面的考虑，还问到关于创业公司的稳定性、是否可以选择 remote 等问题。

对于行业和公司，我给的建议如下：第一，今年可以考虑具身智能方向，盲猜会有相当多公司和产品冒出来，而且这个方向和 AI 关系密切（不过不同公司具体用了多少那就嘿嘿了），正处于风口。第二，如果可以，优先考虑大厂，这点我在上一位的访谈中也提到过，原因不在赘述。第三，选自己喜欢做的 AI 产品或业务，总之，必须先站到这个圈子里。以上三条最少应该满足一条，多多益善。

关于创业公司的稳定性，我只能说，对于个人来说，其实没有哪家公司是稳定的，即便大厂，谁又能肯定不会被裁掉呢。所以，归根结底还是提升自己能力，积累相关工作经验，让自己有“随时离开一家公司”的底气，这才是真正的稳定。这点我在发刊词中提到过，S 同学认真阅读过，也很明白这个道理。

至于 remote 工作，我的观点是：既看个人，也看公司。我以前正好远程工作过一年，一个朋友也远程工作过几年。先说个人方面，以我的经验为例，就首先个人需要具备强大的自驱能力和自控力，同时还得有一个安静的工作环境，家里不方便可能还得出去租个工位。我当年就是这样做的，家里实在是没干活儿氛围。而且，那一年我说的话都很少，有一阵子感觉说话都不利索了。再说公司方面，以我朋友的经验为例，首先得具备一定的稳定性（可能得去查一下），除非是类似 huggingface 这种非常知名的公司。我朋友比较宅，在家 remote 了可能有两三年时间，但那家公司突然就无了，前面都毫无征兆，真是措手不及。

学习之路

工作的困惑暂时解决了，接下来要谈的是准备问题。S 同学的 AI 知识还停留在 LLM 之前那个机器学习的年代，但 LLM 之后一切都变了，不能说以前的知识就没用，只是目前大部分岗位都和大模型相关，要求有相应的工作履历和背景知识。S 同学要补的就是这方面的知识和项目。

目前，S 同学正在系统性地学习一个开源的 Agent 项目，听起来学习效果还不错。我本想建议直接主题学习的，不过考虑到现在相关知识的积累还不太够，我觉得 S 同学选择系统性学习反而是正确的——先整体建立一个认知，然后再逐步构建自己的知识体系。是我自己有点想当然了。其实，我在转行前后几年也是系统性地上了不少课的，国内外的都有，而且都认真完成了作业。虽然这些学习对工作可能没有太多实际帮助，但却为后面的学习打下了坚实的基础。

考虑到 S 同学没有大模型相关项目，我建议在系统性学习完成后，可以利用公司数据做一个小的 Agent/RAG 项目，包装成一段项目经历。因为简历上如果一个大模型相关项目经验都没有的话，恐怕会比较难通过大模型开发类岗位的简历筛选。另外，我也强调，这并不是造假，而是真实地去完成这个项目，掌握全流程涉及到的相关知识。简历的核心目标是把我们的能力表现出来。

最后，我也建议 S 同学去深入研究某一个其项目中用到的、或其他大模型开发相关的框架/组件，诚如我在《【聆听·微光】002：一位普通院校硕士研究生的毕业之际 | 长琴》中提到的那样，对一个 Case 的精通要好过很多个小白项目。然后在和面试官聊项目时，自然地过渡到自己精通的这个 Case。

尾声

S 同学说被我的乐观和心态感染，其实我自己也是会焦虑的，我笑着开玩笑，总不能再把焦虑传给本来就因为焦虑来找我聊天的你们吧。况且，焦虑又能解决什么问题呢？

后来又聊了一下我的工作日常，这让我想起了我曾经也很想知道算法工程师的工作日常。从 S 同学的实时反馈中，我能清楚感受到其对学习和探索的热情，对拥抱 AI 的急切心情。当然，也有那么一丝对未来不确定性的担忧。总之，在这里真挚祝福 S 同学能早日找到自己心仪的工作，在 AI 潮流中乘风破浪！

💡 共鸣时刻

这是一个极好的时代，也是一个不好的时代。
AI 大势当前，个人除了随波逐浪，别无他法。
S 同学很明显意识到这点，并已经走上了转型之路。

为了跟上时代，也为了更好的自己。

每一次的努力和拼搏，都是对未来的期待。
纵有狂风拔地起，我亦乘风破万里。

LLM 强化的“炼金术”：主流开源模型的 RL 优化策略赏析

2026-01-14T15:00:00.000Z

TL;DR

EXAONE: 改进 GRPO，通过移除 Clip 保留探索性 Token，并利用非对称采样引导模型远离错误路径。
Kimi: 从 KKT 条件推导出 RL 目标函数，将长推理过程视为“隐式搜索”，并利用逐步升温长度惩罚解决“过度思考”问题。
MiMo: 采用反向 KL 散度进行多教师蒸馏（MOPD），实现“寻找众数”的精准能力迁移。
MiniMax: 针对 GRPO Clip 问题，采用带 Stop-gradient 的重要性采样与 Token Mask 机制，不丢弃探索梯度同时确保训练平稳。
Qwen: 将重要性权重回归序列级别，引入长度归一化解决 Token-level 高方差，同时增强了 MoE 路由的稳定性，并进一步演进为平滑剪裁的 SAPO。

结论： 行业正从简单的奖励最大化转向更精细的分布对齐、隐式规划引导和训练稳定性控制。

这是一篇开始的比较早的文章了，一直没写完，正好赶上最近几个团队多有新作发布，就一并梳理掉吧。

EXAONE

最开始是想写 2507 EXAONE 4.0: Unified Large Language Models Integrating Non-reasoning and Reasoning Modes^[1] 这篇文章的，主要是它提出的 AGAPO 优化方法，也算是 GRPO 的变种。

做法如下：

移除 clip，避免丢弃探索性 token。这个探索性 token 我们在 GRPO优化在继续——CISPO和熵 | 长琴^[2] 中我们提到过，当时的做法是，通过使用裁剪并断开梯度的熵项增强优势函数。
非对称采样，对于全错样本，不是全部丢弃，而是在优势计算中会分配一个较小的负奖励，这种负反馈用以引导模型远离错误的推理路径。这和 DAPO^[3] 的动态采样不一样，倒是和 CISPO^[4] 思想有点类似。
组级与全局优势，组内使用 LOO 计算优势，在 batch 内归一化。这应该来自 Reinforce++和它的KL Loss选择 | 长琴^[5]。
序列级累计 KL，引入 KL 惩罚项目的是保留 SFT 阶段学到的能力。

最终损失函数如下：

有意思的是，它的后续版本 2601 K-EXAONE Technical Report^[6] 还是用的它，不过稍微有一点点额外的调整。

借鉴 MiniMax M1 的 CISPO^[4]，采用了带截断重要性采样的 off-policy 梯度目标。
使用零方差过滤：对于其采样 rollout 获得完全相同奖励、从而优势值为零的 prompt，直接予以丢弃。
去除了 KL 惩罚项。这是 ORZ^[7] 的做法。
在整个 RL 训练阶段，冻结 MoE 的 router。

最终损失函数如下：

Kimi

Kimi-1.5 和 Kimi-2 都用了同一套优化方法，这是从优化角度重新从头到尾梳理后得出来的方法，过程极其有意思。我们来重点看看。

优化视角

Kimi 从解决复杂问题的 CoT 方法出发，自然转到进一步增强推理能力的 planning 方法，并提出，这些方法的核心思想在于：在价值估计的引导下，显式地构建一个由“思路”（thoughts）组成的搜索树。

“思路（thoughts）”和“反馈（feedbacks）”都可以被视为中间推理步骤，而且这两者都可以表示为语言 token 的序列。因此，可以将一个规划算法视为一个直接作用于推理步骤序列的映射。

在这一框架下，规划算法所使用的搜索树中存储的所有信息，都被展平为提供给算法的完整上下文。这为生成高质量 CoT 提供了一个耐人寻味的视角：与其显式地构建搜索树并实现规划算法，不如训练一个模型去近似这一过程。

以上都是 Kimi-1.5 的原文。看到了么，从优化出发，自然地转到用 LM 去近似。这点在之前其他论文是没有提过的。

文章继续说道，在这里，思考的数量（即语言 token 的数量）可以类比为传统规划算法中分配的计算预算。长上下文窗口能力使得这种方法在训练阶段和测试阶段都能够无缝扩展。如果这一设想可行，模型就能够通过自回归预测，在推理空间中隐式地执行搜索。由此，模型不仅学会解决一组训练问题，还会逐步具备有效处理单个问题的能力，从而在未见过的测试问题上表现出更强的泛化能力。

换句话说，用 LM 近似其实本质上还是在做优化，只不过是在“隐式”地进行。我很喜欢这一部分的分析，必定出自某个优化大佬。

然后，很自然地才到了 RLVR，生成 CoT 的质量由其是否能够导向正确的最终答案来衡量。优化目标就是奖励期望最大化。

RLVR 的目标是：训练一个能够同时发挥基于简单提示的 CoT与引入规划机制的 CoT各自的优势。在推理阶段，模型仍然以自回归的方式采样语言序列，从而避免了在部署时采用复杂规划算法所需的高成本并行化机制。

这是对前面定性分析的实践描述。

论文继续分析这一方法与简单的基于提示的方法的区别：模型不应只是机械地遵循一系列既定的推理步骤。相反，它还应当利用已探索的全部思路集合作为上下文信息，学习关键的规划能力，包括错误识别、回溯以及解法的逐步改进与精炼。

有没有一种追本溯源，形成闭环的感觉。对 GRPO 和 RL 的理解无疑能更上一层，真是相见恨晚！

策略优化

KKT

我们先从 KKT 说起，瞬间回到了 Hard-SVM, Soft-SVM 和 KKT | 长琴^[8] 啊！KKT = Karush–Kuhn–Tucker，是用来解决这样一类问题：

$\begin{array}{cl}\max _x & f(x) \\\text { s.t. } & g_i(x) \leq 0 \\& h_j(x)=0\end{array} \tag{1}$

即在约束条件下目标函数的最优解。

因为有了约束，所以直接求导还不够，因为最优解可能在边界上，导数不一定为 0，因此必须把“约束”纳入一阶条件，这就是为什么需要 KKT 条件。这是运筹规划领域非常常见的一类问题。

为了把“约束”放到目标函数，就引入了拉格朗日函数：

$\mathcal{L}(x, \lambda, \mu)=f(x)+\sum_j \lambda_j h_j(x)+\sum_i \mu_i g_i(x) \tag{2}$

λ 和 μ 分别是等式和不等式的约束因子。

我们都知道 KKT 有四个条件^[9]，

$\begin{aligned}\nabla_x \mathcal{L}\left(x, \lambda, \mu\right)=0 \\\mu_i g_i(x) = 0 \\g_i(x) \le 0 \quad h_j(x) = 0 \\\mu_i \ge 0\end{aligned} \tag{3}$

分别是：驻点条件、互补松弛条件、可行性、对偶可行性。

KKT到RL

其实迄今为止我们知道的大部分 RL 问题都可以看成一个约束优化问题，

$\max _\theta \mathbb{E}_\pi[r(x, y, y^*)] \quad \text { s.t. } \quad \operatorname{KL}\left(\pi \| \pi_{i}\right) \leq \epsilon \tag{4}$

引入不等式约束乘子 μ≥0，

$\begin{aligned}\max_{\theta} \mathbb{E}_\pi[r(x, y, y^*)]-\mu\left(\operatorname{KL}\left(\pi \| \pi_{i}\right)-\varepsilon\right) =\\ \max_{\theta} \mathbb{E}_\pi[r(x, y, y^*)]-\mu \operatorname{KL}\left(\pi \| \pi_{i}\right)+ \mu \varepsilon \end{aligned} \tag{5}$

这里有两个隐含约束：

$\begin{aligned}\sum_y \pi_\theta(y|x) = 1 \\\pi_\theta(y|x) \ge 0\end{aligned} \tag{6}$

对于每个 y 的概率约束（省掉最后一项常数项），

$\max_{\pi(\cdot|x)} \quad \sum_y \pi(y|x) r(x, y, y^*)-\mu \sum_y \pi(y|x) \log \frac{\pi(y|x)}{\pi_{i}(y|x)}+\lambda\left(\sum_y \pi(y|x)-1\right) \tag{7}$

对 π(y) 求导并让其等于 0，

$\nabla_{\pi(y|x)} = r(x, y, y^*) - \mu \left( \log \frac{\pi(y|x)}{\pi_{i}(y|x)}+ 1\right) + \lambda = 0 \tag{8}$

整理后得，

$\log \frac{\pi(y \mid x)}{\pi_{\theta_{i}}(y \mid x)}=\frac{r\left(x, y, y^*\right)+\lambda-\mu}{\mu} \tag{9}$

两边 exp，

$\pi(y \mid x)=\pi_{i}(y \mid x) \exp \left(\frac{r\left(x, y, y^*\right)}{\mu}\right) \exp \left(\frac{\lambda-\mu}{\mu}\right) \tag{10}$

最后一项是常数。上式两边对 y 求和，

$\sum_y \pi(y \mid x) = \exp \left(\frac{\lambda-\mu}{\mu}\right) \sum_y \pi_{i}(y \mid x) \exp \left(\frac{r\left(x, y, y^*\right)}{\mu}\right) \tag{11}$

上式左边必须等于 1，于是，

$\exp \left(\frac{\lambda-\mu}{\mu}\right) = \frac{1}{\sum_y \pi_{i}(y \mid x) \exp \left(\frac{r\left(x, y, y^*\right)}{\mu}\right)} \tag{12}$

令分母和项为 Z，于是我们有，

$\pi(y \mid x)=\pi_{i}(y \mid x) \exp \left(\frac{r\left(x, y, y^*\right)}{\mu}\right) / Z \tag{13}$

进一步化简可以得到，

$r(x, y, y^*) - \mu \log Z = \mu \log \frac{ \pi(y \mid x)}{\pi_{i}(y \mid x)} \tag{14}$

左边是 reward + 常数（Z 对每个 x 是常数），右边是最优策略相对于 reference 或旧策略的 log-ratio。在每一轮，πi 不更新，仅用来采样、计算 KL，并做 log-ratio 的基准。

Surrogate Loss

我们不知道最优的 π（π∗），但可以从 ref/旧策略采样，让 πθ 去拟合这个等式。也就是让上面式子尽量相等。

于是，可以构造一个平方损失，

$L(\theta)=\mathbb{E}_{\left(x, y^*\right) \sim \mathcal{D}}\left[\mathbb{E}_{(y \mid x) \sim \pi_{\theta_i}}\left[\left(r\left(x, y, y^*\right)-\mu \log Z-\mu \log \frac{\pi_\theta(y \mid x)}{\pi_{\theta_i}(y \mid x)}\right)^2\right]\right] \tag{15}$

用旧策略 πθᵢ 的样本，回归一个 log-ratio + reward 的线性关系，当 loss→0 时：πθ→π∗。

不过 μ logZ 我们并不知道，因为 action 空间巨大，不好计算。注意，它在梯度里只起到 baseline 的作用（常数），它不依赖于 y，影响方差，但不影响期望。

论文提到两种估计方法，方法一是蒙特卡洛 log-sum-exp，用 k 个样本采样近似：

$\mu \log Z \approx \mu \log \frac{1}{k} \sum_{j=1}^k \exp \left(r_j / \mu\right) \tag{16}$

方法二是，作者发现，使用抽样奖励的经验平均值效果不错：

$\mu \log Z \approx \bar{r} = \frac{1}{k} \sum_{j=1}^k r_j \tag{17}$

论文说，当温度参数 μ 变得很大时，μ logZ会收敛到在参考策略 πθi 下的期望奖励，所以用样本平均奖励去近似是合理的。根据 Z 的表达式，我们有：

$\mu \log Z=\mu \log \mathbb{E}_{\pi_{\theta_i}}\left[e^{r / \mu}\right] \tag{18}$

当 μ→∞ 时，r/μ≈0，对指数函数做一阶泰勒展开，

$Z=\mathbb{E}\left[1+r / \mu+O\left(1 / \mu^2\right)\right]=1+\frac{\mathbb{E}[r]}{\mu}+O\left(\frac{1}{\mu^2}\right) \tag{19}$

两边取 log，

$\log Z = \log \left( 1+\frac{\mathbb{E}[r]}{\mu}+O\left(\frac{1}{\mu^2}\right) \right) \tag{20}$

利用泰勒展开 log(1+x) = x + O(x^2)，得到，

$\log Z = \left(\frac{\mathbb{E}[r]}{\mu}+O\left(\frac{1}{\mu^2}\right)\right) +O\left(\frac{1}{\mu^2}\right) =\frac{\mathbb{E}[r]}{\mu}+O\left(\frac{1}{\mu^2}\right)\tag{21}$

注意，x 平方每一项的阶都是 O(1/μ^2) 或更小，因此可以吸收到二阶项，O(x^2) = O(1/μ^2)。最终得到，

$\mu \log Z = \mathbb{E}[r] + O(\frac{1}{\mu}) \tag{22}$

也就是说，当 μ 很大时，μ logZ 近似等于期望 reward。

代入式（15）求导，可得：

$\begin{aligned} \nabla_\theta L &= 2 \left(r\left(x, y, y^*\right)- \bar{r} -\mu \log \frac{\pi_\theta(y \mid x)}{\pi_{\theta_i}(y \mid x)}\right) \cdot \left( -\mu \nabla_\theta \log \pi_{\theta} \right) \\&= -2 \mu \left( r(x,y,y^*) -\bar{r} \right) \nabla_\theta \log \pi_{\theta} + 2\mu^2 \log \frac{\pi_\theta(y \mid x)}{\pi_{\theta_i}(y \mid x)} \nabla_\theta \log \pi_{\theta} \\&= -2 \mu \left( r(x,y,y^*) -\bar{r} \right) \nabla_\theta \log \pi_{\theta} + \mu^2 \nabla_\theta \left( \log \frac{\pi_\theta(y \mid x)}{\pi_{\theta_i}(y \mid x)} \right)^2\end{aligned} \tag{23}$

除以 -2μ，在 k 个 response 上的梯度就是文章给的式子，

$\frac{1}{k} \sum_{j=1}^k\left(\nabla_\theta \log \pi_\theta\left(y_j \mid x\right)\left(r\left(x, y_j, y^*\right)-\bar{r}\right)-\frac{\mu}{2} \nabla_\theta\left(\log \frac{\pi_\theta\left(y_j \mid x\right)}{\pi_{\theta_i}\left(y_j \mid x\right)}\right)^2\right) \tag{24}$

注意，该 loss 的目的在于施加一阶最优性条件，使残差趋近于 0。我们关心的是其驻点而非严格的下降路径，因此在推导中忽略整体符号和尺度常数是可以的。

式子左边看起来很熟悉，这不就是 REINFORCE with baseline 么？主要区别在于采样不是来自当前策略 πθ，而是来自参考策略 πθi（off-policy）。而式子右边就是一个 log-ratio 的 L2 惩罚，这不正是 KL 的 K2 估计^[10]么？或者说，它就是一个 K2 风格的 KL 正则。现在再结合式（5），看起来更加清楚。很多 RL 算法其实也是这个基准的变体。

价值函数

价值函数在 RLVR 场景下可能不适用，文中举了个例子：一个包含一定错误的推理步骤，可能相对于当前策略具有负优势而受到惩罚。但如果它最终能成功纠错并最终到达正确答案，它就可以从这种“试错”过程中学习到有效的模式。这种学习过程反而是应该特别鼓励的，诚如文章所言：“我们应当鼓励模型探索多样化的推理路径，以增强其解决复杂问题的能力。这种探索式训练会产生大量有价值的经验，支持模型关键规划能力的形成。我们的主要目标并不局限于在训练问题上获得高准确率，而是着眼于为模型赋予有效的问题求解策略，从而最终提升其在测试问题上的整体表现。”

长度惩罚

针对训练过程中观察到的“过度思考”现象，引入“长度奖励”抑制 token 长度的快速增长，从而提升模型的 token 使用效率。如果一组响应的 max_len = min_len，表示所有响应的长度相同，此时长度奖励=0，否则根据下式计算，

本质上鼓励生成较短的正确回答，并对较长的正确回答进行惩罚，同时明确对答案错误且过长的回复施加惩罚。

实验中发现，长度惩罚在训练初期可能会导致训练速度变慢。为缓解这一问题，在训练过程中逐步“升温”长度惩罚的策略，即训练初期采用标准策略优化而不加入长度惩罚，随后在训练的剩余阶段施加固定的长度惩罚。

采样

采用了两种采样方法提高训练效率。

课程采样：从较容易的任务开始训练，逐步过渡到更困难的任务。
优先采样：重点关注模型表现不佳的问题，按 1-成功率的比例采样。

Mimo

Mimo^[11] 的 RL 遵循标准的 GRPO，同时借鉴了几个新的实践方法。

移除 KL Loss。这是 orz^[12] 的做法。
动态采样和 Clip Higher。这都是 DAPO^[3] 的做法。

MiMo-V2-Flash^[13] 采用了一个被称为 MOPD（multi-teacher on-policy distillation）的方法，将多教师（领域）蒸馏表述为一个在线策略强化学习目标。

反向KL

学生策略与教师策略之间的反向 KL 散度损失定义为：

$\mathcal{L}_{\text {reverse-KL }}(\theta)=-\mathbb{E}_{x \sim \mathcal{D}, y_t \sim \pi_\theta\left(\cdot \mid x, y_{\lt t}\right)} \log \frac{\pi_{\text {domain }_x}\left(y_t \mid x, y_{\lt t}\right)}{\pi_\theta\left(y_t \mid x, y_{\lt t}\right)} . \tag{25}$

为什么是反向 KL？这不禁让人想起了 MiniLLM^[14] 这篇论文，请看下图：

p 是教师模型，q 是学生模型。左边是我们非常熟悉的正向 KL，右边则是反向 KL，它们的区别如下：

	正向KL	反向KL
采样	从教师模型采样	从学生模型采样
公式	D(T\|S) = E_T (log T/S)	D(S\|T) = E_S (log S/T)
特性	Mean-fitting，均值拟合	Mode-seeking，寻找众数

正向 KL，学生模型会试图覆盖教师模型的所有概率区域。如果老师有两个峰，学生会试图变胖来把两个峰都盖住。这是传统监督学习蒸馏常用的方式，也是我们非常熟悉的方式。

反向 KL，学生模型会倾向于锁定在教师模型的一个高概率波峰上，而忽略其他区域。这意味着学生模型会避免学习教师模型中大量的长尾分布，生成的结果会更加真实可靠。这非常适合 MiMo-V2-Flash 这种多领域蒸馏的情况——蒸馏每个领域教师的擅长能力。

最终 Loss 写成如下形式，

可以看到，这和式（25）是一样的。

MOPD Loss

采用来自 𝑰𝒄𝒆𝑷𝒐𝒑!^[15] 的训练-推理重要性采样，舍弃那些差异较大的 token。IcePop（冰棒）主要是稳定 MoE 训练的。MOPD 的代理损失如下：

MOPD 的优势会与其他类型的优势结合使用，

$\hat{A}_{\mathrm{MOPD}, t}=\operatorname{sg}\left[\log \frac{\pi_{\operatorname{domain}_x}\left(y_t \mid x, y_{\lt t}\right)}{\pi_\theta\left(y_t \mid x, y_{\lt t}\right)}\right]+\alpha \hat{A}_{\mathrm{ORM}} .$

这个损失来自 MiniMax-M1^[16] 的 CISPO^[4]，从标准 REINFORCE 出发，引入重要性采样比率（off-policy 与采样分布不一致）。不同的是，MOPD 是序列级别的。

MiniMax

既然刚刚提到了 CISPO，这里就再一并回顾一下 MiniMax-M1 提出的这个 RL 优化算法。MiniMax-M2 没有 paper，想来应该和 M1 差别不大（当然，我们知道 M2 用了 Full Attention）。

CISPO 我们此前在 GRPO优化在继续——CISPO和熵 | 长琴^[2] 中专门介绍过，也是观察到 GRPO 中的不当 clip 可能会将关键推理 token 剪掉，导致无法参与后续梯度更新。因此，CISPO 被设计为明确避免丢弃 token，即使是那些对应较大更新的 token，同时通过内在机制将熵控制在合理范围内，以确保探索过程的稳定性。损失函数如下（直接截博客图了）：

这里 sg 意思是将 IS 当做一种固定的 reweighting 因子，衡量采样分布和目标分布（新旧策略）之间的差异。不参与梯度就不会因为 clip 导致 update 被截断，进而导致 token update 被强行剪掉。

另外，还提出一个通用公式，引入一个按 token 的 mask，然后就可以通过超参数调优来控制是否以及在何种条件下应舍弃来自特定token 的梯度。

简单来说，就是让过分放大奖励和过分惩罚的 token 损失为0，完全不参与梯度更新，一定程度上等价于 PPO 带梯度的的 clip。

Qwen

既然回顾到这里了，也一并回顾下 Qwen3 的吧，Qwen3 发布的比较早，当时 paper 没有详细披露 RL 设计，不过后面专门发了相关论文，就是这篇 2507 Group Sequence Policy Optimization^[17]，也简称 GSPO。我们在 GRPO“第一背锅侠”Token Level X：DAPO/DrGRPO与GSPO/GMPO的殊途同归 | 长琴^[18] 中介绍过这个研究。

GSPO 引入了长度归一化，目的是解决 token 级别的重要性权重计算方式在训练中引入的高方差噪声。因此，重要性权重的单位应该和奖励的单位一致，都是序列级别的。损失函数设计如下（还是直接截博客图）：

当然，后面还有一个 token 级别的变种，这里就不贴了。由于 GSPO 仅关注序列级的似然，反而能使 MoE 的训练更加稳定（专家激活波动会导致训练无法正常收敛），这也算是一个整的外部性了。

Qwen 团队近期还发表了一篇动态 clip 的升级版本：2511 Soft Adaptive Policy Optimization^[19]，让训练更加稳定。

小结

本文我们赏鉴了几个有名开源模型的 RL 设计，除了 Qwen3，其他几个模型都是近期有新版本发布，看完就想正好整理一下。印象比较深的还是 Kimi，比较喜欢从头推导。其他的做法相对比较实践，其实另一个非常工业化的是美团，他们的 2510 Higher Satisfaction, Lower Cost: A Technical Report on How LLMs Revolutionize Meituan’s Intelligent Interaction Systems^[20] 真是延续了其技术博客^[21]的工业实践性。总之，看得很爽，写得更爽，希望你也能看得爽。

最后，附上一张 AI 整理的图，我做了一些校正。

模型 / 算法	核心优化目标	稳定性控制	新颖点	解决的痛点
EXAONE (AGAPO)	GRPO 变体 + 序列 KL	移除 Clip，保留探索性 Token	非对称采样（针对全错样本分配负奖励）	避免过度裁剪导致的探索不足
Kimi (RLVR)	KKT 推导下的 Surrogate Loss	L2 风格的 log-ratio 惩罚	隐式搜索树近似；升温长度惩罚	推理回溯能力与“过度思考”平衡
MiMo (MOPD)	反向 KL (Mode-seeking)	训练-推理重要性采样截断	多教师在线策略蒸馏	多领域专家能力精准迁移
MiniMax (CISPO)	REINFORCE + IS 重加权	Stop-gradient；门控 Mask	不剪断数据流，只剪断风险梯度	防止关键推理 Token 梯度丢失
Qwen (GSPO)	序列级策略优化	长度归一化 + 序列级似然	权重单位与奖励单位对齐	Token 级高方差及 MoE 路由波动

References

【聆听·微光】003：一位对工作迷茫的程序员的觉醒时刻

2026-01-12T15:00:00.000Z

【来访者个人档案】

身份：工作1-2年的后端开发工程师。
自述：我觉得现在的工作没有价值，时而感到迷茫。

今天通话的伙伴是 L 同学，刚毕业工作了一两年，在银行做系统，稳定的同时又备受煎熬，在工作中找不到意义和价值。同时又有自己的创业小项目，有现金流，但还无法全职的程度。L 同学是公众号的老粉丝了，看过我不少文章，他自己的创业小项目也是受《实时语音交互场景下RAG的机遇和挑战 | 长琴》这篇文章的启发。

L 同学的困惑主要是工作相关和 AI 时代如何提升性学习。从问题表面来看其实是比较容易解决的，不过在聊的时候发现，其实这些问题只是 L 同学在探索和找寻自身意义和价值过程中的自然表现，这才是根源所在。

工作的意义

关于工作和公司，我在《【聆听·微光】002：一位普通院校硕士研究生的毕业之际 | 长琴》稍微提过一下，简单来说就是，每个公司只是我们成长路上的一段合作经历，重要的是提升自己。其实，对于这一主题，我在很早之前的《AI 工程师养成记（上） | 长琴》中也有提及，文中提到三个心态：创业心态、成长心态和当下心态，其核心也是以自我发展为基准，努力做好工作。

围绕着这个中心思想，回到 L 同学的工作：没有价值、感受不到意义，而且还有各种内部“糟心事”。这是环境在告诉你：“走吧，走吧，你已经不再适合这里了”。所以，首先我非常明确地表达了这个意思。

不过同时，鉴于这个工作非常稳定，大概率可以做到退休，我给 L 同学描绘了另一种可能性：“维持现状，同时搞自己的创业小项目”。对，成年人就是什么都要，而且很多时候也并不是非此即彼，完全可以兼顾，只是彼此进展不同而已，比如有段时间忙 A，过一阵再忙 B，但整体都在往前推进。

如果确定要换工作，接下来要考虑的就是换到哪里去。我的意思是，尽量换到一个自己喜欢或者感兴趣的产品。如果可以的话，优先选择大厂。前者无需多说，大厂的考虑则包括：履历、规范性、背书、结识更多大佬，等等。不是说小公司没有这些，只是遇到的概率没有大公司那么大。而且，开发岗位相对算法岗位来说还没那么看学校和背景，也相对容易些。

但是，无论去哪里工作，我都建议 L 同学不要停止自己的独立开发活动，能自己完成从产品设计到开发，再到销售得到收入，这种能力其实是非常难得的，至少我自己就不具备（销售能力）。L 同学担心自己做了一些前端、产品相关工作，会影响自己找工作。我觉得恰恰相反，懂些前端和产品能让后端更好地做好架构设计，更好地和前端、产品沟通，这点是很多后端开发不具备的，这是 L 同学的优点。

最后，补充一点关于工作的意义。最近一些年流行提前退休，好像工作是非常痛苦的事情。确实，做一份自己不喜欢的工作，那一定是痛苦的。L 同学说羡慕我每天开开心心去上班（我在发刊词《聆听·微光 | 长琴》中提到过），其实我在转行前，也会时不时地有不那么开心的日子，但转行后好像就再也没有过了。所以，必须找一个自己喜欢做的工作（或者大部分内容是自己喜欢的），我觉得这很重要。

其实，工作本身应该属于个人“事业”的一部分，工作可能是短暂的，但事业是伴随我们一生的。在每个公司的工作经历，都应该能够为我们的事业添砖加瓦。一旦把心态从“做工作”调整到“搞事业”，可能大部分人都和我一样，没有退休计划。

AI冲击下如何学习

第二个聊的话题是 AI 大环境下的学习问题，L 同学的表现是：“难以像以前一样静下心来啃某个技术”，这不禁让我想起了《【聆听·微光】001：一位研究生在读的”reward hacker“关于学习的困惑 | 长琴》中的 F 同学，看来这是一个相对比较普遍的问题。

其实，大家可能不知道，我自己也很焦虑，前一阵子还刚写了《所爱隔山海，山海亦可平 | 长琴》给自己打气。F 同学的问题很直接：“AI 都会写代码了，而且写的那么好，那我还学什么？”是啊，相比知识那边，Coding 这边的冲击更大。其实，我自己心里早就隐约有这种意识——编程学习的方法得变了，还得赶紧变。此前，对这个问题也做过一些思考，正好 L 同学问到了，我就跟他谈了我的观点。

首先，如果想要更好地使用 AI，必须学习，而不是完全交给 AI。这个大前提明确后，剩下的就是学什么、怎么学的问题了。我觉得有两个方面是必须要学习的。

第一，架构设计。我曾经写过一阵子前后端，也负责过不少复杂项目的架构设计，我可以很明确地说，不懂架构 hold 不住复杂项目。你可能可以写一个简单的网页应用，甚至稍微复杂点都行，但更复杂的项目以及大部分的企业项目，要是不懂点架构设计知识，可能用自然语言描述都描述不清楚。这点我在《以 AI Coding 之管窥探世界之变 | 长琴》中也提到过，AI 是替代了人的双手，而不是脑子。

第二，如何用 AI 编程。对于这点，大家都是新手，以前的编程高手不学习的话也不一定能用好 AI。我自己有一些实践经验，比如写好需求文档、接口文档，分模块完成，让 AI 在不同模块下放一个设计文档，并在更新代码前先修改设计文档等等。很多 IDE 也会根据你的描述给出 Task 让你 Review，做完后还给你 Walkthrough。最近比较推荐的一篇是腾讯技术工程团队发表的《认知重建：Speckit 用了三个月，我放弃了——走出工具很强但用不好的困境 - 知乎》，里面提到了大量关于 AI 编程的认知和最佳实践，非常值得借鉴。

除此之外，最好还能懂一些通用的编程知识，比如设计模式、并发和异步编程等等，能让我们更容易看懂 AI 的设计，以及更好地和他沟通。至于特别底层的（比如操作系统这个层面）那就看个人兴趣了，能学肯定是最好的，不学看起来似乎也影响不大。

至于怎么学，架构设计方面，我建议 L 同学去找一些已有的成熟的架构设计案例，比如 donnemartin/system-design-primer 就有不少。其实仔细研究那么几个就差不多了，剩下的就是自己工作慢慢积累了。毕竟，像编程这种需要动手的，看和做还是很不一样的。

而用 AI 编程其实也一样，最好的方式就是“在实践中学习”，具体来说，是在与 AI 协作编程的过程中学习。我们可以在不懂的地方问他，也可以让他讲讲他的设计思路。

最后来说说如何静下来学。调整心态就不多说了，我觉得从操作上来看，把要学的内容分成“需要深度理解和掌握”的和“只需大致了解即可”的两类会比较好（当然你分的更细也可以）。前者毕竟是少量，那我们就必须得一点一点死磕，找自己精力最好的时候去学习。至于其他的，快速过一下也无不可。另外，在学的过程中要尝试逐步构建自己的体系，这种“构建”带来的成长感也是极为愉悦的体验，尤其是很多知识点融会贯通的时候，个中滋味诸位只能自我品鉴了。

尾声

后面慢慢聊到了我的一些经历，比如降薪转行、放弃高层管理到一线算法研究、放弃大厂职位入职初创企业等等。其实，这些看似不可理解的行为背后都有一个共同的源头：“你真正想要的是什么”。对于我来说，保持赤诚和热情不断探索技术是排在第一位的，不到万不得已的确是不想妥协。至于以后，谁知道呢。可未知，本身不也很有趣么。

也祝愿 L 同学早日找到自己“真正想要的”，那一刻，请务必告诉我。

💡 共鸣时刻

我们大多数人为了生存，不得不参加工作。
有很多人不喜欢自己的工作，每天充满痛苦。
但请别放弃探索和思考，去找寻自己内心所爱。

这是一条荆棘之路，充满痛苦和挣扎。

但我们相信已经启程的 L 同学定能找到自己内心的满足。
心有所爱，一路生花。

【聆听·微光】002：一位普通院校硕士研究生的毕业之际

2026-01-07T15:00:00.000Z

【来访者个人档案】

身份：即将硕士研究生毕业。
自述：我觉得自己决策慢、做事情慢、好像行动力不强。

今天的来访者是 J 同学，一位研三、正在找工作、即将踏入社会的、有一点迷茫但又有一些憧憬的典型毕业季同学。

J 同学读的文章是《我为什么做开源？ | 长琴》，结果被我里面说的一句话”打击“了，觉得自己可能不适合技术。这句话是这样的：

J 同学说自己就是需要嚼碎的内容，可能搞不定环境。

虽然那是我的真实想法，但这么赤裸裸的表达对一个可能不那么喜欢、同时又是技术相关专业的新人来说，可能有点过于苛刻了。还请 J 同学不要放在心上。

J 同学的问题比较典型，总的来说可以分三块：工作、能力和认知。

工作选择

其实还是工作岗位的选择问题，具体这里就不透露了。对于工作这方面，我一贯的观点就两个（只针对普通家庭、普通人）。

第一，遵从个人内心，工作有好坏但是否合适和喜欢更重要。有人就喜欢考公务员、编制，那就去考，也有人喜欢创业或者先在社会上历练，那就去闯荡。这些都没问题，大的方面来说，大家都是为社会作贡献；小的方面来说，都是在努力过自己想过的生活。

第二，工作优先去一线发达城市。这里不解释太多，相信大家都明白。越发达的城市，机会越多，也相对更加公平。当然，如果确实没机会，那优先保证能养活自己。读了 20 年书，总不能还向家里伸手吧，先打经济基础再谈上层建筑。

J 同学有点担心目标公司的口碑不太好。同学啊，你不是找对象，看啥口碑呀，打开陌陌哪儿还有啥好公司……任何一家公司都只是你成长路上的一次合作，它有需求你有能力满足需求，那咱们就合作一段时间。如果你的成长速度比公司快，总有一天你会去往新的去处（俗称跳槽）；相反，如果你的能力跟不上公司发展的需要，那你也会去往新的去处（俗称走人）。

你看，就这么简单。不要动不动就以司为家，不要命地工作。公司没了再开一个就是，你没了那就真没了。当然，这不是说我们可以敷衍工作、不负责任。相反，我们应该专心致志、集中精力、认真地把工作做好。这是对公司负责，更是对我们自己负责。难道会有人认为混一天日子是自己占了便宜？

能力提升

这里我们再谈学习，但与之前访谈不一样，我们不聊知识点。其实，我自己非常理解现在同学们的学习压力，连我自己都很有压力。实在是 AI 这个方向进展太快了，一周不看感觉就要落后了，你想想谁不得紧绷着。而学生同时还需要忙学业、要写论文、要找工作，更糟糕的是学校学的可能已经落伍了，还要自己去找想办法找学习资料。而现在的资料浩如烟海，新人哪里来的辨别能力，从”大海“里捞出最值得投入去学的。那不只能看哪个火看哪个，结果反而可能浪费了大量时间，却对找工作和工作都没有帮助，事倍功半。想想这压力，得亏我自己当时的技术发展不是这样，不然以我的性格，估计焦虑的每天觉都睡不着。

我给 J 同学的建议是，停止一切花里胡哨的教程、资料的学习，只专心干一件事——研究透一个具体的 Case。因为 J 同学的方向是产品，这个 Case 就是某个产品，可以是目标公司的产品，也可以是自己喜欢的某个产品。研究它的功能、设计、市场、运营、用户、竞品等等，把它研究到和它的产品经理、产品负责人差不多熟悉或比他们更熟悉的情况。只要研究透彻一个，产品力绝对大幅提升，比看任何教程和资料都管用。

我告诉 J 同学，这可能是普通院校同学要在激烈竞争环境中脱颖而出的唯一方法。这个方法也可以用到其他方向，比如算法，把 verl 研究透比一万个玩具教程都管用的多。况且，退一步讲，即便暂时没有脱颖而出，这个过程的收获也是相当丰厚的。

自我认知

从开始到结束，J 同学几次提到自己”决策力、行动力不足，每次做什么事情都要思考很久“这点，J 同学觉得这是自己的缺点。但是根据我们交流的情况看，这其实和其”考虑比较周全，很容易站在对方角度考虑问题“有关，我觉得这不是缺点。

另外，交流时还发现 J 同学会下意识地给自己贴标签，很容易否定自己，比如刚刚提到的，还比如觉得自己学不会某个东西、甚至配置不了环境等等，表现出来不是很自信。

我很理解 J 同学这种状态，毕竟自己也曾在某些方面表现出过相当的不自信，我觉得这是正常的，是人在面对未知或不熟悉事物时的一种自然反应，无需放在心上。当然，也可能源于自己不太好的出身、背景、履历等。

我告诉 J 同学，不要总想竞争，竞争是很惨烈的，而且很多方面咱确实比不过。再说，即使比过了，那还有更厉害的呀，这会让人压力很大、很累。那应该怎么做呢？去逐步构建自己的护城河。那是综合你——愿意做的、擅长做的、包含你独特风格的——个人品牌，它可以长期积累、它可以提供价值，它是你个人专属的护城河。

所以，不要竞争，要想方设法去构建属于你的独一无二的护城河——既成全自己，也更具价值。

尾声

我们还聊了很多，总共一个小时多点。我觉得自己还是有点话太多，有些地方说的也比较虚，比如理想、信念之类，对当下的 J 同学来说，可能还有点为时尚早。不过总的来说是一次愉快的交流，结束后，J 同学给发了感谢，非常礼貌，并总结了一下收获：

我觉得总结的很到位。祝 J 同学得偿所愿！

💡 共鸣时刻

从学校到社会，是每个人生命中重要的分水岭。
每个人起点不同，其实不止现在，时时刻刻如此。
但每个人都可以通过努力形成自己独特的的护城河。

做自己、认可好的自己、也接纳不好的自己。

J 同学只是万千普通同学中的一个，但也有属于自己的独一无二。
我们平凡，我们也伟大。

从平面国到硅世界：当文明被困在自己的维度里

2026-01-06T15:00:00.000Z

今天看完了《平面国》，一本著于 1884 年的小书，一本看似讲物理，其实讲社会和人类的书。

一千个人眼中有一千个哈姆雷特，同样，每一个人看书都会有自己不同的视角和理解。当下，正值 AI 迅猛发展的时刻，一切的一切看似都在往好的方面发展，我前几天才写完《以 AI Coding 之管窥探世界之变 | 长琴》，今天看完这本书，又有了新的理解。本文尽量谈一些观点和认知层面的，避免剧透。

平面国的主角是一位二维世界的正方形，前面大部分内容都在介绍二维世界是怎么运行维系的。后面才开启了先到一维，再到三维、零维，想去更高维，但最终回到二维的一段经历。

本世界

其实整本书还是以二维视角展开的，读的过程中，我们会很容易就将其中的一些“设定”带到我们所处的世界。二维世界有它自己的规则，物理规则倒是其次，主要是社会规则。上层阶级对底层阶级的控制、底层阶级表现出来的特性、不同性别之间的对立……一整套生来就在，鲜有人质疑其合理性的运转规则。而且，随着时间的推移，这套规则愈发无瑕、愈发坚不可摧。看的时候感觉好像自己开了上帝视角在看一个世界（或宇宙），内心涌起一股悲凉的同时不由心想，从宇宙太空看地球，从更高维度看人类，是不是也是如此。那里面关于社会的一切一切，即便这么多年过去，还不是一样可以一一映照在当下。那继续往“上”呢？是否真的有那至高？

跨世界

后面的维度旅行，给人印象最深的唯有两个字：“固执”——无论如何都无法相信更高维度的存在，或者说，不愿意相信超出自己认知的存在。我们在深感无奈的同时也不由得后背发凉——我们是不是也是如此，从某一天开始，认知就被锁死在一个安全区域，超出这个区域的要么被视为大逆不道，要么不屑一顾？请试想一下，你是否只和自己观点相近的人交流？是否难以接受他人的反驳和批评？是否听到不同声音会下意识否认或假装没听见？是否爬到比较好的位置就忘了曾经的迷茫和落魄？或者说，自己一路风顺就根本就不知道这世上还有那么多人“何不食肉糜”？

“固执”的背后唯有两个字：“傲慢”，这两个字是那么的不显，以至于很多人其实都没意识到。但你仔细一想，可不是么，刚刚提到的那种固执可不是另一种形式的“唯我独尊”？这不是傲慢又是什么。《三体》里面有句很经典的话：“弱小和无知不是生存的障碍，傲慢才是”。我们傲慢，仍不自知呀。

人世界

物理上的东西确实比较好玩儿，低维世界的生物也的确非常难以理解高维世界的情况。不信让我们尝试从三维到四维，我们要如何想象一个四维生物能看到并触碰到我们的内脏呢？这可能也是每个世界生物的局限性吧，再想想《三体》的程心，我们看书时在上帝视角，自然觉得她圣母，但若自己身处其中，是否也能看得清真相？《三体》中又有几人能看清真相？程心被骂圣母，但她难道不是千千万万个大众的“代表”？如果大众都是清醒的，程心不就是个普通人。

好在人类还有自身最宝贵的东西：求知欲和理性。注意，这里的求知欲是广义上的，而不仅仅指对某个知识点的欲望。最基本的可谓是哲学三问：我是谁？我从哪里来？我要到哪里去？有了求知欲，人就会去探索、去思考，去变得理性。这是对抗傲慢的唯有效一方法。

我觉得一个社会和文明的进步与否，不能光看物质层面，更应该看非物质层面——人民大众是否提升了自己的求知欲和理性。这几天在读韩非子，我被古人的智慧折服，同时，也真没有感觉到这么多年过去，人类在思想深度上有太多进步。

硅世界

科技在飞速发展，AI 日新月异，世界正在巨变。

我好像看到了互联网被攻占，里面几乎全是 AI 生成的内容。

我好像看到了《The IWM 1000》中的机器，人类可能不再需要学习任何知识。

我好像看到了虚拟世界正在和现实世界重叠，虚和实彼此融合。

我好像看到了真实世界正在被攻占，硅基智能充斥人类社会。

我不知道未来会怎样，是更好，还是更坏？

等等，什么是“好”，什么是“坏”？

平面世界的生物觉得平面国是好，其他世界是坏。那么，三维世界的人类呢？

如果把“维”从物理维度换到其他，比如 AI 呢？

【聆听·微光】001：一位研究生在读的”reward hacker“关于学习的困惑

2026-01-03T03:00:00.000Z

【来访者个人档案】

身份：研究生在读，大模型方向实习生。
自述：我是个 Reward Hacker，为了面试通过，我刷题、背八股，但我心里慌。

2025 年 1 月 2 日，昨天发完小红书后，今天迎来了第一位小伙伴。

第一位小伙伴（我们后面称他为 F 同学）就和我想象中的不一样，我本来以为他会问关于大模型和相关工作的问题，没想到他更加关注的居然是 ”学习“ 问题。他看的博客是《Hybrid LLM 之 Gated DeltaNet | 长琴》。

关于学习的困惑

F 同学目前正在实习，应该是还不错的机构。我们的对话从他最近的一个困惑开始。F 同学的组长让他去调研一个框架，但组长自己也不知道这个框架，F 同学感到没有人手把手指引，和自己想象的不太一样，压力很大，不知道从何做起。

顺便就引出了他关于学习的第一个问题：面对一个知识点，如何进一步深入学习？他发现自己现在习惯阅读别人解读的文章、视频，或者把论文丢给 AI 让 AI 输出结果，要自己看却有点看不下去。

紧接着是第二个问题：如何学习一个框架，他发现看了 README 的基本用法后就不知道后面怎么去学了，好像也没有地方去找更多其他用法或者高级用法。

面向工作学习

这里有个背景，F 同学也是中间转行到大模型方向，之前本来是要做后端的，但大模型实在太火爆了。虽然谈不上多喜欢，但给的多啊。他为找工作做了很多准备（包括代码、知识点等），取得了很好的成绩，不过他谦虚地称自己是 reward hacker——面向面试和找工作的学习。

虽然我还没有聊过很多人，但据已经了解到的信息，像 F 同学这样冲着 ”大模型工资高“ + ”面向找工作学习“ 的同学应该不在少数。

听到他这么说，其实我本想聊聊类似 ”要找到自己喜欢做的、热爱的事业“ 之类的话题，但转念一想，再丰满的理想也得面对现实啊。况且，理想这东西又岂是一时半会能想出来的。如果本来就有坚定的理想，那还找我聊什么，还能有什么困惑。再说，理想也不是一下就明朗的，还不得随着经历和阅历的增加逐步清晰的？

所以，我非常赞同他目前的这种选择，这是当下对他来说理性的最优选择，除非真的是非常讨厌这个方向。F 同学可能也并不一定喜欢这个方向，但他至少不讨厌、不厌恶，这已经很好了。

进入职场与长期主义

心态调整

回复问题之前，我首先提示了一个心态问题——即便老师都未必能手把手教你，又怎么能期待同事呢？其实 F 同学的这种感受我在刚入行时也经历过。后来才慢慢意识到，在职场上，能遇到这样的那是运气，遇不到才是正常现象。大家都很忙，metor 也有大量自己的工作要做，他能在方向和关键点上指点一下就已经相当不错了。及早把心态调整到位，反而能把主动权抓回自己手里。

关于知识点学习

其实，怎么说，我虽然也有一定的自学能力（经济学工作几年后转行），但肯定比不上清北的同学，智商也就中等水平，也给不出什么建议。我只是跟他分享了我当时并保持至今的一些做法，看看是否能对他有所启发。

首先是读第一手资料。这是我保持至今的习惯，几乎不读任何别人写的解读类文章。只有当自己阅读完一手资料（一般是论文）之后，才会看情况是否要去阅读其他资料。另外，我也很少读中文社区的资料，不过大模型时代中文社区感觉比英文社区要好。
其次是一开始要有耐心，去积攒自己的“点”。F 同学谈到自己看到一个知识点可能没有很多想法，只是把别人的解读读完感觉好像就没了。这是正常的，刚开始的知识都是零散的，只有你不断地积累，才能慢慢连点成线，以线扩面，形成体系。这是一个逐步构建自己知识体系的过程。其实，这个认知我早就有了，但前几年真的是无奈，盲点太多了，根本连不起线。大家看我前几年的博客就知道了。
最后是谨慎接受碎片化输入、标题党（几分钟搞懂 XX）教程或小白教程。我自己是不刷抖音的，也很少刷社交媒体，刚刚说了，二手资料都很少看。如果确实要系统学习某个东西，我会找卡内基梅隆、MIT、斯坦福等学校的相关课程（比如陈天奇的《深度学习系统》）。这可能是我个人的一个“笨办法”——只啃一手资料。我也知道短视频和通俗解读有时候很诱人，但对于构建知识体系来说，它们像是零食，好吃但不管饱。

关于框架使用学习

我的回复比较简单，直接去用。我自己是这样，除了写相关教程或者系统研究，从没有专门学习过某个框架。一般的做法是看一下基本用法，然后就开始用了，遇到问题再去查，查不到就去看源码（这个是我最喜欢的方式，比任何文档和答案都清晰，一目了然）。包括编程也是，大部分语言都是找本书大概看下语法后就直接上手写了。

其实就是第一门语言比较磕磕碰碰，第二种以后就比较快了。这和工具一样，你脑子是清晰的，只是不知道怎么用这个框架或语言表达而已，用一下就会了。我举了骑自行车、游泳和学开车的例子，你不需要知道摩擦力、前后轮驱动原理这些知识，你只是在“用”它，去用就可以了。

不过如果是学习一个框架或语言本身，那是不一样的。以框架为例，我的建议是：首先把一个例子跑起来，然后研究输入输出、每一个指标的意义、每一个参数的用法和含义、关键模块背后的设计思想等等。这能极大提升自己对框架和相关算法的理解，这远比跑完一组实验、跑出一个结果更重要。

尾声

聊完问题，我们还聊了一些其他的，比如为什么现在年轻人精神压力这么大，比如如何更好地面对越来越浮躁的社会等等，我也向他说明了我做这件事的初衷（这个后面会专门写一篇聊一下）。我们大概是五五开吧，可能他比我说的稍微多一点点，其实我应该更克制一点。

总之，祝福 F 同学，希望他能健康、快乐，走出自己精彩的人生！

💡 共鸣时刻

学习是手段，其背后的目的是我们都渴望成长，
但首当其冲的现实是我们得找到一个好工作。

F 同学不是一个人，我们很多人都是那个 “Reward Hacker”。

其实无论是沉不下心也好、急功近利也罢，
都是我们面对压力时的自我救赎啊。