[{"c":"AgentRx 提出了一种新的归因框架，但总体来说，该框架还是分为标记错误、归因识别关键错误这两步。 AgentRx 将错误分类为 9 种（$K_1$–$K_9$）：指令/计划依从失败、意图–计划失配、捏造新信息/幻觉、无效工具调用、工具输出误读、用户意图说明不充分、意图不受支持、触发护栏、系统故障。 AgentRx 接收以下输入：(i) 包含输入–输出模式的工具集 $\\mathcal{T}$，(ii) 可选的领域策略 $\\Pi$，以及 (iii) 失败轨迹 $T=\\langle s_{1},\\dots,s_{n}\\rangle$。每个步骤 $s_{k}$ 包含多个记录事件，带有智能体名称、工具名称、步骤索引、工具输出或自然语言对话内容等字段。 其中 AgentRx 将不同框架的日志统一为通用中间表示（IR），解析附录的日志后发现，AgentRx 针对不同的框架做了统一适配，换到新框架时仍需要调整日志适配器。 令 $T_{\\leq k}$ 表示截至并包含步骤 $k$ 的轨迹前缀，AgentRx 根据工具 schema、领域策略和轨迹前缀生成可执行约束，逐步评估这些约束以生成可审计的验证日志 $V$。基于 LLM 的裁判结合 $V$ 和分类清单 $K$ 来预测根因步骤 $\\hat{s}$ 和类别 $\\hat{y}$。 首先 LLM 针对工具 schema 和可用的领域策略生成全局约束 $\\mathcal{C}^{G}$，存入全局存储 $\\mathsf{G}$。在每一步，根据任务指令 $I$ 和已观察前缀 $T_{\\leq k}$、以 $\\mathsf{G}$ 为上下文产生动态约束 $\\mathcal{C}^{D}_{k}$，存于局部存储 $\\mathsf{L}_k$。步骤 $k$ 的可用约束为 $\\mathcal{C}_k:=\\mathcal{C}^{G}\\cup\\mathcal{C}^{D}_k$。 守卫 $g_{C,k}=G_C(T_{\\leq k},s_k)\\in\\{0,1\\}$ 判断约束是否适用。为 0 时跳过，为 1 时执行断言 $\\phi_{C,k}=\\Phi_C(T_{\\leq k},s_k)\\in\\{\\text{sat},\\text{viol}\\}$。断言可以由程序检查，也可以由 LLM 判断。步骤 $k$ 的评估为： $$ \\text{Eval}_{C}(k)=\\begin{cases}(\\text{skip},\\emptyset)\u0026\\text{if }g_{C,k}=0,\\\\ (\\phi_{C,k},e)\u0026\\text{otherwise.}\\end{cases} $$ 跑完所有步骤后，我们只关心到底哪几步违反了哪条规矩，证据是什么。这就是验证日志 $V$ 的集合表达式： $$ V\\;:=\\;\\{(k,C,e)\\mid C\\in\\mathcal{C}_{k},\\ G_{C}(T_{\\leq k},s_{k})=1, (\\text{viol},e)=\\text{Eval}_{C}(k)\\}. $$ LLM 裁判结合任务指令、轨迹、分类清单和验证日志，输出关键故障步骤与根因类别。 AgentRx 与适配版 W\u0026W 的对比结果如下： 表 1：各数据集上的故障归因准确率对比。我们在故障智能体和关键步骤定位准确率上对比了适配版 W\u0026W（W\u0026W*）与 AgentRx。数值为 3 次运行的均值 $\\pm$ 标准差。 AgentRx 在各领域的步骤定位准确率都有提升，在多数设置中的责任智能体识别也有所改善。这里对比的是 W\u0026W 的方法：论文将 AgentRx 基准中的轨迹转换为 W\u0026W 所需的格式，并调整提示词，让 LLM 在日志中定位首个不可恢复的故障步骤。","d":"AgentRx 智能体故障诊断与约束验证阅读笔记。","dt":"2026-11-11","s":"blog","t":"AgentRx: Diagnosing AI Agent Failures from Execution Trajectories","u":"/zh/blog/agentrx-notes/"},{"c":"Blade BLADE 通过 Jev 来进行模型的归因，它将整个流程分为三步，值得注意的是三个阶段的归因都是由 Jev 来进行决策的，下图为 BLADE 的框架。 图 1：BLADE 概览。(1) Jev 重构事件间依赖。(2) 依赖关系选出待审计交接处，Jev 对照任务需求片段 $R$ 检查每个智能体决策如何使用信息源。(3) 诊断结合责任图 $G=(V,E,R,F)$ 读取完整轨迹；每个事件均保留为候选。 方法 BLADE 首先将事件定义为 $e_i$，定义四种事件依赖关系：依赖（depends on）、重复（repeats）、矛盾（contradicts）与修复（repairs）。事件与事件的关系交给 Jev 来做选择（还多了个 None 选项），令 $\\mathcal{R}_{\\mathrm{link}}$ 表示四种关系类型，令 $x_{t,r}$ 表示事件 $e_{t}$ 处针对关系 $r$ 的提问。分配给较早事件 $e_{u}$ 的概率为 $$ p_{ut}^{(r)}=P_{\\mathrm{Jev}}(e_{u}\\mid s_{\\tau},x_{t,r}). $$ Blade 保留概率至少为 $\\theta=0.3$ 的关系，形成加权边集 $$ E=\\bigl\\{ (e_{u},e_{t},r,p_{ut}^{(r)}):u \\lt t, r\\in\\mathcal{R}_{\\mathrm{link}},\\ p_{ut}^{(r)}\\geq\\theta\\bigr\\}. $$ 由于不是每种依赖关系都是有用的，若将合格的依赖关系都拿来建边，则需要 $O(N^2)$ 的复杂度，Blade 采用 depend-on 分布优先选择来建边。对每个事件 $e_{t}$，令 $\\mathcal{U}_{t}=\\{u \\lt t:p_{ut}^{(\\mathrm{dep})}\\geq\\theta\\}$，其中 $\\mathrm{dep}$ 表示 depends-on 关系；令 $\\mathcal{S}_{t}\\subseteq\\mathcal{U}_{t}$ 为其中 $p_{ut}^{(\\mathrm{dep})}$ 最高的至多 $K=2$ 个信息源索引。选定的交接处为 $$ \\mathcal{H}_{t}=\\bigl\\{(e_{u},e_{t}):u\\in\\mathcal{S}_{t}\\bigr\\}, $$ 且 $\\mathcal{H}=\\bigcup_{t=2}^{T}\\mathcal{H}_{t}$。审计规划复用了依赖概率，无需额外的模型调用。每个交接处 $(e_{u},e_{t})$ 承载隐式语义契约：接收端应保留信息源含义、避免将不确定信息视为既定事实，并遵守任务需求。与形式化契约验证不同，这些义务通过结构化语义判定来评估。BLADE 从任务 $q$ 中提取需求片段 $R$，并将其与完整轨迹一起纳入审计状态 $s_{\\tau,R}$。 通过 Jev 将每个事件分类为智能体决策或证据，记作 $\\kappa(e_{t})$，并评估每个选定的接收端事件 $e_{t}$ 如何使用其信息源 $e_{u}$。对于提问 $x_{ut}^{\\mathrm{use}}$，Jev 在九个预定义标签 $\\mathcal{L}$ 上分配概率： $$ p_{ut}(\\ell)=P_{\\mathrm{Jev}}\\big(\\ell\\mid s_{\\tau,R},x^{\\mathrm{use}}_{ut}\\big),\\qquad\\ell\\in\\mathcal{L}. $$ 其中 $\\ell_{ut}$ 为概率最大的标签，$\\pi_{ut}$ 为其对应的概率。标签用于区分潜在的错误引入、现有错误的继承或修复，以及未产生保留发现的情形。标签划分为三组，$\\mathcal{L}=\\mathcal{L}_{\\mathrm{kept}}\\cup\\mathcal{L}_{\\mathrm{breach}}\\cup\\mathcal{L}_{\\mathrm{inh}}$： $\\mathcal{L}_{\\mathrm{kept}}$ 代表忠实使用、未实际使用该信息源，或证据不足以评估该交接处。 $\\mathcal{L}_{breach}$ 代表通过未经核实的采纳、适用不当的信息、曲解或引入新错误的修正，所造成的潜在错误引入。 $\\mathcal{L}_{inh}$ 代表现有错误的传播，或在不引入新错误的前提下进行的修复。 对于进入智能体决策的交接处，BLADE 将非保持（non-kept）的判定保留为结构化发现。令 $\\mathcal{H}^{\\mathrm{dec}}=\\{(e_{u},e_{t})\\in\\mathcal{H}:\\kappa(e_{t})=\\mathrm{decision}\\}$。所得的发现为 $$ F=\\bigl\\{ (e_{u},e_{t},\\ell_{ut},\\pi_{ut}): (e_{u},e_{t})\\in\\mathcal{H}^{\\mathrm{dec}},\\ \\ell_{ut}\\notin\\mathcal{L}_{\\mathrm{kept}}\\bigr\\}. $$ 通过以上的构建，Blade 将 Traj 构建为责任图：$G=(V,E,R,F)$，其中 E 为依赖关系边，V 为节点，R 提供用来评估这些交互的任务需求。 给定任务 $q$、完整轨迹 $\\tau$ 以及责任图 $G$，Jev 回答与 All-at-once 基线相同的决定性步骤问题，该问题通过结构化责任证据得到了增强： $$ \\hat{t} =\\arg\\max_{t\\in\\{1,\\dots,T\\}}P_{\\mathrm{Jev}}\\bigl(e_{t}\\mid q,\\tau,G\\bigr), \\hat{a} =a(e_{\\hat{t}}). $$ Blade 在评测数据集的表现如下表： 表 1：无参考答案条件下的智能体与步骤准确率（%）。所有方法均在同一个 Jev 决策接口下实例化（附录 B.2）。HC：人工设计（Hand-Crafted）；AG：算法生成（Algorithm-Generated）。宏平均（Macro Avg.）对五个子集赋予同等权重。粗体表示最优，下划线表示次优。 Blade 通过完全由 Jev 来进行归因，达到的快速、低成本的归因方式，但是我想如果在构建好了责任图之后由 LLM 来决策，效果会不会更好一些，因为推理模型在长上下文、结构化的语言组织上可能具备更好的归因能力。实际上，Jev 的决策只能归因到一个具体的模型，而某些错误可能是多种错误信息结合而成，Jev 的输出导致其只能局限在单一智能体。 同时，Blade 的测评框架不具备泛用性，针对于不同的 Harness 框架需要做一些微调。","d":"BLADE 多智能体故障归因与信息使用审计阅读笔记。","dt":"2026-11-10","s":"blog","t":"BLADE: Auditing Information Use for Failure Attribution","u":"/zh/blog/blade-notes/"},{"c":"存在的问题 Who\u0026When（WW） 的数据集评测方式其实是有问题的，WW 的具体表现形式为： 输入：一份完整的失败会话日志，记录了从用户提问开始，多个智能体按轮次交互，直到最终给出错误答案（或触发最大重规划轮数等停止规则）的全过程。 任务要求：让大模型阅读日志，找出导致任务失败的最早的、唯一的一个责任智能体和唯一的一个步骤。 决定性错误步的定义：如果把智能体在这一步的错误动作替换成正确动作，后续的轨迹就能顺利走向成功。 但是作者发现，对于 WW 数据集中的轨迹，并没有表明步数，也就是每一步都需要大模型去记忆推断；同时交给 LLM 的判罚尺度与专家标注的尺度不一致，给 LLM 的 Prompt 里面嵌入了给人类专家的一句简介的指南提醒 明确告诉模型：要找的是最早导致任务偏离正轨、且若修正就能成功的决定性步骤。 完成以上两步后，在包含标准答案的 WW 手工构建集上，GPT-4o 的步骤归因准确率就从原来的 6.04%飙升到了23.56%。 继续往下探索，WW 数据集的归因方式或者说归因角度太过于单一，对于多种错误中挑选出一个绝对错误本来就是不确定的，这导致 LLM 可能与人类专家标注的不一致，但其实两者都可被认为是关键错误；多智能体还会存在智能体之间的责任模糊，即子智能体出错，可能是自身问题、也可能是分配任务的智能体描述不当造成，在这种情况下，只把错误归因于一个智能体是片面的。 Dover 针对于以上问题，作者提出了 Dover，核心框架可简要说明为三个部分： 撇弃人类专家标注的 GT，因为可能存在多视角错误（类 MP-Bench），Dover 回到了决定性错误的定义身上，直接修改 $t$ 步的决策，由此看后续的任务是否可以完成，如果完成，则证明该步时决定性错误。 对于一个长 Session 里面的多个 React 循环，可能多个 trail 都是错误的（因为 LLM 可能先去试错），Dover 针对于每个 trail 都单独划分，然后从每个 trail 里面去找错误点，这样在缩短上下文的同时还可以针对失败任务进行不同路径的修复。 图 1：WW-HC 中案例 3 的失败轨迹，展示了故障归因中的内在模糊性。该会话包含四个独立的试验轮次，每个轮次由一次计划更新启动并通过 ReAct 式循环（Yao et al., 2023）执行。不同策略（例如第 1 轮中的直接滚动浏览与第 2 轮中的日历导航）产生各自独立的错误点，使得在全会话中进行单步归因在本质上充满歧义。第 2 轮（第 53–55 步）进一步展现了智能体间的协同失调：编排器发出了无效指令，而 WebSurfer 则通过执行无关动作放大了错误。 主管（Orchestrator）和子智能体（Sub-agents）之间的责任往往纠缠不清，DoVer 在做干预时，明确划分了两个层次的修复手段： 直接修改主管的计划或者发给子智能体的 Prompt。 子智能体无法完成，可能是因为工具缺失，通过创建新工具来辅助任务完成，这一步是直接修改 Harness 框架了（可以联接到 RSI 这一方面） 图 2：DoVer（先做后验，Do–then–Verify）调试管线。(1) 试验切分：以重新规划步骤为切分点，将失败会话日志拆分为若干轮次；(2) 故障归因：针对每个轮次，提出标定故障步骤或智能体的假设 $h_i$；(3) 干预生成：将 $h_i$ 转化为可执行的干预，编辑原日志中的计划、被归因消息或步骤；(4) 干预执行：就地（in place）重放轨迹，即保留干预步之前的所有步骤，执行干预并度量新日志的进展。颜色标识：计划/重新规划（蓝色）、执行（绿色）、归因故障（红色）、终态失败（深红）、终态成功（深绿）、干预（黄色）、新计划/重新规划（蓝斜线剖面）、新执行（绿斜线剖面）。 Dover 分为四步： 试验切分：以智能体系统自我反思后的“重新规划步”为切分点（图 2 中的蓝色方块），把一条冗长的完整失败轨迹 $\\tau$ 切分成若干个独立的 Trials。这样做可以缩短上下文、支持并行干预、多路径修复。 故障归因：针对一个试验轮次 $\\tau^i$，使用 LLM + Prompt 生成候选故障归因假设 $h_i$，且 $h_i = (\\hat{a}_{\\hat{t}}^i, r_{\\hat{t}}^i)$，其中 $\\hat{a}^i$ 是嫌疑智能体，$r_{\\hat{t}}^i$ 是自然语言写成的错误分析。 干预生成：将 $h_i$ 转化为 $\\hat{t}$ 步上下文的具体、最小化的文本编辑操作 $I_i$，其中操作分为上面提到的两类。 干预执行：将系统状态回滚恢复到第 $\\hat{t}$ 步之前的快照 $\\sigma_{\\hat{t}}$，用干预生成的新消息 $I_i$ 替换掉原本的错误消息 $m_{\\hat{t}}$，然后继续执行。 指标 施加干预并重跑后，最终成功解决任务的试验运行占比，但对于没有成功解决的，也需要衡量决策是否让任务执行更正确了。论文通过：对于带有人工标注解题步骤的数据集（如 GAIA），先用 LLM 从人类标准解题过程中提取出最多 $K \\le 5$ 个与具体工具无关的关键里程碑 $\\{\\mathbf{m}^1, \\mathbf{m}^2, \\dots, \\mathbf{m}^K\\}$，对于任意一条执行轨迹 $\\gamma$，用 LLM 裁判比对它完成了几个里程碑： $$ A(\\gamma) = \\sum_{k=1}^K \\mathbb{I}\\left[\\text{轨迹 }\\gamma\\text{ 达成了里程碑 }\\mathbf{m}^k\\right] $$ 比较干预后的新轨迹 $\\tilde{\\tau}_I$ 与干预前的原失败轨迹 $\\tau$： $$ \\text{Prog}(\\tau \\to \\tilde{\\tau}_I) = \\frac{A(\\tilde{\\tau}_I) - A(\\tau)}{K} \\in [-1, 1] $$ 论文为了保持 LLM 是否真的按照 $I_i$ 走下去，还设置了 LLM-as-Judge 来判断是否一直符合修正后的要求，并划分了四个验证状态。 表 1. 干预后故障假设的验证结果类别。 验证结果类别 判定条件（基于 3 次独立重跑） 1. 验证通过 3 次重跑中，至少有 2 次完全成功解决任务。 2. 部分验证 成功次数 $\\lt 2$ 次，但至少有 2 次同时满足： ① 忠实执行了干预 ② 里程碑进展度 $\\ge +20\\%$ 3. 驳回 / 证伪 成功次数 $\\lt 2$ 次，且至少有 2 次同时满足： ① 忠实执行了干预 ② 里程碑进展度 $\\le +20\\%$ 4. 未决 不满足以上三种的所有其他情况 实验 论文中数据集的分布 表 2：各数据集上的失败与干预案例汇总，列出了总案例数、失败案例数、干预案例数、干预试验总数以及每案例的平均试验轮次数。 故障翻转为成功的表现： 表 3：各设置下故障翻转指标的实验结果。表中报告了干预试验数、试验成功率以及平均取得的进展度。 值得注意是：在包含大量高难度任务的 WW-AB 上，进展度为 +0%，说明在极端困难的任务上，不当的干预有时甚至会干扰原有进度（负进展抵消了正进展）。 故障假设的验证分布： 表 4：各数据集上故障假设的验证结果分布。表中报告了分类为验证通过、未决、部分验证或驳回的试验数量与百分比。 可以看到，在困难数据集上，单凭框架无法进行有效提升。 自我改进 这是作者期待的两个未来方向。在论文中，作者通过人机协同，优化并添加了一些工具，使得智能体在高难任务的表现得到有效提升，但我认为应期待：(i) 完全自动化的调试闭环（即 RSI），其中 DoVer 的洞察反馈给自动化的子智能体改进（例如利用代码智能体来实现修复）；(ii) 具备能力感知的干预生成，当不允许修改代码时，允许 DoVer 根据已知的子智能体能力边界量身定制干预措施。这两个方向均有助于实现构建鲁棒、自我完善的多智能体系统的目标。 总结 Dover 这篇工作给出了范式提升，不再是一味的检测判断，而是通过怀疑-重放-验证的步骤来锁定关键错误步，与此同时，Dover 也指出了 ReAct 框架下，针对单一动作的错误归因本身就是片面的；更重要的是，Dover 给出了后续工作的一些启发，就像我在自我改进篇章里面说的那些内容。 但 Dover 依然有许多不足。首先就是 Dover 里面的验证、归因方法实际上在真实场景下无法发挥，原因是 Dover 给调试模型的 Prompt 中是含有真实答案的，即 Judge LLM 实际上是带着答案找错误的，后续 Dover 计算里程碑进度的时候也是通过人类手写的标准步骤来进行计算的，然而在真实场景下并没有类似的标准答案，因此缺乏真实可用性。 引入 PRM 代替 Judge LLM with GT，训练专门进行中间打分的 PRM，通过检测轨迹中的逻辑自相矛盾、死循环或空结果幻觉来触发无监督归因。 可以考虑动态需求图来代替人类的标准步骤，在任务开始时，先用一个规划分解模型将用户的原始 Query 自动拆解为一个带验证条件的子目标有向无环图（Sub-goal DAG）（如：先验证数据源存在性 $\\rightarrow$ 再验证字段完整性 $\\rightarrow$ 最后计算结果）。重跑时直接用子目标的完成度来计算 Progress Made，彻底摆脱对人工标注步骤的依赖。 同时，Dover 的 Token 开销太大，对于一条失败的轨迹，Dover 需要开辟 4 条以上的路径进行重放，更多地，对于一个 Trial 来说，Do","d":"DoVer 多智能体故障归因、干预与验证的阅读笔记。","dt":"2026-11-06","s":"blog","t":"DoVer: Intervention-Driven Multi-Agent Debugging","u":"/zh/blog/dover-notes/"},{"c":"观念 本文章的核心观点是：给定一失败轨迹 $\\tau = (x_1, x_2, \\dots, x_N)$，目标是找到关键错误步 $t^\\star$，作者把最早发生的、对最终任务失败负有直接因果责任的那个错误步骤（如果当时把这一步改对，后面的连锁崩盘就不会发生，任务就能成功）作为 $t^\\star$。 对于 Who\u0026When 这种直接塞给 LLM 失败轨迹的测试来说，由于上下文太长、局部错误很多、一步错步步错的原因，直接去测评通常性能不高。 图 1：关键错误及其级联影响示例。 方法 图 2：TrajDebug 错误生命周期追踪框架概览。 多粒度历史压缩 TrajDebug 让大模型对轨迹中的每一个 step 分三个颗粒度划分： 表 1. 多粒度历史视图的内容与字符上限。 视图级别 代号与字符上限 保留内容与作用 高细节视图 th1 $\\le 3000$（字符/字段) 几乎原汁原味：保留原始指令、动作、环境观察和局部推理片段。只删掉明显的废话、重复句式和装饰性格式，用于当前步及紧邻步骤的精细证据核验。 中细节视图 th2 $\\le 1200$（字符/字段) 骨干摘要：合并相关信息，省略次要的展开说明，但保留该步的主要意图、具体动作、状态更新、错误报错和关键观察，用于中等距离历史上下文。 低细节视图 th3 $\\le 600$（字符/字段) 极简浓缩：用最少的词仅记录粗略进展、核心实体以及未解决的承诺/硬约束，用于遥远的历史背景。 其中，压缩过程有两条约束： 针对原有约束和计划进行保留，三个粒度均需要保留 user 的约束或计划（如 禁止做某事，子目标计划） 关键的 Token 需要保留原样，不可压缩或简化（即针对特有名词如 商品/订单 ID、工具函数名） 错误触发点检测 LLM 检查第 $t$ 步的时，它所得到的上下文由以下规则组成，该规则可以有效减少上下文长度： 对于 $Step_t$ 的内容，采用 th1 即原内容。 对于 $Step_{t-x} \\to Step_{t-1}$ 采用 th2。 再往前的历史内容采用 th3。 对于检查出来的错误，LLM 以以下形式输出： $$ e = (t, c, p, q_w, q_r) $$ 其中，$t$ 为步骤、$q_w$ 为错误承诺原文（即 Agent 犯错误的原文，可以是内容也可是动作）、$q_r$ 为 Agent 违反错误的参考原文（即针对 $q_w$ 的规矩或事实的原文）、$c$ 是参考依据类别、$p$ 是执行阶段（表明 Agent 错误发生在哪个阶段）。 参考依据类别 $c$ 共有四种类别： 任务冲突，$q_r$ 来自于前面的任务指令或系统约束； 历史冲突，$q_r$ 来自于前面的环境反馈、工具输出或已确立的事实； 步内冲突，$q_r$ 来自于当前第 $t$ 步的内部； 环境异常，通常来自于外部因素（如断网、网站404） 执行阶段 $p$ 共有五个阶段： 规划：如漏掉子任务、顺序排错、目标漂移。 推理：如扭曲证据做错选择、过度推广结论、捏造未检查的前提。 动作：如选错工具或言行不一、参数语法格式错误、执行违规动作。 观察：如看错工具返回结果、无视关键返回信息。 验证：如未做要求的检查就交卷、任务没做完就提前终止、无脑死循环重试。 错误状态分类 得到了错误集之后，还需要进行聚类，因为同一个错误会被多次记入，并且还会有已经修复好的错误被记入，因此需要进一步聚类去重。 TrajDebug 将围绕同一个被违反的具体参考对象 $O$ 的一组触发点 $\\mathcal{E}$，打包合并为一个错误实例 $E = (\\mathcal{E}, O)$。 $O$ 由参考依据类别 $c$ 和具体的被违反依据 $q_r$ 共同决定。 状态分类器会对每一个错误实例 $E$ 进行两项基于原文证据的分类： 对于已解决的问题，只有当后续步骤拿出了对于同一个参考对象 $O$ 的可引用的原文证据以此来证明的错误承诺已被修正。对于未解决的错误就一直处在 Active 状态。 给出 终态足迹 概念；对于错误动作已经对外部环境造成无法撤回的改变、错误的信念或事实影响后续一连串的动作且没有被改正、修改某个错误花费了超过一半的成本或超过一半的轨迹长度都被称为 终态足迹 对于 1 和 2，我们将错误实例按照四种情况进行分类 表 2. 错误实例生命周期状态与候选集判定。 错误生命周期状态 维度 1：是否解决？ 维度 2：有无终态足迹（及通道）？ 是否保留进候选集 $\\mathcal{F}(\\tau)$ 1. 干净修复 已解决 无足迹 × 2. 潜伏活跃 未解决 无足迹 × 3. 代价修复 已解决 有足迹 √ 4. 显性活跃 未解决 有足迹 √ 我们有： $$ \\mathcal{F}(\\tau) = \\{ E : \\operatorname{state}(E) \\in \\{\\operatorname{CostlyResolution}, \\operatorname{ManifestActive}\\} \\} $$ 候选集引导的因果归因 对于 $\\mathcal{F}(\\tau)$，不应该直接选取时间最早的，而是应该做几步考量，因为最早的不一定是最关键的。 TrajDebug 使用大模型作为最终的因果归因裁判： 给出候选集 $\\mathcal{F}(\\tau)$，涉及 $e = (t, c, p, q_w, q_r)$ LLM 进行推理，由它来决定修正哪一个候选步骤，能够从根本上消除后续的错误级联。 为了防止 LLM 推理错误或漏掉了哪一步，最后允许 LLM 推翻 $\\mathcal{F}(\\tau)$，直接根据自己的理解从轨迹里另选一步，但设置了极严苛的证据门槛：大模型必须先论证为什么 $\\mathcal{F}(\\tau)$ 里的所有候选都无法解释最终失败，并且必须像前两阶段一样有 $e = (t, c, p, q_w, q_r)$，这种受严格证据约束的回退机制依然比直接提示高出 4 个百分点。 反馈 关键错误检测器只有在输出转化为可测量的智能体改进时才有用。论文将 TrajDebug 作为反馈源，反馈注入执行智能体的系统提示。比较 Vanilla 及 Self-Reflection 两种 Baseline，效果如下： 表 3：将检测器输出用作 GLM-5.1 反馈时的任务成功率。 可以看到均有所提升，这里采用的反思是 对于每条失败轨迹，检测器生成反馈，并将其注入系统提示，这里的结果均超越了全局提示词或者一般性反思。 总结 成本高，它需要 LLM 针对每个步骤都分成三层来压缩；也许可以用小模型或者块的低细节视图快速定位？ 如果没有第三步的重放，真正的关键错误步能够活着进入最终候选集 $\\mathcal{F}(\\tau)$ 的比例其实只有 42.0%，因为规定了显式的 $q_w$、$q_r$，所以要求较高，无法有效针对隐式错误做归因； 没有实时拦截（后续有方法做 可以通过 $\\mathcal{F}(\\tau)$ 进行冻结前面的分支重放，而不是直接通过系统 Prompt 重新全部重跑；","d":"TrajDebug 关键错误定位、错误生命周期追踪与反馈应用阅读笔记。","dt":"2026-11-05","s":"blog","t":"TrajDebug: Tracing Error Lifecycles","u":"/zh/blog/trajdebug-notes/"},{"c":"Who\u0026When 由于是 25 年中旬的论文，用的模型较老，以 o1 和 R1 为测评模型，在该数据集上的表现为： 表 1：OpenAI o1、DeepSeek R1 与 GPT-4o 的失败归因性能对比 数据集的主要构成：由算法生成的 Agent System 和人工构建的 Agent System ；共 127 个系统，由人工标注，具体来说分为两类错误：Agent-Level（Who，即定位到具体错误的智能体），Step-Level（When，即定位到具体的步骤）；其中 Step-Level 表现较差。 分为了三种测评方法，分别是 All-at-Once、Step-by-Step、Binary-Search 三种方法，表现性能如下，以 4o 为例： 表 2：GPT-4o 在有无真实标签下的失败归因方法性能对比 数据集实例： 图 1：Who\u0026When 数据集中的算法生成系统与人工构建系统失败日志示例。 11.8 更新：目前在 WW 数据集上进行实践，实际上 AI 算法生成的任务数据集比较不合理。这也解释了后面的 MP-Bench 为什么是合理的。 简单举个例子，任务是找出专辑的第五首歌曲的副歌部分的倒数第二个词是什么，Manager 将任务分派给了三个子智能体串行执行，分别是歌词专家、语言学验证专家、音乐史学家；（Step 0）：歌词专家首先转发了 Manager 的一部分内容，Manager 假定第五首歌是 F（实际是 A），并要求验证是不是 F； （Step 1）：音乐史学家收到后，一个个的列出专辑的时候产生用户偏向性，认为第五个就是 F，后续的工作按照此基础自然会出错。 我个人认为，责任智能体、责任步应该是音乐史学家和 Step 1，因为明明 F 是一项待核实的任务，音乐史学家没有遵循。但实际给出的标注是歌词专家、Step 0；从另一个视角来说，这个答案也可以理解，WW 选择的是最早出现错误声明的那一步。 本次利用 Deepseek-V4.1-F1017 在 Who\u0026When 的 eval 集上进行了评测，共计32条，并且跑了 8 条开发集，整体的效果如下： 表 3. Who\u0026When 自行评测结果对比 实验分组 样本范围 表示方式 有效率 Agent 准确率 Step 准确率 Joint 联合准确率 关键词启发式 eval/16 raw / canonical 100% 25.0% (4/16) 12.5% (2/16) 12.5% (2/16) dev 开发集 dev/4 raw 100% 75.0% (3/4) 50.0% (2/4) 50.0% (2/4) dev 开发集 dev/4 canonical 100% 100.0% (4/4) 50.0% (2/4) 50.0% (2/4) eval 评测集 eval/16 raw 100% 68.75% (11/16) 50.0% (8/16) 50.0% (8/16) eval 评测集 eval/16 canonical 100% 56.25% (9/16) 37.5% (6/16) 37.5% (6/16) 可以看到，结构化的呈现在 WW 数据集上并不能带来准确率的提升，在 LLM 看来，结构化的 Traj 能让 LLM 归因于计划/决策者，而在杂乱无章的 Traj 中，LLM 更偏向于真实报错的部分。实际上，在 LLM 答错的 8/10 道题里面，仅有一个出现了之前我认为的多视角问题，更多的是迷失在长上下文中而产生一些幻觉或者错判。 MP-Bench 不同的分析人员可以合情合理地将失败归因于不同的步骤。这种非确定性和多视角的本质源于多智能体系统内在的相互依赖性。多个专业智能体可以相互依赖地组合成旨在达成同一目标的多样化有效执行轨迹。因此，失败归因在很大程度上取决于观察者对于何为“正确”轨迹的内在心智推理。 以往工作中观察到的局限源于忽视 MAS 失败多视角特性的评测假设偏差，而非模型能力不足。 图 2：说明多智能体系统失败归因多视角特性的动机示例。 MP-Bench 采用归一化折损累计增益（nDCG@K），该指标评估预测排序与真实排序之间的一致性，更加重视对高度显著的失败步骤进行正确优先排序。 表 4：在 MP-Bench 上各系统的失败归因与归因推理性能对比。 论文还测了在多智能体测试下的结果： 表 5：单大模型系统与多大模型融合失败归因系统之间的性能对比 TrajErrBench 目前的一些数据集存在以下问题： 轨迹普遍偏短：Who\u0026When 的算法生成子集平均只有 8.72 步，很难测试长上下文下的证据丢失问题。 场景相对单一或偏玩具化：多集中在简单的多智能体对话、网页购物（WebShop）或文字房间游戏（ALFWorld）。 缺少真实复杂场景：缺乏在工业界最受关注的复杂多轮工具调用（如客服业务规则约束）和超长程仓库级代码开发场景。 TrajErrBench 由两个互补的真实高难度领域子集构成： 表 6. TrajErrBench 数据集构成 子集名称 轨迹数量 平均步数 任务场景与特点 产生失败轨迹的LLM $\\tau^{2}$-Bench 子集 400 条 29.27 步 多轮客服与工具调用（航空 Airline \u0026 零售 Retail）：智能体需要一边和模拟用户多轮对话收集需求，一边调用后台数据库 API，并严格遵守复杂业务政策（如退改签规则、预算限制、舱位规定）。 DeepSeek-Reasoner、 GPT-5、 Qwen3-Max SWE-Bench Pro 子集 86 条 119.70 步 超长程仓库级软件工程：智能体在真实的 GitHub 代码仓库中定位 Bug、阅读多个源码文件、编写补丁并运行测试。轨迹极长，上下文高度复杂。 基于 OpenHands 框架运行： Claude-Opus-4.6、Kimi-K2.6-Coding、Gemini-3.1-Pro、Grok-4.20-Beta、GPT-5.4 合计 486 条 — 覆盖真实工具交互与长程代码修复 8 个前沿大模型 表 7：多基准关键错误检测的主要实验结果 作者在该数据集中发现了以下问题： 关键错误往往在轨迹的后半段；在以前的数据集里，智能体经常一上来前几步就犯致命错误。但在该数据集中，作者发现 Agent 之前大部分都是在进行分析、解读而不是执行，开始做核心决策或修改代码时，才会犯下致命错误。 Agent 往往在推理阶段出问题，在 $\\tau^{2}$-Bench 中占 60.7%，在 SWE-Bench Pro 中占 57.1%。","d":"多智能体故障归因基准 Who\u0026When 与 MP-Bench 的阅读笔记。","dt":"2026-11-04","s":"blog","t":"Multi-Agent Failure Attribution Benchmark Notes","u":"/zh/blog/multi-agent-attribution-benchmarks/"},{"c":"近期 LLM 的能力呈线性或指数级上升，甚至大模型能力已然超出 AI 开发者的意料。OpenAI 团队称，内部模型通过约 10,000 个并行智能体协作，给出了 Navier–Stokes 千禧年难题的解答；Anthropic 研究员也介绍了 Claude 与领域专家合作开展的遗传学研究；Google 的 Gemini 4 Argon 则通过多智能体协作，帮助研究人员扩展了核聚变磁约束相关问题的数学解，这项研究与已有 59 年历史的 Grad 猜想有关。由此可见，随着任务规模和执行时长的增长，任务所要求的多元能力越来越难以全部集中在单个智能体中，多智能体协同提供了一种原则性的解决方案。 多智能体系统存在的问题 在多智能体协作中，单模型依旧有幻觉事实、消息误传或错误的工具调用等局部错误，这些错误在后续的交互轮次中扩散传播，随着步数的迭代，这些错误难以被发现定位，归因和自我纠错两种缺陷深度交织在一起，从而智能体们无法进行改进。 这种错误暴露出一种本质的不对称性：对于一个复杂精密的多智能体系统，它的能力远远超过了用于理解系统为何发生故障并促使自主改进的机制体系（RSI）。 弥合这一鸿沟需要一个闭环的框架，使得能够识别故障、减少预算、指导结构性自我改进。 图 1：沿运行生命周期组织的多智能体系统概览，展示个体能力、协同、故障归因与系统自进化及其代表性工作。 个体智能 LLM 在自动化软件工程、科学实验设计以及多步网页导航等复杂场景中依然具有局限性，本质的缺陷还是缺乏持久性记忆、无法主动感知外部环境，受限于训练期间的静态知识，Harness 赋予了 LLM 感知环境、制定目标、执行工具等能力，Agent = Harness + LLM： 图 2：沿推理管线组织的个体智能体能力架构。记忆贯穿其中，提供检索上下文并吸收执行反馈；规划与工具使用构成其他核心能力。 模块化优化占据主导地位，但模块间的耦合仍未经深入研究。推理、记忆、规划和工具使用在每一个时间步上都相互依存，然而现有方法几乎完全孤立地优化单个模块。各模块之间的能力不匹配往往成为端到端部署中的真正瓶颈，但这种故障模式对于目前的基准测试而言却是不可见的，因为现有基准大多只针对一到两种能力。 推理 CoT 通过精心设计的提示诱导出中间推理步骤，在不改变模型参数的情况下大幅度提升了复杂任务的性能。核心挑战便转变为外部机制应如何弥合模型的静态参数化知识与现实世界任务的动态需求之间的鸿沟。遵循这一视角，我们沿着推理管线的信息流来组织现有方法，将其划分为三个阶段： 输入阶段增强，通过外部知识检索与多模态感知来拓展模型可获取的信息边界； 推理过程增强，通过搜索空间扩展与路径验证来优化推理轨迹； 输出阶段调控，通过事后评估与自适应修正来提升生成结果的可靠性与事实准确性。 查询增强 RAG 将参数化生成器与非参数化检索器相结合，使得模型能在推理阶段从外部知识库中获取相关文档。在此基础上，后续的工作有 通过训练模型来自适应决定如何检索、通过反思标记对检索内容和生成内容进行评判 利用知识图谱进行检索，查询相关子图、在知识图谱上进行多跳推理 Knowledge Card 设计多个小模型作为各个领域可插拔的知识模块，小模型负责生成背景材料，依然通过检索由大模型来回答 RuAG 利用大模型辅助确定候选条件和预测目标，通过蒙特卡洛树搜索从离线数据中挖掘可靠的逻辑规则，再将规则转化为自然语言，直接或按需检索后注入提示词，指导大模型进行推理和生成。 推理增强 对于推理轨迹本身，沿两个维度对其进行组织：搜索空间扩展，用于增加候选解的覆盖度；以及路径验证，用于提供识别最可靠结果所需的选择压力。 搜索空间扩展 CoT、ToT、GoT 依赖人工设计的提示协议，DeepSeek-R1 通过大规模的 RL 训练模型自主生成长思维链，展现出纯粹源自奖励优化的自我验证、自发回溯、自我批评的能力。 推理路径验证 拓展了搜索空间能够产生更多的候选解，更多的候选解意味着会引入等量的错误路径。目前的方法通过采样多条输出后内部投票、维护失败自迭代等方式，这种方法不改变模型的参数。 PRM 通过对推理步骤进行独立评分，大幅度提升了模型的推理能力，后续的进展基于 PRM 整合到 RL 训练过程中，证实了过程监督在同时塑造习得策略与选择机制时最为有效。 输出检验 目前针对输出内容的可靠性评估分为两类。一类是通过将输出分解为多个待检验项，然后逐步核对知识库，还可以扩展到代码、数学推理、科学文献等更细粒度的错误定位。另一类则是不借助外部知识，通过衡量多个样本的一致性来检测幻觉，或是模型自主去检验、独立回答，亦或者多条样本根据投票选出胜者，然后以此进行自迭代。 表 1. 推理增强方法对比，按干预阶段和子类型编排。 Table 1 子类型：KE 知识增强；PE 感知增强；ESS 扩展搜索空间；VRP 推理路径验证；OV 输出验证；RC 响应修正。任务范围：评估领域——Ma 数学；QA 问答；Co 代码；LF 长文本生成；Ag 智能体；Mu 多任务。主要来源：主要信息源——Evid = 外部证据；Inter = 内部状态；Consis = 跨样本一致性；Log = 逻辑/验证；Tool = 基于工具。修正：错误修正机制——SF = 自我反馈；Refl = 反思；TV = 工具验证；SC = 自洽性。Ext. Ret.：使用外部检索。TF：免训练。TTC：支持测试时计算扩展。 Method Sub-type Task Scope Prim. Source Correction Ext. Ret. Tool TF TTC Year A. Input-Stage Enhancement ViperGPT 89 PE Mu Inter — — ✓ ✓ — 2023 RAPTOR 90 KE QA LF Evid — ✓ — ✓ — 2024 Self-RAG 50 KE QA LF Evid SF ✓ — — — 2024 LLaVA 91 PE Mu Inter — — ✓ — — 2024 TopViewRS 92 PE Mu Inter — — — ✓ — 2024 VisCoT 93 PE Mu Inter — — — ✓ — 2024 HippoRAG2 94 KE QA LF Evid — ✓ — ✓ — 2025 Theanine 95 KE QA LF Evid — ✓ — ✓ — 2025 SubgraphRAG 51 KE QA Evid — ✓ — ✓ — 2025 B. Reasoning-Process Enhancement Self-Consistency 64 VRP Ma QA Consis SC — — ✓ ✓ 2023 LATS 96 ESS Mu Inter Refl — ✓ ✓ ✓ 2024 CoC 97 ESS Ma QA Co Tool — — ✓ ✓ — 2024 AnyTool 98 ESS Ag Tool SF — ✓ ✓ — 2024 RAIN 99 ESS QA Inter SF — — ✓ ✓ 2024 Math-Shepherd 67 VRP Ma Log — — — — ✓ 2024 CPO 62 VRP Ma Log — — — — — 2024 rStar 100 ESS Ma Consis SC — — ✓ ✓ 2025 rStar-Math 101 ESS Ma Consis SC — — — ✓ 2025 TTS 102 ESS Ma Log — — — ✓ ✓ 2025 TOPS 103 ESS Ma Log — — — ✓ ✓ 2025 Rewarding Progress 104 VRP Ma Log — — — — ✓ 2025 WizardMath 68 VRP Ma Log — — — — ✓ 2025 C. Output-Stage Regulation FActScore 70 OV LF Evid — ✓ — ✓ — 2023 FacTool 71 OV Mu Evid — ✓ ✓ ✓ — 2023 SelfCheckGPT 73 OV LF Consis — — — ✓ — 2023 Semantic Entropy 105 OV QA LF Inter — — — ✓ — 2023 RARR 78 OV QA LF Evid TV ✓ — ✓ — 2023 ITI 81 RC QA Inter — — — ✓ — 2023 Reflexion 19 RC Ag Co Inter Refl — — ✓ ✓ 2023 L2R 106 RC QA Inter — — — — — 2023 Factcheck-GPT 72 OV QA LF Evid — ✓ — ✓ — 2024 HaloScope 75 OV QA LF Inter — — — ✓ — 2024 DoLa 79 RC QA LF Inter — — — ✓ — 2024 CAD 80 RC QA LF Evid — — — ✓ — 2024 FactTune 84 RC QA LF Evid — — — — — 2024 CoVe 77 RC QA LF Log SF — — ✓ ✓ 2024 CRITIC 87 RC QA Ma Co Tool TV — ✓ ✓ — 2024 R-Tuning 85 RC QA Inter — — — — — 2024 HalluLens 76 OV Mu Inter — — — ✓ — 2025 ","d":"《Beyond Individual Intelligence》阅读笔记：个体能力、推理、记忆、规划、角色分配、多智能体通信、编排、故障归因与自进化。","dt":"2026-10-23","s":"blog","t":"Multi-Agent Systems Survey Notes","u":"/zh/blog/multi-agent-survey-notes/"},{"c":"智能体记忆的生命周期 生命周期可以分为记忆提取、记忆存储、记忆检索、记忆演化四个部分。 记忆提取：将原始的非结构化观测 $o_{t}$ 转化为结构化的记忆单元 $m$。 记忆存储：通过适当的索引与结构化组织，将提取出的记忆单元组织并安置到记忆结构 $\\mathcal{M}$ 中。 记忆检索：响应查询 $q$ 检索所存储的相关信息 $\\mathcal{M}_{\\text{rel}}\\subset\\mathcal{M}$ 的机制。 记忆演化：对记忆进行提炼的后处理阶段，包括内部自演化机制（例如巩固、抽象）和外部自探索过程（例如新的环境反馈）。 图 1：展示 AI 智能体系统工作流程以及记忆系统具体实现方案的示意图。 智能体记忆多维度分类 智能体记忆可以划分为多维度，包括时间跨度、功能角色以及表示结构。 时间跨度 短期记忆：留存近期、即时相关的信息，具备快速访问的能力，但容量有限。包括当前对话上下文、正在进行的推理轨迹以及瞬时状态变量。通常在即时任务完成后即被丢弃，但其中的关键重要元素可能会被巩固沉淀至长期存储中。 长期记忆：跨会话持久存储信息，包括积累的知识、历史交互、习得的模式以及用户偏好。长期记忆支持跨交互片段的连贯性，赋能迁移学习，并为在更长时间尺度上实现个性化与自适应行为奠定坚实基础。 记忆认知结构 语义记忆：存储通用的、脱离具体情境的世界知识和事实性信息（例如“巴黎是法国的首都”）。在图结构中，它构成了稳定的本体层，提供常识和特定领域事实，作为智能体推理的可靠基础。 程序记忆：编码技能、例行程序与固定规则。它代表“操作规程”类知识（how-to knowledge），例如标准作业程序或游戏规则。在实际应用中，这使智能体能够在标准条件下自动执行复杂的既定任务。 联想记忆：在知识库内的不同概念或数据点之间建立潜在关联。通过连接相关联的信息片段（例如症状与诊断之间的关联，或商品与类别之间的映射），它能够促进创造性推理和类比思考，充当知识图谱中的连接纽带。 工作记忆：充当智能体处理即时经验的“心智草稿纸”。它临时暂存当前对话轮次、中间推理步骤和瞬态变量。尽管具有瞬时性，但它是所有经验记忆的入口，其特点是访问极快且直接决定智能体的下一步行动。 情景记忆：按时间顺序记录过往交互会话的序列。它将瞬态的工作记忆转化为持久且可查询的自传式历史。例如，它记录下某位用户曾要求提供素食选项或取消过某笔订单。这使智能体能够回忆起“何时发生了何事”，提供明确的时间锚定。 情感记忆：捕捉交互过程中衍生的情绪基调或情感倾向。通过记录用户反馈或挫败感程度，智能体能够在后续交互轮次中调整其同理心和沟通风格。该层级为原始交互日志增添了定性的情感维度。 两大类型 静态知识记忆与动态经验记忆之间的协同作用，使智能体既能理解世界的固有规律，又能自适应融入个性化的人机交互。 知识记忆（被动且静态）：代表智能体对客观、全局且可验证信息的被动且静态的储备。其功能类似于内部参考图书馆或教科书，包含规范性事实、通用规则、既定规程以及关于世界的一般性规律。这类记忆通常预先加载、极少更新，且独立于具体上下文。其核心目的在于为推理与行动提供稳定、可靠的基石。例如，它存储概念的事实定义、游戏的固定规则或标准的科学原理。在实际应用中，购物智能体的商品数据库或机器人的通用可供性模型均属于知识记忆。总体而言，这类记忆是被动的，充当逻辑推理的可靠事实支柱。 经验记忆（主动且动态）：这是智能体专属的个人日志，主动记录其具体的交互过程、环境观测以及行动结果。它涵盖用户对话历史、执行日志、试错轨迹与反馈信号。例如，它记录下某位特定用户需要素食千层面变体、某次基于均值回归策略的交易实际上导致了亏损，或者标准抓取流程在潮湿马克杯上执行失败。这类记忆是动态且高度个性化的，构成了从实践中学习并适应特定情境的基础。 图 2：智能体记忆的两大类型，即“知识记忆”（Knowledge Memory）与“经验记忆”（Experience Memory），以及它们在不同智能体场景中的应用。静态知识记忆与动态经验记忆之间的协同作用，使智能体既能理解世界的固有规律，又能自适应融入个性化的人机交互。 （非）结构化记忆 传统的智能体记忆系统通常采用简化的存储范式，主要包括： 基于线性或缓冲区的记忆：例如固定长度的 token 窗口或对话历史记录，这类记忆能够保留近期的交互信息，但存在信息丢失问题且缺乏关系上下文。 基于向量的记忆：将交互信息编码为存储在向量数据库中的稠密嵌入，从而支持高效的基于相似度的检索，但在结构化推理与层次关系建模方面存在局限。 基于键值对或日志的记忆：将事件记录在时序日志或“属性–值”对中，支持直接查找，但在处理复杂查询或动态更新时表达能力有限。 记忆存储 图 3：智能体记忆系统图构建范式的全面分类体系：涵盖构建方法论、对应的记忆功能，以及各项技术的优缺点对比分析。 知识图谱结构 知识图谱建模 为智能体构建知识图谱，涉及从非结构化交互流中持续提取并融合结构化三元组。主流方法高度依赖大语言模型作为强大的开放词表解析引擎。 在 AriGraph 世界模型中，LLM 解析来自环境的每一条文本观测，以识别相关对象并以三元组形式提取其内在关系。类似地，Mem0等系统在提取阶段利用 LLM 将对话消息转化为“实体–关系–实体”三元组。该方法显著优于传统的命名实体识别（NER）和关系分类流水线，因为 LLM 能够泛化到未见过的细粒度实体类型，并基于深度上下文理解挖掘隐式语义关系。 对应的记忆类型 知识图谱基于三元组的结构使其极其适合实现长期静态记忆类型。这包括通用的世界常识（例如 (巴黎, 首都, 法国)）以及固定不变的领域特定概念。显式的关系格式支持高效存储和复杂的多跳查询，而这正是基于向量的检索器所难以胜任的。此外，通过为三元组补充时序元数据，或将其与情景事件节点相链接（将情景顶点与同一观测中提取的三元组相连），知识图谱同样能够对情景记忆提供稳健支持。 当然，知识图谱也支持动态构建和修改，因为知识、指南手册等信息也是会变化的。 层次化记忆结构 层次化记忆通过将信息组织成多级树状结构，它提供了一种逻辑严密的层级结构，将庞杂的海量经验压缩为易于调用的知识图式。这一固有特性赋予其卓越的能力：既支持自顶向下的分层遍历以检索抽象主题，又支持自底向上的聚合摘要以维持海量记忆库的全局连贯性。MemTree 等系统正是采用了这种机制，通过树层级结构对新信息进行动态路由，在既有节点下聚类相似内容，同时为新颖信息开辟全新分支，并促使所有祖先节点自底向上递归更新其语义摘要以反映新吸收的知识。 层次化记忆的构建主要依赖两大核心过程：用于空间组织的语义聚类，以及用于概念提炼的递归摘要。为了维持层级结构作为高度压缩知识图式的价值，每个父节点都会动态生成对其子树所包含全部信息的紧凑自然语言摘要。 除上述静态事实知识外，该结构还具体体现为会话或序列记忆。在此形态下，单句陈述或对话轮次主要依据其在特定会话内的时间先后顺序或对话上下文流转进行关联。这构建了一条时间线或叙事链，对于在单一交互片段内建模对话连贯性以及追踪用户意图演变至关重要。 时序图结构 双时间维度建模 在智能体记忆中，一个关键区别在于事件发生的实际时间（有效时间，valid time）与该事件被记录到系统中的时间（事务时间，transaction time）。Graphiti 实现了同时追踪这两个时间维度的双时序模型。 在跨会话对话中，相对时间表述（例如“上周五”）极易引发语义歧义。TReMu 采用了一种感知时间的记忆机制，将提及时间（会话发生的时间戳）与推断出的事件实际发生时间进行解耦。 层次化时间约束 **MemoTime**的提出旨在杜绝推理链中的逻辑时序幻觉（例如检索出发生在原因之前的结果）。该框架将 TKG 的推理过程组织为层次化的“时间之树”（Tree of Time）。该结构确保检索到的任何推理路径 $e_{1}\\to e_{2}\\to e_{3}$ 都严格遵循时间先后顺序（$t_{1}\\leq t_{2}\\leq t_{3}$）。这种感知算子的结构设计使智能体能够高效剪枝剔除在语义上看似相关但在时间维度上无效的证据。 日期 事件 10 月 14 日 旧环境测试通过 10 月 15 日 升级 Python 10 月 16 日 修复升级后的依赖问题 10 月 17 日 新环境测试通过 子问题树（时间之树，由 LLM 生成）可以这样理解： text 4 行 主问题：升级、修复依赖之后，首次测试通过的日期？ ├─ 子问题1：什么时候升级？ → 10月15日 ├─ 子问题2：升级后何时修复依赖？ → 10月16日 └─ 子问题3：修复后最早的测试通过记录？ → 10月17日 前一步得到的时间，会成为后一步检索的约束： text 4 行 查到升级日期 → 限定“升级之后”的依赖修复记录 → 再限定“修复之后”的测试记录 → 从合格记录中选最早的一条 这是一棵针对当前问题临时构建的计划树，与保存历史知识的记忆图不同。 超图结构 尽管仅连接两个实体的二元图具有较高效率，但在表示复杂的多实体交互（例如三种药物联合作用产生特定副作用）时会出现信息丢失。超图（Hypergraphs）通过引入能够连接任意数量节点的超边（hyperedges）解决了这一问题，从而保持了 $n$ 元关系的完整性。 多元关系中的信息完整性 构建超图记忆的核心动机在于避免将复杂事实拆解为多条二元边所导致的图稀疏性与语义碎片化。HyperGraphRAG 从信息论角度证明了超图表示比等价的二元图保留了更完整的信息。通过将自然语言知识片","d":"智能体记忆的生命周期与分类，以及图结构下的记忆存储、检索和持续演化。","dt":"2026-10-20","s":"blog","t":"基于图的智能体记忆：学习笔记","u":"/zh/blog/graph-based-agent-memory/"},{"c":"痛点 评价一个候选程序，通常只需要运行它并检查结果。评价一个探索策略，则需要让它连续安排很多次尝试，观察最终发现了多好的方案、消耗了多少资源。一个眼前分数低的方向，可能几次修复后才出现突破；一个早期领先的方向，也可能很快停滞。 策略质量的反馈比单个程序的反馈更延迟。每修改一次控制器都重新跑完整在线发现，会反复支付模型调用、代码执行和评价的成本。与此同时，探索策略的空间很大：分支选择、停止规则、并行批次和失败处理都可以组合变化。这是引言提出的两个瓶颈：反馈昂贵而延迟，候选元策略又很多 固定探索策略的优点是简单、稳定；局限是它不能根据积累的发现经验改变跨轮的搜索习惯。Dream-RSI 的切入点，是降低比较探索策略的代价，而不是直接为某个领域设计一个更强的固定启发式。 Dream-RSI 过程 0. Dream-RSI 分为在线工作和离线规划这两个过程，Dream-RSI 交替进行： 在线探索 → 保存发现树 → 离线评价和修改策略 → 选择策略上线 → 新一轮在线探索。 1. 在线探索 首先设置一个初始的工作环境，这个工作环境称为根节点 $r$，每个非根节点均记录 “父节点及之前的上下文、工作空间快照、评价诊断和评分”。设 $t$ 是在线—离线的外层循环编号，$\\pi_t$ 是第 $t$ 轮在线使用的可执行调度策略代码。通过调度程序 $\\pi_t$ 选择当前探索树的叶节点或者是根节点，即延续所选节点的工作或者是开启新方法，由 coding agent 或专门负责解决这个任务的 agent 来完成节点的延续，完成后的节点保存上下文和评分，成为新的叶节点。停止条件： 达到最大的在线调度轮数（一个并行批次计一轮，不等于一次尝试）； 调度策略选择不继续进行； 2. 离线规划 由 1 的工作，我们得到这一轮的探索树 $\\mathcal T_t$（下文简称 $\\mathcal T$），明显地，$\\mathcal T$ 是由若干条链组成的，因为上个阶段只允许在叶节点延续工作，不会从普通节点产生新分支（根节点除外）。离线先评价当前的策略 $\\pi_t$，再评价其修改版本。模拟器持有完整树，但每次回放从根节点开始，只向策略逐步揭示已访问的节点，策略根据已揭示的信息来选择下一步的工作空间。设策略版本 $m$ 在第 $i$ 棵树上回放 $k$ 轮后为 $\\mathcal T_i^{m,k}$，则有 $\\mathcal T_i^{m,k}\\subseteq\\mathcal T_i$；一次回放期间策略代码不变。假设 A1 是最早创建的根节点子节点，可以这样回放： 轮次 策略选择的起点 模拟器返回 第 1 轮 根节点 $r$ 已保存的 A1 第 2 轮 根节点 $r$ 已保存的 B1 第 3 轮 A1、B1 已保存的 A2、B2 接下来 返回空批次 停止，不揭示 A3 这条策略没有创造新实验，只是形成了一条新的调度轨迹: 选当前已揭示树中的非根叶节点：返回它已有的下一节点； 选根节点：按创建先后，打开下一条尚未揭示的分支； 没有已记录后继：不返回新节点 回放在策略返回空批次、达到最大回放调度轮数，或整棵历史树全部揭示时结束。一次回放结束后，通过公式计算得分： $$ V=\\underbrace{\\max_{v\\in\\mathcal T_{\\mathrm{revealed}}}s_v}_{\\text{最佳发现质量}} -\\underbrace{\\beta_1N}_{\\text{总尝试量惩罚}} +\\underbrace{\\beta_2\\frac{N}{\\max\\{1,k^\\star\\}}}_{\\text{平均批量奖励}}. $$这里 $\\mathcal T_{\\mathrm{revealed}}$ 是本次回放结束时已揭示的子树，$s_v$ 是节点 $v$ 的任务评分（越大越好），$V$ 是本次回放得分。$N=|\\mathcal T_{\\mathrm{revealed}}|-1$ 是已揭示的非根节点数，$k^\\star$ 是本次回放完成的调度轮数；$\\beta_1,\\beta_2\\geq0$ 分别是固定的成本惩罚和并行奖励系数。$N$ 代表这条轨迹所对应的生成—评价请求数；回放本身并没有重新执行这些请求。第一项看本次已揭示节点中的最高质量，不对所有分数求平均，也不计入未揭示节点。第二项鼓励节约尝试。第三项偏好把工作放进较少的决策轮，也就是奖励并行度的一个代理指标；分母取 $\\max\\{1,k^\\star\\}$ 是为了避免除以零。 为减少对单次探索经验的依赖，增加多样性，我们在第 $t$ 轮 RSI 中，让每个策略版本分别回放已积累的 $t$ 棵历史树，取 $$ V^m=\\frac{1}{t}\\sum_{i=1}^{t}V_i^m. $$其中 $m$ 是策略版本编号，$i$ 是历史树编号，$V_i^m$ 是同一个版本 $m$ 在第 $i$ 棵树上的回放得分，$V^m$ 是其平均分，不是各轮旧策略当年的分数平均。多树评价不保证消除历史过拟合。 3. 选择策略上线 每个版本在全部历史树上完成离线测评后，交给策略开发 Agent 根据回放轨迹、得分和此前反馈修改调度策略代码，得到下一版本，而不是直接修改轨迹。达到规定的版本数后，从全部已测版本（含原策略）中选平均分最高者，作为下一轮在线策略；只保证固定历史上的平均回放分不低于原策略，不保证在线表现一定提升。 4. 离线评价的作用 离线阶段的价值不是在旧记录里创造新发现，而是低成本比较不同调度程序。 不同策略可能在同一历史树上： 用更少尝试找到相同质量的结果； 避免过早停止，从而访问到更好的结果； 把有价值的尝试组织成并行批次； 没有回放时，比较每个策略版本通常需要重新进行真实探索；有回放后，可以先利用已有结果筛选策略，再把有希望的版本部署到在线环境。 RSI 的不足 具有局限性：不同的任务所需的评价方法不同，需要针对数据集或者任务场景针对性设计。它并没有因此获得任意增加能力、修改评价标准、改变任务接口的自由。更重要的是，它的调度程序在运行过程中是固定的，也就意味着它不适合通用的场景，缺少统一策略的跨场景泛化。 只能选择叶节点或根节点，整个树是若干条链组成的，可以在某个父节点后开辟新的子节点，但具体有待商讨（这里指从已有后继的中间节点重新分叉，是扩展设想，不是文中已支持的操作）。 需要适合保存、分支和重复尝试的状态，代码工作空间比较容易保存和恢复。但发送邮件、修改共享系统、与他人交互等行为，可能影响真实外部环境，不能像代码快照一样随意恢复。把这类任务组织成独立、可回放的探索分支，需要额外设计。 历史回放的有效性有限。回放只提供已经发生过的结果。如果换了任务、用户目标或环境，旧结果可能不再具有同样的意义。所以，它更适合“能够反复试验和比较候选解”的发现问题，而不是已经覆盖了所有通用智能体任务。 文中未单独定义\"若当前任务已经完成之后，该分支就停止\"的分支终止规则；若后续调度程序仍然在已完成的叶节点上继续，且没有提高最佳分数，会增加尝试成本，降低 $V$。 在全部历史树上取平均，可以减少对单棵树的依赖，但这些历史同时参与策略开发，因此仍可能过拟合。 总结 Dream-RSI 具有可跨领域复用的元探索框架，但现有验证主要集中于可重复生成候选、可自动评价、可保存探索状态的发现任务。其应用依赖任务特定的评分与执行接口，尚未充分证明单一调度策略对异质任务和变化用户需求的泛化能力。它能自动改进预设接口内的调度规则，但不能自动解决目标定义、状态可回放性和跨场景适配问题。 论文：Dream-RSI: Recursive Self-Improvement through Evolving Worlds。","d":"Dream-RSI 的痛点、在线探索与离线回放过程，以及对其局限的几点思考。","dt":"2026-10-16","s":"blog","t":"Dream-RSI 学习笔记","u":"/zh/blog/dream-rsi/"},{"c":"PPO 算法 首先定义一些概念，作为我们第一步的知识理解： Action：可选择的动作，即模型下一步进行的动作集 Policy：策略函数，输入 state，输出 action 的概率分布，一般用 $\\pi$ 表示，如 $\\pi(action1|S_t)=0.78\\dots$ Trajectory：轨迹，用 $\\tau$ 表示，是一连串的 state 和 action，$S_{t+1}=f(S_t,a_t)$ 确定，或者 $S_{t+1}=f(*|S_t,a_t)$ 随机 Return：回报，从当前时间到结束的 reward 累计和 期望： $$E(x)_{x \\sim p(x)} = \\sum_{x} x * p(x) \\approx \\frac{1}{n} \\sum_{i=1}^{n} x_i \\quad (x_i \\sim p(x))$$目标 1：训练一个 Policy 神经网络 $\\pi$，在所有状态 $S$ 下，给出相应的 Action，得到 Return 的期望最大。 目标 2：训练一个 Policy 神经网络 $\\pi$，在所有的 Trajectory 中，得到 Return 的期望最大。 Policy Gradient $R(\\tau)$ 为轨迹 $\\tau$ 获得的总回报，在当前策略下，所有可能轨迹的回报期望： $$E(R(\\tau))_{\\tau \\sim P_\\theta(\\tau)} = \\sum_{\\tau} R(\\tau)P_\\theta(\\tau)$$$$\\nabla E(R(\\tau))_{\\tau \\sim P_\\theta(\\tau)} = \\nabla \\sum_{\\tau} R(\\tau)P_\\theta(\\tau)$$$$= \\sum_{\\tau} R(\\tau)\\nabla P_\\theta(\\tau)$$$$= \\sum_{\\tau} R(\\tau)\\nabla P_\\theta(\\tau)\\frac{P_\\theta(\\tau)}{P_\\theta(\\tau)}$$$$= {\\color{#4285F4}{\\sum_{\\tau} P_\\theta(\\tau)} R(\\tau)}\\frac{\\nabla P_\\theta(\\tau)}{P_\\theta(\\tau)}$$$$\\approx \\frac{1}{N} \\sum_{n=1}^N R(\\tau^n) \\frac{\\nabla P_\\theta(\\tau^n)}{P_\\theta(\\tau^n)}$$$$= \\frac{1}{N} \\sum_{n=1}^N R(\\tau^n)\\nabla \\log P_\\theta(\\tau^n)$$其中最后一步使用了 $\\nabla \\log f(x) = \\frac{\\nabla f(x)}{f(x)}$。 一个状态是完全由当前状态和当前动作决定的，那么一个 Trajectory 的概率就是在该 Trajectory 下的所有 state 和该 state 下所有 action 的连乘，即： $$= \\frac{1}{N} \\sum_{n=1}^N R(\\tau^n)\\nabla \\log \\prod_{t=1}^{T_n} P_\\theta(a_n^t|s_n^t)$$$$= \\frac{1}{N} \\sum_{n=1}^N R(\\tau^n) \\sum_{t=1}^{T_n} \\nabla \\log P_\\theta(a_n^t|s_n^t)$$$$= \\frac{1}{N} \\sum_{n=1}^N \\sum_{t=1}^{T_n} R(\\tau^n)\\nabla \\log P_\\theta(a_n^t|s_n^t)$$此时去掉求导符号，进行梯度下降为：$\\frac{1}{N} \\sum_{n=1}^N \\sum_{t=1}^{T_n} R(\\tau^n)\\log P_\\theta(a_n^t|s_n^t)$，之后我们进行梯度更新，定义的 loss 为： $$\\text{Loss} = -\\frac{1}{N} \\sum_{n=1}^N \\sum_{t=1}^{T_n} \\color{#4285F4}{R(\\tau^n)} \\log \\color{#EA4335}{P_\\theta(a_n^t|s_n^t)}$$因此我们需要采集每个 Trajectory 造成的 $R(\\tau^n)$，采集数据非常慢，且占用显存和内存较大，且存在问题。 $$\\frac{1}{N} \\sum_{n=1}^N \\sum_{t=1}^{T_n} {\\color{#4285F4}R(\\tau^n)}\\nabla \\log P_\\theta(a_n^t|s_n^t)$$问题在于：$R(\\tau^n)$ 是整局游戏的总得分。但实际上，在时刻 $t$ 采取的动作 $a_t$，不可能影响时刻 $t$ 之前发生的事情。用总得分去评估当前的动作是不合理的。 $$R(\\tau^n) \\rightarrow \\sum_{t'=t}^{T_n} \\gamma^{t'-t} r_{t'}^n = \\color{#4285F4}{R_t^n}$$我们将总回报替换为从当前时刻 $t$ 开始，到游戏结束时的未来累积回报 $R_t^n$。这里通常还会引入一个折扣因子 $\\gamma$（Gamma，取值在 0 到 1 之间），表示越久远的奖励，其参考价值越低。$r_{t'}^n$ 表示具体某一步的即时奖励。更新后为： $$\\frac{1}{N} \\sum_{n=1}^N \\sum_{t=1}^{T_n} \\color{#4285F4}{R_t^n} \\nabla \\log P_\\theta(a_n^t|s_n^t)$$接着依然存在一个问题：如果某个环境的奖励永远都是正数，或者永远都是负数怎么办？如果全是坏的，这样导致模型永远会往下更新，因此我们最好是引入一个 baseline，根据 baseline 来评估每种 action 的好坏 减去 baseline 后：好的局势 reward 为正，坏的局势为负 基于上述的 baseline，我们有以下优化公式： $$=\\frac{1}{N} \\sum_{n=1}^N \\sum_{t=1}^{T_n} (R_t^n - B(s_n^t)) \\nabla \\log P_\\theta(a_n^t|s_n^t)$$$B(s_n^t)$：Baseline。它通常是当前状态 $s_n^t$ 的平均期望得分（在实际应用中，通常会训练另一个神经网络——价值网络 Critic，来预测这个状态的价值 $V(s)$ 作为基线）。 $(R_t^n - B(s_n^t))$：这个差值被称为优势函数（Advantage Function, 通常记为 $A_t$）。它衡量的是：“当前采取的这个动作，比我在这个状态下瞎闭着眼睛随便选（平均水平），到底好多少或坏多少？” 优势函数 首先对于根据我们的基准公式： $$\\frac{1}{N} \\sum_{n=1}^N \\sum_{t=1}^{T_n} (R_t^n - B(s_n^t)) \\nabla \\log P_\\theta(a_n^t|s_n^t)$$接下来再次给出一些定义： Action-Value Function（动作价值函数 / $Q$ 函数）：$R_t^n$ 每次都是一次随机采样，方差很大，训练不稳定，$Q_\\theta(s, a)$ 在 state s 下，做出 action a，期望的回报。 State-Value Function（状态价值函数 / $V$ 函数）：$V_\\theta(s)$ 在 state s 下，期望的回报。 Advantage Function（优势函数 / $A$ 函数）：$A_\\theta(s, a) = Q_\\theta(s, a) - V_\\theta(s)$，在 state s 下，做出 Action a，比其他动作能带来多少优势。 所以，我们可以将原式用数学期望 $A_\\theta(s, a)$ 替换了原本基于随机采样的 $(R_t^n - B(s_n^t))$，公式变为： $$\\frac{1}{N} \\sum_{n=1}^N \\sum_{t=1}^{T_n} A_\\theta(s_n^t, a_n^t) \\nabla \\log P_\\theta(a_n^t|s_n^t)$$我们在计算优势函数时，可以计算出向前 k 步的真实奖励： 第一步估计：$A_\\theta^1(s_t, a) = r_t + \\gamma * V_\\theta(s_{t+1}) - V_\\theta(s_t)$ 第二步估计：$A_\\theta^2(s_t, a) = r_t + \\gamma * r_{t+1} + \\gamma^2 * V_\\theta(s_{t+2}) - V_\\theta(s_t)$ 第三步估计：$A_\\theta^3(s_t, a) = r_t + \\gamma * r_{t+1} + \\gamma^2 * r_{t+2} + \\gamma^3 V_\\theta(s_{t+3}) - V_\\theta(s_t)$ 第 $T$ 步估计：$A_\\theta^T(s_t, a) = r_t + \\gamma * r_{t+1} + \\gamma^2 * r_{t+2} + \\gamma^3 * r_{t+3} + \\dots + \\gamma^T * r_T - V_\\theta(s_t)$ 我们引入 $\\delta_t^V = r_t + \\gamma * ","d":"从 Policy Gradient 到 GAE、重要性采样与 PPO-Clip、GRPO 的完整推导笔记","dt":"2026-10-11","s":"blog","t":"PPO to GRPO","u":"/zh/blog/ppo-to-grpo/"},{"c":"经过 SFT 之后的模型是针对 Token level 上做了训练，让模型在 token 概率分布上更偏向遵守格式的回答。但具体如何回答，回答的准确性可以用 RL 来进一步增强，在 RL 的训练过程中，我们不希望模型又大幅度偏离 SFT 制定的回答格式，于是需要用到 KL 散度来进行约束，限制 RL 训练后的模型过度偏离 SFT 后的模型，同时争取进一步提升准确率。 设模型生成的完整回答是 $o=(o_1,o_2,\\ldots,o_{|o|})$。 第 $t$ 步之前已经生成的内容记为：$o_{\\lt t}=(o_1,o_2,\\ldots,o_{t-1})$。 那么第 $t$ 步的上下文前缀设为：$h_t=(q,o_{\\lt t})$。 在相同的上下文前缀下，参考策略模型（即SFT之后的模型，希望模型遵守的语气和格式）选择同一个候选 token 的概率为：$\\pi_{\\mathrm{ref}}(a\\mid h_t)=\\pi_{\\mathrm{ref}}(a\\mid q,o_{\\lt t})$。 当候选位置写成一个点时：$\\pi_\\theta(\\cdot\\mid h_t),\\pi_{\\mathrm{ref}}(\\cdot\\mid h_t)$， 给定一个具体 token，得到一个概率数值；遍历所有候选 token，得到一份概率列表。 对于固定的上下文前缀 $h$，假设两个策略具有相同的支持集，共同候选集合为： $$ \\begin{aligned} \\mathcal A_h \u0026=\\{a:\\pi_\\theta(a\\mid h)\u003e0\\}\\\\ \u0026=\\{a:\\pi_{\\mathrm{ref}}(a\\mid h)\u003e0\\}. \\end{aligned} $$记集合大小为 $m_h$，定义两个概率，分别是从当前训练模型和参考模型取一个 token 的概率： $$ p_a=\\pi_\\theta(a\\mid h), \\qquad b_a=\\pi_{\\mathrm{ref}}(a\\mid h). $$其中 $p,b\\in\\mathbb R^{m_h}$。 并且两份列表各自归一化：$\\sum_{a\\in\\mathcal A_h}p_a=1,\\sum_{a\\in\\mathcal A_h}b_a=1$。 精确 KL 对固定的前缀 $h_t$，KL 的定义是： $$ \\begin{aligned} \u0026D_{\\mathrm{KL}}\\!\\left( \\pi_\\theta(\\cdot\\mid h_t) \\Vert \\pi_{\\mathrm{ref}}(\\cdot\\mid h_t) \\right)\\\\ \u0026\\quad= \\mathbb E_{a\\sim\\pi_\\theta(\\cdot\\mid h_t)} \\left[ \\log\\frac{\\pi_\\theta(a\\mid h_t)} {\\pi_{\\mathrm{ref}}(a\\mid h_t)} \\right]. \\end{aligned} $$左边比较的是两份完整的下一 token 分布。右边的期望表示：按照当前策略选择各个 token 的概率，对括号里的数值做加权平均。对有限候选集合，期望可以直接展开成求和： $$ \\begin{aligned} \u0026D_{\\mathrm{KL}}\\!\\left( \\pi_\\theta(\\cdot\\mid h_t) \\Vert \\pi_{\\mathrm{ref}}(\\cdot\\mid h_t) \\right)\\\\ \u0026\\quad= \\sum_{a\\in\\mathcal A_{h_t}} \\pi_\\theta(a\\mid h_t) \\log\\frac{\\pi_\\theta(a\\mid h_t)} {\\pi_{\\mathrm{ref}}(a\\mid h_t)}. \\end{aligned} $$这一步使用的只是离散随机变量的期望定义。$\\log\\frac{\\pi_\\theta(a\\mid h_t)}{\\pi_{\\mathrm{ref}}(a\\mid h_t)}$ 是该 token 的对数概率比，单项可以为正，也可以为负；按当前概率对所有候选加权求和后，才得到非负的 KL 惩罚。若两个分布完全一致，所有比值都为 1，取 $\\log$ 为 0，则无惩罚。 精确 KL 的总和不会是负数，因此可以起到惩罚的作用 使用对所有正数成立的不等式： $$ \\log u\\leq u-1,\\qquad u\u003e0. $$令： $$ u=\\frac{\\pi_{\\mathrm{ref}}(a\\mid h)} {\\pi_\\theta(a\\mid h)}. $$移项可得： $$ \\log\\frac{\\pi_\\theta(a\\mid h)} {\\pi_{\\mathrm{ref}}(a\\mid h)} \\geq 1-\\frac{\\pi_{\\mathrm{ref}}(a\\mid h)} {\\pi_\\theta(a\\mid h)}. $$两边乘以当前概率，再对所有候选求和： $$ \\begin{aligned} \u0026D_{\\mathrm{KL}}\\!\\left( \\pi_\\theta(\\cdot\\mid h) \\Vert \\pi_{\\mathrm{ref}}(\\cdot\\mid h) \\right)\\\\ \u0026\\quad\\geq \\sum_{a\\in\\mathcal A_h} \\left[ \\pi_\\theta(a\\mid h) -\\pi_{\\mathrm{ref}}(a\\mid h) \\right]\\\\ \u0026\\quad=1-1=0. \\end{aligned} $$这个证明同时用到了两份概率分布各自加起来等于 1。前面的基本不等式只在 $u$ 等于 1 时取等号。因此，在共同支持的条件下，KL 为 0 当且仅当两个分布在所有候选上完全一致。 $k_1$ 固定前缀 $h$，对抽到的 token $a$，定义： $$ k_1(a,h;\\theta) = \\log\\frac{\\pi_\\theta(a\\mid h)} {\\pi_{\\mathrm{ref}}(a\\mid h)}. $$如果采用“第 $i$ 条回答、第 $t$ 个 token”的下标，先定义： $$ h_{i,t}=(q,o_{i,\\lt t}), $$然后写成： $$ k_{1,i,t}(\\theta) = \\log \\frac{\\pi_\\theta(o_{i,t}\\mid h_{i,t})} {\\pi_{\\mathrm{ref}}(o_{i,t}\\mid h_{i,t})}. $$它只是被抽中 token 的对数概率比。对固定前缀、从当前策略抽取的 token，有： $$ \\begin{aligned} \u0026\\mathbb E_{a\\sim\\pi_\\theta(\\cdot\\mid h)} \\left[k_1(a,h;\\theta)\\right] = D_{\\mathrm{KL}}\\!\\left( \\pi_\\theta(\\cdot\\mid h) \\Vert \\pi_{\\mathrm{ref}}(\\cdot\\mid h) \\right). \\end{aligned} $$这是 KL 定义的直接应用。$k_1$ 的单个样本可以为负，整个分布的 KL 非负。同时，如果选择多次抽样 $k_1$ 的话，总体期望与精确 KL 一样，属于无偏估计： 保持前缀不变，独立地重复抽取 $N$ 个 token： $$ a^{(1)},\\ldots,a^{(N)} \\overset{\\mathrm{iid}}{\\sim} \\pi_\\theta(\\cdot\\mid h). $$$$ \\begin{aligned} \u0026\\widehat D_{\\mathrm{KL}}^{(k_1,N)}(h;\\theta) = \\frac{1}{N}\\sum_{n=1}^{N} \\log \\frac{\\pi_\\theta(a^{(n)}\\mid h)} {\\pi_{\\mathrm{ref}}(a^{(n)}\\mid h)}. \\end{aligned} $$对这个随机估计量取期望，利用期望的线性性： $$ \\begin{aligned} \u0026\\mathbb E\\!\\left[ \\widehat D_{\\mathrm{KL}}^{(k_1,N)}(h;\\theta) \\right]\\\\ \u0026\\quad= \\frac{1}{N}\\sum_{n=1}^{N} \\mathbb E\\!\\left[ \\log \\frac{\\pi_\\theta(a^{(n)}\\mid h)} {\\pi_{\\mathrm{ref}}(a^{(n)}\\mid h)} \\right]\\\\ \u0026\\quad= D_{\\mathrm{KL}}\\!\\left( \\pi_\\theta(\\cdot\\mid h) \\Vert \\pi_{\\mathrm{ref}}(\\cdot\\mid h) \\right). \\end{aligned} $$整条回答的 KL 约束 规定 EOS 结束符也为一个 token，采用以下规定： 回答生成 EOS 时结束。 已经结束的回答，在后续位置确定性地补 EOS。 到第 $T$ 个位置时，两个策略都强制选择 EOS。 后文 $|o|$ 指含首次 EOS、不含补齐位置的有效长度。 一条较早结束的回答，可以是 ${o=(\\text {hi,how,are,you,today,?,EOS,EOS,EOS})}$，第一次 EOS 是结束选择，后面的 EOS 是为统一长度补上的。补齐位置的两个条件概率都等于 1： $$ \\pi_\\theta(\\mathrm{EOS}\\mid h_t)","d":"KL 散度学习笔记：精确 KL、k₁、k₃，以及 GRPO 中的 KL 约束与聚合方式。","dt":"2026-10-09","s":"blog","t":"KL 散度","u":"/zh/blog/kl-divergence/"},{"c":"直接微调整个模型需要大量的计算资源和显存。对于 Qwen3-0.6B（0.6B 参数），全量微调的显存需求不能只看 FP16 或 FP32，还取决于优化器、序列长度、批大小，以及是否使用梯度检查点或卸载等技术。对于更大的模型（如 7B、13B），在单张消费级 GPU 上全量微调通常会更困难。 LoRA(Low-Rank Adaptation)是一种参数高效微调方法，它只训练少量的额外参数，而保持原模型参数冻结。LoRA 的核心思想是:模型微调时的参数变化可以用低秩矩阵表示。 图源：IBM。 低秩更新与参数量 假设原模型的权重矩阵为 $W \\in \\mathbb{R}^{d \\times k}$，微调后的权重为 $W' = W + \\Delta W$。LoRA 假设 $\\Delta W$ 可以分解为两个低秩矩阵的乘积: $$ \\Delta W = BA $$其中 $B \\in \\mathbb{R}^{d \\times r}$, $A \\in \\mathbb{R}^{r \\times k}$, $r \\ll \\min(d, k)$ 是秩(rank)。 前向传播时，输出为: $$ h = Wx + \\Delta Wx = Wx + BAx $$原模型参数 $W$ 保持冻结，只训练 $B$ 和 $A$。 参数量对比:原模型参数量为 $d \\times k$，LoRA 参数量为 $d \\times r + r \\times k = r(d + k)$。当 $r \\ll \\min(d, k)$ 时，LoRA 参数量远小于原模型。例如，对于 $d=4096, k=4096, r=8$ 的情况，原模型参数量为 $4096 \\times 4096 = 16,777,216$，LoRA 参数量为 $8 \\times (4096 + 4096) = 65,536$，参数量减少了 256 倍! 这个降幅来自参数计数：可训练矩阵的每个元素贡献一个标量参数。对于正整数维度 $d,k,r$，乘积矩阵的秩至多为 $r$，未必恰好等于 $r$。对这一个权重矩阵，可训练参数量与全量参数量之比为： $$ \\begin{aligned}\\frac{\\text{LoRA parameters}}{\\text{full parameters}}\u0026=\\frac{dr+rk}{dk} =\\frac{r(d+k)}{dk} =r\\left(\\frac1k+\\frac1d\\right),\\\\\\frac{8(4096+4096)}{4096\\cdot4096}\u0026=\\frac{65{,}536}{16{,}777{,}216} =\\frac1{256}=0.00390625,\\\\\\frac{16{,}777{,}216}{65{,}536}\u0026=256.\\end{aligned} $$ 直观地说，两个窄矩阵替代了一个稠密的可训练更新。冻结的基座权重和激活仍占显存；这个比例不意味着总显存或运行时间也降低 256 倍。偏置及其他额外训练的模块还需另行计数。 秩的含义 这约束的是更新的可表示范围，并非断言每个有效的全量微调更新都具有低秩。选定的秩是否足够，取决于任务和所适配的层，应通过验证判断，不能只看参数量。 全量微调允许这个权重矩阵在参数空间中自由变化，而 LoRA 要求变化量满足： $$ \\Delta W=BA $$这带来一个数学限制： $$ \\operatorname{rank}(\\Delta W) = \\operatorname{rank}(BA) \\leq r $$当 $r=8$ 时，无论怎样训练 $A,B$，最终得到的更新矩阵的秩都不会超过 $8$。可以从输入到输出的过程理解： $$ x\\in\\mathbb{R}^{4096} \\ \\xrightarrow{A}\\ z\\in\\mathbb{R}^{8} \\ \\xrightarrow{B}\\ \\Delta h\\in\\mathbb{R}^{4096} $$ 设 $B$ 的 8 列分别是 $\\mathbf b_1,\\ldots,\\mathbf b_8$，那么： $$ \\Delta h=Bz =z_1\\mathbf b_1+z_2\\mathbf b_2+\\cdots+z_8\\mathbf b_8 $$这意味着：对这个训练好的 LoRA 分支，不同输入产生的输出修正，都由最多 8 个独立方向组合而成。其中： $A$ 根据输入决定每个方向使用多少，也就是计算 $z_1,\\ldots,z_8$。 $B$ 提供这些可以组合的输出方向。 训练过程中，$A$ 和 $B$ 都会学习，所以这些方向并不是预先固定死的。 原始 $W$ 可以是满秩的，加上低秩更新以后，$W'$ 仍然可以是满秩的。 $r$ 的选择 可训练参数 能表示的更新范围 实际效果 较小 较少 限制较强 可能足够，也可能欠拟合 较大 较多 范围更广 可能改善，也可能收益很小或泛化变差 因此，LoRA 的主要优势是减少可训练参数及其优化器状态，并便于保存和部署适配器。实际显存、训练速度、过拟合程度，以及相对全量微调的效果，仍取决于任务和配置。 如表所示，这是原学习材料中不同模型规模下的参数量和显存对比示意。表里的显存数字依赖具体训练配置，不是固定要求。 超参数与缩放 LoRA 的关键超参数包括:秩(rank，r)，控制 LoRA 矩阵的秩，越大表达能力越强，但参数量也越多，典型值为 4-64，默认 8;Alpha($\\alpha$)，LoRA 的缩放因子，实际更新为 $\\Delta W = \\frac{\\alpha}{r} BA$，控制 LoRA 的影响强度，典型值等于 rank;目标模块(target_modules)，指定哪些层应用 LoRA，通常选择注意力层(q_proj， k_proj， v_proj， o_proj)，也可以包括 MLP 层(gate_proj， up_proj， down_proj)。 把缩放写作 $c_{\\mathrm{LoRA}}=\\alpha/r$，其中 $\\alpha\u003e0$。为说明除以秩补偿的是什么，设 $z_j$ 为 $BA$ 某个固定元素中的独立标量贡献，索引为 $j=1,\\ldots,r$，各项具有共同均值 $\\mu\\in\\mathbb R$ 和方差 $\\sigma^2\u003e0$，且两者都不随 $r$ 改变。固定 $\\alpha$ 时，利用期望的线性性与方差相加，得到： $$ \\begin{aligned}\\mathbb E\\left[\\frac{\\alpha}{r}\\sum_{j=1}^{r}z_j\\right]\u0026=\\frac{\\alpha}{r}\\sum_{j=1}^{r}\\mu=\\alpha\\mu,\\\\\\operatorname{Var}\\left(\\frac{\\alpha}{r}\\sum_{j=1}^{r}z_j\\right)\u0026=\\frac{\\alpha^2}{r^2}\\sum_{j=1}^{r}\\sigma^2 =\\frac{\\alpha^2\\sigma^2}{r},\\\\\\operatorname{Var}\\left(\\frac{\\alpha}{\\sqrt r}\\sum_{j=1}^{r}z_j\\right)\u0026=\\alpha^2\\sigma^2.\\end{aligned} $$ 因子 $1/r$ 把求和变成平均，在上述假设下抵消了均值随分量数量增加而增长的部分。这说明的是均值层面的补偿。方差仍随 $r$ 改变，因此更新幅度或范数未必保持不变。训练后的分量，其均值、方差或相关性都可能随秩改变；下述初始化的更新则恰好为零。让 $\\alpha$ 与 $r$ 成正比，只能保持 $c_{\\mathrm{LoRA}}$ 固定，不能保持学到的更新固定。初始化、学习率和优化器状态也会影响训练。 缩放方式 期望 方差 $\\dfrac{\\alpha}{r}\\sum z_j$ $\\alpha\\mu$ $\\dfrac{\\alpha^2\\sigma^2}{r}$ $\\dfrac{\\alpha}{\\sqrt r}\\sum z_j$ $\\alpha\\sqrt r\\,\\mu$ $\\alpha^2\\sigma^2$ 在这套假设（各项独立，而且 $\\mu,\\sigma^2$ 不随 $r$ 改变）下，除以 $r$ 稳定的是均值，除以 $\\sqrt r$ 稳定的是方差。 初始化与权重合并 采用 $A_0$ 随机初始化、$B_0=0$，并定义 $H_W=\\partial\\ell/\\partial W^\\prime\\in\\mathbb R^{d\\times k}$。 $$ \\begin{aligned} \\Delta W_0\u0026=c_{\\mathrm{LoRA}}B_0A_0=0,\\\\ \\frac{\\partial\\ell}{\\partial A}\u0026=c_{\\mathrm{LoRA}}B^\\top H_W\\in\\mathbb R^{r\\times k},\\\\ \\frac{\\partial\\ell}{\\partial B}\u0026=c_{\\mathrm{LoRA}}H_WA^\\top\\in\\mathbb R^{d\\times r},\\\\ \\left.\\frac{\\partial\\ell}{\\partial A}\\right|_0\u0026=0,\\\\ \\left.\\frac{\\partial\\ell}{\\partial B}\\right|_0\u0026=c_{\\mathrm{LoRA}}H_{W,0}A_0^\\top. \\end{aligned} $$ 模型初始时保持基座输出，同时只要梯度非零，$B$ 就能立即学习。$A$ 的首次任","d":"LoRA 学习笔记：低秩更新、参数量、缩放、初始化及常见变体。","dt":"2026-10-08","s":"blog","t":"LoRA","u":"/zh/blog/lora/"},{"c":"MCP（Model Context Protocol） MCP 分三层，分别是上游、MCP 协议、下游。 下游称为 MCP Server/开发者或者厂商。下游负责承载具体业务逻辑，通过 MCP 规范向外注册与暴露三类核心资产： Tools：供模型调用的函数即工具（如操作 Git、查询 SQL、调用内部微服务）。 Resources：供模型只读挂载的数据上下文（如本地文件、表结构 Schema、日志流）。 Prompts：标准化的交互提示词模板与工作流预设。 上游称为 MCP Client/宿主环境，即常用的各大智能体如 Codex、Claude Code、Pi 等引擎。作为客户端，它们负责生命周期管理、协议转译与权限控制： 与配置的多个 MCP Server 建立进程或网络连接。 自动发现各 Server 暴露的 Tools/Resources 并在 Prompt 构建阶段转交给 LLM。 在模型决定调用某工具时，按标准协议组装请求并分发给目标 Server，将执行结果返回给推理循环。 接着就是 MCP 协议本身了，它是一套标准规范（基于JSON-RPC 2.0 的通信与生命周期合约），严格规范了上游和下游的报文格式、状态流转和能力协商，类似于 TCP/IP 这类协议。 整体流程以查询 GitHub 项目并按 star 数排序为例：宿主通过 MCP 获取查询工具的名称、描述和输入 Schema，再向模型提供工具定义。模型生成工具名及符合 Schema 的参数；宿主检查后，通过 tools/call 将请求发送给 MCP Server。Server 调用 GitHub API，返回结果，宿主再将结果交给模型。Schema 由工具提供方定义，模型生成的是调用参数。 MCP 的作用是统一能力描述和调用接口，减少针对不同服务重复编写通信适配的工作。各服务的业务逻辑、认证方式、权限要求和错误处理仍需分别实现或配置。 宿主可以把 MCP 工具映射为模型支持的工具调用格式，因此模型通常不需要直接处理 MCP 报文。Resources 和 Prompts 则按各自的协议接口使用，不应默认把所有内容都转换成工具或自动注入上下文。 MCP 协议的一个巨大优势是丰富的社区生态。Anthropic 和社区开发者已经创建了大量现成的 MCP 服务器，涵盖文件系统、数据库、API 服务等各种场景。这意味着你不需要从零开始编写工具适配器，可以直接使用这些经过验证的服务器。 Awesome MCP Servers (https://github.com/punkpeye/awesome-mcp-servers)，社区维护的 MCP 服务器精选列表。 MCP Servers Website (https://mcpservers.org/)，官方 MCP 服务器目录网站。 Official MCP Servers (https://github.com/modelcontextprotocol/servers)，Anthropic 官方维护的服务器。 自定义的 MCP 服务器可以满足特定的需求，它可以封装业务逻辑、访问私有数据、性能专项优化或者功能定制扩展，同时你也可以将自己制作的 MCP 发布到社区平台。 A2A（Agent-to-Agent） MCP 协议解决了智能体与工具的交互，而 A2A 协议则解决智能体之间的协作问题。在一个需要多智能体（如研究员、撰写员、编辑）协作的任务中，它们需要通信、委托任务、协商能力和同步状态。 对于传统的也是现在大部分都在用的协作架构-星型拓扑，即主 Agent 分派多个子 Agent 完成任务，由主 Agent 来整理汇报。但存在一些问题： 单点故障：主 Agent 失效导致系统整体瘫痪。 性能瓶颈：所有通信都经过中心节点，限制了并发。 扩展困难：增加或修改智能体需要改动中心逻辑。 A2A 协议采用点对点（P2P）架构（网状拓扑），允许智能体直接通信，从根本上解决了上述问题。它的核心是任务（Task）和工件（Artifact）这两个抽象概念，这是它与 MCP 最大的区别，如表 10.7 所示。 为实现对协作过程的管理，A2A 为任务定义了标准化的生命周期，包括创建、协商、代理、执行中、完成、失败等状态。 该机制使智能体可以进行任务协商、进度跟踪和异常处理。 A2A 请求生命周期是一个序列，详细说明了请求遵循的四个主要步骤：代理发现、身份验证、发送消息 API 和发送消息流 API。下图借鉴了官网的流程图，用来展示了操作流程，说明了客户端、A2A 服务器和身份验证服务器之间的交互。 ANP（Agent Network Protocol） 当智能体分布在不同平台或组织时，需要解决如何描述能力、发现服务、验证身份和跨域交互等问题。ANP 为这些开放网络中的交互提供协议基础。应用可以利用这些信息选择服务提供者，但按实时负载、成本或服务质量选出最合适 Agent 的策略，仍需应用或平台实现。ANP 的跨域通信规则不等于最优化任务调度算法。 ANP 的设计目标就是提供一套标准化的机制，来解决上述的服务发现、路由选择和网络扩展性问题。为实现其设计目标，ANP 定义了以下几个核心概念： 借用官方的入门指南来介绍 ANP 的架构设计 在该流程图中，Agent A 首先通过一个公开的发现服务，基于语义或功能描述进行查询，定位到符合其任务需求的 Agent B。该发现服务通过预先爬取各智能体对外暴露的标准端点（.well-known/agent-descriptions）来建立索引，从而实现服务需求方与提供方的动态匹配。 之后 Agent A 使用私钥对包含自身 DID 的请求进行签名，Agent B 收到后通过解析 DID 获取公钥，验证完整性和真实性，然后建立起可靠通信。 身份验证通过后，Agent B 响应请求，双方依据预定义的标准接口和数据格式进行数据交换或服务调用（如预订、查询等）。标准化的交互流程是实现跨平台、跨系统互操作性的基础。 该机制的核心是利用 DID 构建了一个去中心化的信任根基，并借助标准化的描述协议实现了服务的动态发现。这套方法使得智能体能够在无需中央协调的前提下，安全、高效地在互联网上形成协作网络。","d":"关于 MCP、A2A、ANP 的学习笔记。","dt":"2026-10-05","s":"blog","t":"MCP、A2A、ANP","u":"/zh/blog/mcp-a2a-anp/"},{"c":"设置好 .config/mini-swe-agent 中的环境之后，我们运行 bash 5 行 python -m minisweagent.run.mini \\ -c mini.yaml \\ -t \"创建一个 test_agent.txt 文件并在里面写入 Hello Agent\" \\ --model \"deepseek/deepseek-chat\" \\ --agent-class minisweagent.agents.default.DefaultAgent 会在 .config/mini-swe-agent 下得到最后一次的运行轨迹，根据该运行轨迹来进行源码的解读 整个 Repo 的框架： run/mini.py:99-101： python 3 行 model = get_model(config=config.get(\"model\", {})) env = get_environment(config.get(\"environment\", {}), default_type=\"local\") agent = get_agent(model, env, config.get(\"agent\", {}), default_type=\"interactive\") Prompt 注入 在 default.py 中我们看到了 python 4 行 self.add_messages( self.model.format_message(role=\"system\", content=self._render_template(self.config.system_template)), self.model.format_message(role=\"user\", content=self._render_template(self.config.instance_template)), ) 进行 prompt 的注入和用户的询问，prompt 在 mini.yaml 中，其中指示了如果 Agent 完成了任务，第一句应该输出 echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT。这对我们后面进行任务检查很有用。 Tool Action 接下来观察到轨迹的 content 和 tool call： json 11 行 \"content\": \"I'll start by analyzing the current directory structure to understand the environment.\", \"role\": \"assistant\", \"tool_calls\": [{ \"index\": 0, \"function\": { \"arguments\": \"{\\\"command\\\": \\\"pwd \u0026\u0026 ls -la\\\"}\", \"name\": \"bash\" }, \"id\": \"call_00_61SsIsH70VtP63w7RQ6G5957\", \"type\": \"function\" }], 展开全部 11 行 一条 assistant 消息的 extra 恰好四个键： json 6 行 extra = { \"actions\": [{\"command\": \"pwd \u0026\u0026 ls -la\", \"tool_call_id\": \"call_00_...\"}], \"response\": {...}, # 模型原始响应，整份塞进来 \"cost\": 0.000327, \"timestamp\": 1789796928.007539, } extra 不会发给模型，在 model 端有 python 2 行 def _prepare_messages_for_api(self, messages: list[dict]) -\u003e list[dict]: prepared = [{k: v for k, v in msg.items() if k != \"extra\"} for msg in messages] 在 extra 中还有用量花费和更具体的 message 可以作为统计。查看 agent 的 tools，发现该 agent 只有一个 tool 即 bash，这样做的好处是不需要进行额外的沙箱安装。况且，read/edit/write/grep 本质都是它的一行子集——加一个 read 工具，等于给 bash 的一小块能力包了层壳。 但实际上，专用工具的精确度和完成度更好，可以更适合 model 调用。相对的，只用 bash 很考验 model 的基础能力，现在的 model 能力确实足以完成绝大部分的场景。 Flag / Return Mini-Swe-Agent 的退出机制分为三种，定义继承自基类异常的 Submitted、LimitsExceeded、FormatError。环境或内部校验处直接 raise，顶层主循环 try...except 统一捕获，并在 messages 中追加 role: \"exit\"。优点就是可以跨调用栈一键跳出，可以区分正常完成和异常终止。但是这种方法是依赖 python 的异常流做正常控制流。 三种退出机制有五个异常类以及一个合成状态 code 6 行 InterruptAgentFlow ├── Submitted ├── LimitsExceeded │ └── TimeExceeded ← 注意：继承的是 LimitsExceeded，不是直接继承基类 ├── UserInterruption └── FormatError 如果格式错误次数过多、迭代次数过多或者运行超时，则返回 FormatError 和 LimitsExceeded python 19 行 if 0 \u003c self.config.max_consecutive_format_errors \u003c= self.n_consecutive_format_errors: self.add_messages( *e.messages,{ \"role\": \"exit\", \"content\": \"RepeatedFormatError\", \"extra\": {\"exit_status\": \"RepeatedFormatError\", \"submission\": \"\"}, },) if 0 \u003c self.config.step_limit \u003c= self.n_calls or 0 \u003c self.config.cost_limit \u003c= self.cost: raise LimitsExceeded({ \"role\": \"exit\", \"content\": \"LimitsExceeded\", \"extra\": {\"exit_status\": \"LimitsExceeded\", \"submission\": \"\"}, }) if 0 \u003c self.config.wall_time_limit_seconds \u003c= int(time.time() - self._start_time): raise TimeExceeded({ \"role\": \"exit\", \"content\": \"TimeExceeded\", \"extra\": {\"exit_status\": \"TimeExceeded\", \"submission\": \"\"}, }) 展开全部 19 行 如果正常完成，model 必须输出 echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT 命令，判断任务完成在 environment 层，而非让 agent 自行调用完成工具或者自行结束 python 7 行 if lines and lines[0].strip() == \"COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT\" and output[\"returncode\"] == 0: submission = \"\".join(lines[1:]) raise Submitted({ \"role\": \"exit\", \"content\": submission, \"extra\": {\"exit_status\": \"Submitted\", \"submission\": submission}, }) 在返回前，需要做一次保存 python 2 行 finally: self.save(self.config.output_path) 在执行 bash 的过程中，mini-swe-agent 使用 subprocess.popen() + 进程组来进行彻底的任务执行与撤回。通过 start_new_session 来创建一个新进程执行 bash，当执行超时的时候，该进程执行的所有子孙进程跟随着父进程统一杀死。随后将结果返回 python 7 行 try: stdout, _ = process.communicate(timeout=timeout) except subprocess.TimeoutExpired: os.killpg(process.pid, signal.SIGKILL) if os.name == \"posix\" else process.kill() stdout, _ = process.communicate() raise subprocess.TimeoutExpired(command, timeout, output=stdout) return subprocess.CompletedProc","d":"通过运行轨迹深入解读 Mini-SWE-Agent 的源码，分析 prompt 注入、工具调用、退出机制和进程管理。","dt":"2026-09-20","s":"blog","t":"Mini-SWE-Agent 源码解读","u":"/zh/blog/mini-swe-agent/"},{"c":"md文件，负责优秀分享、官方博客、论文、开源项目和真实工程经验，整理成一份可以照着执行的 AI Agent 学习 todo list：Agent-Learning-Hub Anthropic 的工程博客，务必精读 《Building Effective Agents》：Anthropic Engineering 开源的高 Stars 系统性智能体学习教程，从零开始进行的 Agent 系统构建与实战：Hello-Agents 优秀博文 - AI应用开发学习全景路线图 Harness 架构下的 Agent，推荐直接去阅读 Claude Code 和 Pi 的源码：Learn Claude Code，关于 pi agent 的优质博文：pi-coding-agent LangChain 生态，在了解 Langchain 的基础包情况下，可以尝试着学习和复现 LangGraph、DeepAgents; 项目使用 LangSmith 做轨迹追踪和Agent测评。 Agent 测评，大语言模型与 AI Agent 打造的 LLM-as-a-Judge 框架，目前：OpenJudge 作为开源项目较为全面。","d":"目前从各种渠道搜集到的一些关于学习 AI Agent 的学习资源和学习路径，后续会继续进行更新和补充","dt":"2026-09-16","s":"blog","t":"AI Agent 学习资源与路线","u":"/zh/blog/ai-agent-resources-for-now/"},{"c":"这篇笔记整理备考中的概念辨析、例题、推导和复习提醒，并按主题安排标题与配图。阅读时结合每个结论所需的条件，以及题目给定的模型和数据。 数据结构 链表 并查集(代码, 优化操作, 根的合并可视化) Prim, Dijkstra 算法的非优先队列代码实现 十字链表与多重邻接表的模拟(会画) 堆代码的实现, 以及堆模拟优先队列代码的实现 红黑树(定义结论, 插入删除) 败者树与选择置换(败者树+序号), 败者树在归并中的作用, 以及败者树的深度 计算机组成原理 浮点数特殊值, 标志位生成 乘除法原理电路以及 Booth 乘除法的移动次数, 舍入 过程调用的过程, 栈帧以及各自的任务 多处理器, 现代处理器 袁书的单周期数据通路大汇总 操作系统 进程通信方式 资源分配图的简化与判断死锁条件 虚拟机, SPOOLing 的具体过程 文件系统挂载(mounting) 位示图, 成组链接法 多处理器调度 磨损均衡 计算机网络 OSI, TCP/IP 各层作用与差异区别 物理层数字数据的线路编码方法，如曼彻斯特编码；同时区分模拟信号的调制表示。 PPP, P2P 协议 虚电路 OSPF, BGP, DHCP 的报文以及具体地址 IP 多播过程以及 IGMP 海明码的校验与纠错 802.11 中预约的时间计算以及 NAV 值的计算 移动 IP 数据结构 需要记住的: 外部排序的各种实现过程; 三种线索二叉树; 十字链表与邻接多重表的适用范围与作用与画法; 会完整的写 Dijkstra、关键路径 的手算过程; 平衡树、红黑树、B树的增删; 败者树的序号以及在选择-置换排序的用法 栈与队列 链式队列和栈的插入、删除需要修改相应结点的链接字段以及队头、队尾或栈顶指针。队列从空变为非空时通常要同时设置队头和队尾。删除队列最后一个数据结点后，应同步恢复空队列的指针状态：无头结点时队头、队尾均为 NULL；有头结点时通常让队尾重新指向头结点。 栈的插入和删除则在栈顶完成。 前缀表达式中的逻辑只是把后缀表达式反过来, 即后缀表达式是从左到右进行转化的, 那么前缀表达式就正好相反, 这里举个手算过程的例子, 对于 ${((1 + 2) * 3) - (4 + 2)}$ 来说: 从左向右, 从内向外, 将运算符移动到前面, ${(1+2)}$ 变为 ${(+12)*3}$, 然后处理右侧 ${(4+2) \\Rightarrow (+42)}$, 所以 ${((+12)*3)-(+42)\\Rightarrow (*+123)-(+42)\\Rightarrow -*+123+42}$, 对于计算机程序来说, 做的步骤如下: 反转中缀表达式。 将所有左括号 ( 换成右括号 )，将所有右括号 ) 换成左括号 (。 对反转后的记号序列使用中缀转后缀算法，以栈临时保存运算符；同优先级运算符的结合性处理也必须相应反转，不能照搬通常的出栈条件。多位数应作为一个完整记号进行反转。 将最终的结果再次反转，得到前缀表达式。 对于前缀和后缀来说, 转中缀的思路是一样的, 利用栈来保存操作数, 碰到运算符就依次出栈, 若是后缀表达式就从左往右, 若是前缀表达式就从右往左模拟 树结构 树的结构 设一个树中的最大度数为 ${max_d}$, 则节点总数 ${\\displaystyle n=\\sum_{i=0}^{max_d}n_i=\\sum_{i=1}^{max_d}i\\times n_i+1}$ 注意两个下标不一样 二叉树 对于关键字互异的二叉排序树，中序遍历得到严格递增序列；给定同一组关键字，该中序序列固定，但仅凭中序序列不能确定树的形态。含 $n$ 个结点的不带编号二叉树，其不同形态数为 $C_n=\\frac1{n+1}C_{2n}^{n}$；若结点带互异编号且不同标号安排视作不同的树，则数量为 $C_n n!$。这两个公式统计树的形态或有标号的树。结点标识互异时，前序或后序序列与中序序列配合，可以唯一确定二叉树。 对于 ${n}$ 个节点的树转二叉树, 树的边数 ${w=n-1}$ 会被分为左指针和右指针, 左指针指向子节点, 右指针指向兄弟, 故有如下性质: 左指针数：每个非叶节点保留一条指向其第一个孩子的左指针，因此左指针条数等于非叶节点数 右指针数：其余边都用于兄弟关系，即右指针。 将含 $n$ 个结点的一棵有序树转换为左孩子、右兄弟二叉树时，根没有兄弟，因此根的右子树为空；其余 $n-1$ 个结点组成根的左子树。相应形态数为 $C_{n-1}$。这里减去的是根结点后的结点数，不能把树高代入卡特兰数公式。 对于森林转二叉树, 若森林存在 ${n}$ 个非终端节点, 那么对应的二叉树应有 ${n+1}$ 个节点无右儿子. 证明: 对于 ${x}$ 个根节点, 最右边的根节点一定没有右儿子, 对于 ${n}$ 个非终端节点, 类似与根节点, 每个非终端节点的儿子都会有一个最右儿子没有有兄弟节点, 故总计 ${n+1}$ 个 对二叉排序树进行中序遍历会得到升序序列(不是前序遍历) 二叉搜索树的查找过程是一个节点一个节点的比较, 并不是看树的高度或路径长度, 而是路径上经过了几个节点 树的路径长度定义为从根节点到所有节点的总长度之和, 那么若要求该树的路径长度最小, 每个节点都会尽可能地向上走, 而这恰恰符合了完全二叉树的定义, 因此完全二叉树有最小的路径长度; 二叉树或 B 树等, 若要寻找一个结点的前驱, 应是它的左子树中的最右节点, 但该节点可能没有左子树, 此时需要返回到父节点寻找前驱或后继; 线索二叉树 非空二叉链表中，$n$ 个结点共有 $2n$ 个孩子指针域，$n-1$ 条真实边占用相应指针，因此空指针域为 $2n-(n-1)=n+1$ 个。这些空域可以用作线索：空左指针指向前驱，空右指针指向后继。 对无额外头结点的非空中序线索二叉树，首结点没有前驱、尾结点没有后继，故有 $2$ 个空线索和 $n-1$ 个非空线索。前序、后序线索树的首尾结点可能已有真实孩子指针，应按具体结构重新计数。 线索二叉树使用二叉链表存储，构建时按所需次序遍历。若结点没有左孩子，把左指针设为前驱线索；若没有右孩子，把右指针设为后继线索，并用标志位区分线索与真实孩子指针。 对前序、中序、后序线索二叉树，要按对应遍历顺序寻找前驱、后继。后序中，若右指针为空且已建立后继线索，可直接沿该线索访问后继；若右指针指向真实孩子，通常还需双亲信息。结点可能以下一个后序访问的双亲作为后继，也可能转到双亲右子树中的第一个后序结点；后者不一定只沿左指针就能找到。三叉链表保存左孩子、右孩子和双亲指针，便于处理一般情况下的后序后继；二叉链表实现则可能需要栈或从根查找双亲等辅助方法。 折半查找树 计算折半查找的成功查找长度时，将给定序列的位置构造成折半查找判定树。某结点的成功比较次数是它从根起算的层数，根为第 1 层；计算平均成功查找长度时，再按各结点的查找概率加权。 折半查找树的形态是趋同的, 即若是一个尽可能向左的二分搜索, 那么就是左子树优先, 否则就是右子树优先, 不可能两种情况同时存在 平衡搜索树（AVL、红黑树、B 树与 B+ 树） AVL树 在平衡二叉树中, 平衡因子是左子树和右子树的高度差, 所以能构成平衡二叉树的最小节点数就是每个非叶节点的平衡因子均为 1, 根据高度有如下公式: ${C_n = C_{n-1}+C_{n-2}+1}$, 其中 ${C_0=0,\\,C_1=1,\\,C_2=2}$; 最多的节点数即为满二叉树; 问: 16个节点的平衡二叉树的最大深度:由于 ${C_5=12 \\lt 16 \\lt C_6=20}$ 故为 5 平衡树中删除一个节点再添加, 由于其可以自平衡, 导致可能与原树一样, 但排序树无平衡要求, 故若删除的不是叶节点则一定不同 给定任一序列, 确定不同的平衡二叉树数量, 由于需要平衡左右子树大小, 所以要选择中间尺寸的节点作为根节点, 然后分别对这些节点进行讨论, 若确定一个根节点后, 其左右子树仍然按照上述方法进行递归确认, 以一个例子说明: 序列{1, 4, 5, 10, 16, 17, 21} 所能确定的平衡二叉树的数量: 首先由于自平衡要求, 选中根节点集合 {5, 10, 16}, 考虑对称, 5 和 16 是对称的, 看 5, 左子树确认为 1, 4, 有两种可能, 右子树最大高度为 3, 根节点集合为 16, 17, 共四种可能, 所以共 ${2\\times 4=8}$ 种; 接下来考虑根节点为 10, 左右子树 size 均为 3, 由于高度为 2 的平衡树最小节点数为 2, 高度为 3 的平衡树最小节点数为 4, 故左右子树只有一种可能, 所以总的数量为 ${8+8+1=17}$ 种; B树、B+树 B 树的插入与删除操作 插入操作：$m$ 阶 B 树的非根结点至少有 $\\lceil m/2\\rceil-1$ 个关键字，最多有 $m-1$ 个；非空根结点至少有一个关键字。常见插入算法先把新关键字放到合适的叶结点，若结点暂有 $m$ 个关键字，则选取第 $\\lceil m/2\\rceil$ 个关键字向双亲提升，将两侧关键字分别留在两个结点中。提升的关键字成为双亲中的分隔关键字；只有根分裂时才需要创建新根。 若双亲也溢出，则继续递归向上分裂。取中间位置时必须明确取整规则。 删除操作: 这里一定注意一点, 删除操作是把当前节点替换为叶节点(终端节点), 即若被删节点不是叶节点, 那么就要找其前驱或后继, 然后进行替换, 替换后删除, 所以本质是删的叶节点, 具体看王道书, 可分为三种:","d":"数据结构、计算机组成原理、操作系统场景题与计算机网络的完整备考笔记。","dt":"2026-09-09","s":"blog","t":"考研 408 笔记：数据结构、组成原理、操作系统与网络","u":"/zh/blog/kaoyan-408/"},{"c":"这篇笔记整理备考中的概念辨析、例题、推导和复习提醒，并按主题安排标题与配图。阅读时结合每个结论所需的条件，以及题目给定的模型和数据。 做到一个新的问题，想起与过去某个问题类似。发现在解答中，对此类问题，以及工具和方法的理解是存在缺陷的，或者发现理解不够深刻。于是通过解决新的问题，一并更新迭代过去的理解。 极限、导数以及微分 代数变换、递推与乘积求导 双曲正弦函数 $y=\\dfrac{e^x-e^{-x}}{2}$, 反解方法如下: 先化成 $2y+e^{-x}=e^x$，两边同乘 $e^x$，令 $u=e^x\\gt 0$，得到一元二次方程 $u^2-2yu-1=0$。两根中只有 $u=y+\\sqrt{y^2+1}$ 为正，因此反函数为 $x=\\ln(y+\\sqrt{y^2+1})$。 对于递推数列 $x_n=f(x_{n-1})$，令相邻两项均为 $a$，得到的是不动点方程 $a=f(a)$，可用于寻找常数解或极限的候选值。若求数列极限，须先证明数列收敛，并确认可将极限代入递推关系，例如 $f$ 在极限点连续。求任意第 $n$ 项还需结合初值和递推式进一步推导。$(660_{18})$ 若 $f(x)=u(x)v(x)$, 则 $f(x)$ 的泰勒展开式是这两个函数的泰勒展开式相乘, 同时也表明了, 无穷小也是会相乘的 关于 $f(x)=u(x)v(x)$ 的导数 $f'(x)=u(x)v'(x)+v(x)u'(x)$ 证明在 $p_{167}$ 页, 如果一个多因使或者 $n$ 阶导无法直接求出, 尝试简化到上述模式, 然后通过求导或者是莱布尼茨公式来求导 $$ \\frac{d^n}{dx^n} [u(x) v(x)] = \\sum_{k=0}^{n} \\binom{n}{k} u^{(k)}(x) v^{(n-k)}(x) $$或者是利用泰勒展开, 如第一点提到的多项式相乘 无穷大、等价无穷小与幂指极限 趋于无穷大描述的是极限过程，而不是某一项真的等于无穷大。 按绝对值趋于无穷大的约定，对任意 $M\\gt 0$，充分接近极限位置后都须有 $|f(x)|\\gt M$；对数列，则须对所有充分大的下标成立。无界只要求能超过任意大的界限，不要求此后一直超过。例如 $\\dfrac{1}{x^2}\\sin\\dfrac{1}{x}$ 在 $x\\to0$ 时无界，但存在趋于零的自变量序列使函数值为零，所以它的绝对值并不趋于无穷大。 若 $\\lim_{n\\to\\infty}x_ny_n=+\\infty$，则有如下推论： 不能断言 $x_n$ 或 $y_n$ 中至少一个趋于 $+\\infty$，但至少有一个数列无界，否则乘积也有界。例如令 $x_n$ 的奇数项为 $1$、偶数项为 $n$，令 $y_n$ 的奇数项为 $n$、偶数项为 $1$，则 $x_ny_n=n\\to+\\infty$，而两个因子都因有无穷多项等于 $1$ 而不趋于无穷大。 若 $x_n\\to a\\ne0$，则 $x_n$ 最终与 $a$ 同号且远离零。由 $y_n=(x_ny_n)/x_n$ 可知：当 $a\\gt0$ 时，$y_n\\to+\\infty$；当 $a\\lt0$ 时，$y_n\\to-\\infty$。若前提只写成 $|x_ny_n|\\to\\infty$，则结论是 $|y_n|\\to\\infty$。 对于函数，若两个因子的绝对值都趋于无穷大，则乘积的绝对值也趋于无穷大；若两个因子都趋于 $+\\infty$，则乘积也趋于 $+\\infty$。符号振荡可能使乘积没有带符号的无穷极限，但不会破坏前述绝对值结论。仅有无界性时，不能使用这一乘积极限规则。 数列与函数遵循相同的规则：若 $|x_n|\\to\\infty$ 且 $|y_n|\\to\\infty$，则 $|x_ny_n|\\to\\infty$；若两者均趋于 $+\\infty$，则乘积也趋于 $+\\infty$。例如对任意 $M\\gt0$，充分大的下标同时满足 $|x_n|\\gt\\sqrt M$、$|y_n|\\gt\\sqrt M$，于是 $|x_ny_n|\\gt M$。结论来自极限定义，而非数列的离散性。 对于多项相乘的求导, 要学会简化 $f(x)=\\prod_{n=1}^{100}\\,(\\tan(\\frac{\\pi\\,x^{n}}{4})-n)$ , 求 $f'(1)$ 通过观察发现 $n=1$ 的时候值为 $0$, 由于多因式求导非常复杂, 我们不希望求解多次导, 那么可以提出 $n = 1$ 的时候, 这样就有 $$ (\\tan(\\frac{\\pi\\,x}{4})-1)\\times\\prod_{n=2}^{100}\\,(\\tan(\\frac{\\pi\\,x^{n}}{4})-n) $$此时就变成了 $f(x)=u(x)v(x)$ 的形式, 再次求导就会非常方便 $y=\\frac{1-x}{1+x}$ , 求 $y^{(n)}(0)$ 我们知道 $(\\frac{1}{ax+b})^{n}$ 的导是好求的, 那么就进行转换 $y=-1+\\frac{2}{1+x}$ 一点处的信息与邻域性质 一点处的信息不可推出区间的性质 若 ${f'(x_0)}$ 存在, ${f(x)}$ 是否推出在 $x_0$ 邻域连续 不可推出。设狄利克雷函数 $D(t)$ 在无理数处取 $1$、有理数处取 $0$，构造 $F(x)=(x-x_0)^2D(x-x_0)$。由 $F(x_0)=0$ 及 $|F(x_0+h)/h|=|hD(h)|\\le|h|\\to0$，得 $F'(x_0)=0$。但在任意 $x\\ne x_0$ 处，有理数与无理数两种趋近给出不同极限，所以 $F$ 在该点不连续。这说明一点可导只保证该点连续，不能保证整个邻域连续。 若 ${f'(0)\\gt 0}$, 是否推出存在 ${\\delta\\gt 0}$ 有 ${f(x)}$ 在 ${(-\\delta,\\,\\delta)}$ 单调增加 不可推出, 考虑如下函数, 发现在 $x=0$ 邻域处导数振荡, 但$f'(0)=\\dfrac{1}{2}$ $$ f(x)=\\begin{cases}{x^2sin\\frac{1}{x} +\\frac{1}{2}x,\\,x\\neq0}\\\\ {0,\\,x=0}\\end{cases} $$ 但可以推出存在 ${\\delta}$, 左邻域均比该点小, 右邻域均比该点大, 但不意味着区间上严格单调。 复合函数的连续性要区分内、外函数的输入点。即使 $f$ 在 $x_0$ 连续，而 $g$ 在输入点 $f(x_0)$ 不连续，$g(f(x))$ 仍可能在 $x_0$ 连续。 例如，若 $f(x)\\equiv C$ 且 $g(C)$ 有定义，则 $g(f(x))\\equiv g(C)$ 是常值函数。即使 $g$ 在 $C$ 附近存在跳跃、可去或振荡间断，复合函数只取到输入 $C$，仍然连续。 关于等价无穷小 对于 $\\int_0^{\\phi(x)}f(t)\\,dt$，若在所讨论的趋近方向上 $\\phi(x)\\sim x^n$、$f(t)\\sim t^m$，且 $n\\gt0$、$m\\gt-1$ 并满足局部可积条件，则 $\\int_0^{\\phi(x)}f(t)\\,dt\\sim x^{n(m+1)}/(m+1)$，阶数为 $n(m+1)$。 不同阶的无穷小相加或相减时，由低阶项决定主项；同阶时必须先合并系数。首项抵消后，结果可能升阶甚至恒为零。对 $\\int_{g(x)}^{h(x)}f(t)\\,dt=\\int_0^{h(x)}f(t)\\,dt-\\int_0^{g(x)}f(t)\\,dt$，若两端分别产生阶数 $n(m+1)$、$k(m+1)$，只有在主项未抵消时才能取其中较低的阶数；同阶时须比较对应的系数。 对于幂函数复合，$[1+Ax^p+o(x^p)]^\\alpha=1+\\alpha A x^p+o(x^p)$。当 $\\alpha A\\ne0$ 时，减去常数项 $1$ 后的无穷小仍为 $p$ 阶。例如固定 $\\alpha\\ne0$ 时，$1-\\cos^\\alpha x\\sim\\dfrac{\\alpha}{2}x^2$；首项系数为零时须继续检查。 导数由差商的极限定义；要由其他极限信息判断可导性，需要把它准确地还原为差商。 若只给出 $\\lim_{x\\to x_0}f(x)=A$，这说明两侧极限相同。连续还要求 $f(x_0)$ 有定义且等于 $A$。若题目未给出该点函数值，连续性尚不能确定；若函数在该点没有定义，则需先补定义才可讨论其在该点连续。具体地，$f(x)=x^2$（$x\\ne0$）、$f(0)=C\\ne0$ 时，$\\lim_{x\\to0}f(x)=0\\ne f(0)$，故在零点不连续，也不可导。 ${\\lim_{x\\to x_0}\\dfrac{f'(x)}{(x-x_0)^2}=A,\\,A\\neq 0}$, 是否意味着 $x_0$ 邻域内单调? 由极限得 $f'(x)=A(x-x_0)^2+o((x-x_0)^2)$，所以 $f'(x)\\to0$，并且在充分小的去心邻域中与 $A$ 同号。因此 $f$ 在左右两个单侧区间上分别严格单调：$A\\gt0$ 时分别递增，$A\\lt0$ 时分别递减。条件未规定两侧函数值如何衔接，也未控制 $f(x_0)$，故不能保证跨越 $x_0$ 的整个邻域或整个去心集合单调。若另知 $f$ 在 $x_0$ 连续，则可将两侧单调性连接起来，并由中值定理得到 $f'(x_0)=0$。 相对的, 若是给出了 $f(x)$ 在区间 $[a,\\, b]","d":"高等数学与线性代数的完整备考笔记。","dt":"2026-09-09","s":"blog","t":"考研数学笔记：高等数学与线性代数","u":"/zh/blog/kaoyan-math/"},{"c":"Array Replacement - Rating 1700 今天是 2026 年 8月 27 日，星期四，问题链接：Array Replacement。 此题考察方式比较隐晦，我们只能从操作方法入手，这其实是一个典型的交换差分，考虑一个三元组($a_{i-1}$, $a_i$, $a_{i+1}$)，我们对它进行一次操作后，得到($a_i$, $a_{i - 1} - a_i + a_{i + 1}$, $a_{i + 1}$)。 我们思考什么情况下将 $a_i$ 替换为 $a_{i - 1}-a_i+a_{i + 1}$ 是优的。显然是在 $a_i \u003c a_{i - 1}-a_i+a_{i + 1}$ 时进行替换。我们可以把这个式子移向变为 $a_i-a_{i + 1} \u003c a_{i - 1}-a_i$，注意到与差分数组十分相似，于是考虑定义数组 $D$，满足 $D_i=a_{i-1}-a_{i}$。 我们观察一下，如果对 $a_i$ 进行操作时对 $D$ 数组的影响: 对于 $D_{i}$ 来说，它会变成 $a_{i - 1} - (a_{i - 1} - a_i + a_{i + 1}) = a_{i} - a_{i + 1} = D_{i + 1}$。 对于 $D_{i + 1}$ 来说，它会变成 $(a_{i - 1} - a_i + a_{i + 1}) - a_{i + 1} = a_{i - 1} - a_i = D_{i}$。 即一次操作，我们会交换 $D_i$ 和 $D_{i + 1}$，且只有两者奇偶性相同时才可交换。于是我们维护每段奇偶性相同的 $D$，在这段数组内按最大值排序，从头部每次减去最大的差分值来保证字典序最小即可。 代码如下： cpp 30 行 // Retired? #include \u003cbits/stdc++.h\u003e #define int long long using namespace std; const int N = 1e6 + 10, mod = 1e9 + 7; void solve(){ int n; cin \u003e\u003e n; vector\u003cint\u003e a(n + 1), d(n + 1); for(int i = 1; i \u003c= n; i++) cin \u003e\u003e a[i], d[i] = a[i - 1] - a[i]; int l = 2; while(l \u003c= n){ int r = l; while(r \u003c= n \u0026\u0026 abs(d[l] % 2) == abs(d[r] % 2)) r++; sort(d.begin() + l, d.begin() + r); reverse(d.begin() + l, d.begin() + r); l = r; } int x = a[1]; cout \u003c\u003c x \u003c\u003c ' '; for(int i = 2; i \u003c= n; i++) x -= d[i], cout \u003c\u003c x \u003c\u003c ' '; cout \u003c\u003c '\\n'; } signed main(){ std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);int t;cin\u003e\u003et;while(t--)solve(); } 展开全部 30 行 Robin Hood Archery - Rating 1900 今天是 2026 年 8月 28 日，星期五，问题链接：Robin Hood Archery。 首先考虑什么情况下 Sheriff 才不会输，由于 Robin Hood 总是先手出，那么在一大一小的情况下，他肯定选择拿大的，那么 Sheriff 不输的局面只有平局，因为他总是落后的，所以当两个数相等的局面，两者得到的分数才会相同，这样就不会输。 再看题意，题目的查询次数较大，因此需要频繁的在区间内进行统计和查询，且不具备实时性（即可以先乱序得出答案，再按问题顺序回答），因此我们考虑莫队，它可以使得我们在 $O(n \\sqrt{n})$ 复杂度内进行区间内的修改查询。 我们维护一个变量 $res$，当区间内的数频均为偶数次时 $res=0$，具体代码如下： cpp 57 行 // Retired? #include \u003cbits/stdc++.h\u003e #define int long long using namespace std; const int N = 1e6 + 10, mod = 1e9 + 7; int pos[N], a[N], cnt[N], mp[N]; struct node{ int l, r, now; bool operator\u003c (const node \u0026w) const{ return (pos[l] ^ pos[w.l]) ? pos[l] \u003c pos[w.l] : ((pos[l] \u0026 1) ? r \u003c w.r : r \u003e w.r); } }p[N]; void solve(){ int n, m; cin \u003e\u003e n \u003e\u003e m; int len = sqrt(n); for(int i = 1; i \u003c= n; i++) cin \u003e\u003e a[i], pos[i] = i / len; for(int i = 1; i \u003c= m; i++){ int l, r; cin \u003e\u003e l \u003e\u003e r; p[i] = {l, r, i}; } sort(p + 1, p + 1 + m); int res = 0; auto add = [\u0026](int x) -\u003e void{ mp[a[x]]++; if(mp[a[x]] % 2 == 0) res--; else res++; }; auto del = [\u0026](int x) -\u003e void{ mp[a[x]]--; if(mp[a[x]] % 2 == 0) res--; else res++; }; int l = 1, r = 0; vector\u003cint\u003e ans(m + 1); for(int i = 1; i \u003c= m; i++){ int id = p[i].now; while(l \u003c p[i].l) del(l++); while(l \u003e p[i].l) add(--l); while(r \u003c p[i].r) add(++r); while(r \u003e p[i].r) del(r--); ans[id] = res; } for(int i = 1; i \u003c= m; i++) cout \u003c\u003c (ans[i] ? \"NO\" : \"YES\") \u003c\u003c '\\n'; for(int i = 1; i \u003c= n; i++) mp[a[i]] = 0; } signed main(){ std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);int t;cin\u003e\u003et;while(t--)solve(); } 展开全部 57 行 Stepan and Permutation - Rating 1100 今天是 2026 年 8月 31 日，星期一，问题链接：Stepan and Permutation。 我们可以根据交换条件得出可以随意交换的位置为分成组的，组内可以随便交换，组外不可交换。考虑通过并查集来分组，对于 $a_i$ 来说，它与 $a_{i + j * x}$ 和 $a_{i + j * y}$ 一组, 其中 $j \\in {0,1,2...}$，那么我们在组内就可以直接排序，然后记录一下每一组所占的位置，按顺序安置。这样只需要检查最终结果是否为增序的排列即可。 代码如下： cpp 53 行 // Retired? #include \u003cbits/stdc++.h\u003e #define int long long using namespace std; const int N = 1e6 + 10, mod = 1e9 + 7; void solve(){ int n, x, y; cin \u003e\u003e n \u003e\u003e x \u003e\u003e y; vector\u003cint\u003e a(n + 1), p(n + 1); for(int i = 1; i \u003c= n; i++) cin \u003e\u003e a[i], p[i] = i; function\u003cint(int)\u003e find = [\u0026](int x) -\u003e int{ if(x != p[x]) p[x] = find(p[x]); return p[x]; }; for(int i = 1; i \u003c= n; i++){ if(i + x \u003c= n){ if(find(a[i]) != find(a[i + x])){ p[find(a[i + x])] = find(a[i]); } } if(i + y \u003c= n){ if(find(a[i]) != find(a[i + y])){ p[find(a[i + y])] = find(a[i]); } } } vector\u003cint\u003e b(n + 1); vector\u003cvector\u003cint\u003e\u003e v(n + 1), pos(n + 1); for(int i = 1; i \u003c= n; i++) v[find(a[i])].push_back(a[i]), pos[find(a[i])].push_back(i); for(int i = 1; i \u003c= n; i++) sort(v[i].begin(), v[i].end()); for(int i = 1;","d":"从周一开始，每天按难度递增解决 Codeforces 上的一道题","dt":"2026-09-07","s":"blog","t":"Codeforces 每日一题","u":"/zh/blog/daily-question/"},{"c":"Overview 论文链接：Retrieval-Augmented Generation RAG 整体架构 总体过程是对于一个特定性的问题，通过 MIPS 方法进行知识库检索，找到相关文件，然后“传给”大模型，大模型来结合该知识然后做出最终的回答。 问题：MIPS 方法的具体细节、如何传给大模型（是通过增加上下文，还是修改询问，还是在 token level 进行改变）、什么是边缘化以及为什么需要边缘化？ RAG-Sequence Model 、RAG-Token Model RAG-Sequence：生成回答仅依赖于一篇文档，该模型适用于答案具有强连贯性，适用于答案来自于单一来源。在解码生成答案时，模型会针对每一篇文档分别生成一组完整的候选答案句子，最后再评估哪个完整句子的综合概率最高。 $$p_{\\text{RAG-Sequence}}(y\\vert{}x) \\approx \\sum_{z \\in \\text{top-k}(p(\\cdot\\vert{}x))} p_\\eta(z\\vert{}x) p_\\theta(y\\vert{}x, z) = \\sum_{z \\in \\text{top-k}(p(\\cdot\\vert{}x))} p_\\eta(z\\vert{}x) \\prod_{i}^N p_\\theta(y_i\\vert{}x, z, y_{1:i-1})$$RAG-Token：在生成一个 Token 的时候，都会重新参考不同的文档，综合多源信息，适用于答案需要多方资源的拼凑。检索器找出前 $k$ 篇文档。当生成器准备预测下一个词时，它会基于这 ${\\displaystyle k}$ 篇文档分别计算出下一个词的概率分布，将它们汇总（边缘化）后确定这个词；在预测再下一个词时，它会重新审视这 ${\\displaystyle k}$ 篇文档并重复上述过程。 $$p_{\\text{RAG-Token}}(y\\vert{}x) \\approx \\prod_{i}^N \\sum_{z \\in \\text{top-k}(p(\\cdot\\vert{}x))} p_\\eta(z\\vert{}x) p_\\theta(y_i\\vert{}x, z, y_{1:i-1})$$ Retriever: DPR DPR 采用的是一种 Bi-encoder 架构，其核心工作机制如下： 文本向量化表示： 文档编码器：使用一个基于 $\\text{BERT}_{\\text{BASE}}$ 的文档编码器将每一篇文档 $z$ 映射为一个稠密向量表示，记为 $d(z)$。公式表示为：$d(z) = \\text{BERT}_d(z)$。 查询编码器：同样使用一个基于 $\\text{BERT}_{\\text{BASE}}$ 的查询编码器，将用户的输入查询 $x$ 映射为一个稠密向量表示，记为 $q(x)$。公式表示为：$q(x) = \\text{BERT}_q(x)$。 相似度计算与概率分布： 检索某篇文档的概率 $p_\\eta(z\\vert{}x)$ 与查询向量和文档向量的点积（内积）的指数成正比。数学表示为： $$p_\\eta(z\\vert{}x) \\propto \\exp(d(z)^\\top q(x))$$“参数化记忆”是指模型在训练过程中，将知识通过权重（例如神经网络中的连接权重）压缩并储存在模型内部。BERT 或 BART 这类预训练模型的参数就是它们的参数化记忆。 而“非参数化记忆”则截然不同。它类似于模型的一个外部知识库或外挂硬盘，知识以原始的、独立的数据形式保存在模型外。 MIPS 负责解决在庞大的知识库向量中，如何快速找出与 ${\\displaystyle q(x)}$ 内积最大(最相似)的前 ${\\displaystyle k}$ 个向量。挨个点积运算会很慢，MIPS 就是负责快速干这个事情的，论文中具体的算法使用了FAISS 库结合 HNSW 算法 RAG 的微调过程（整体工作流程） Forward： 用户输入问题 $x$。 $\\text{BERT}_q$ 把它变成向量 $q(x)$。 用 $q(x)$ 去冻结的文档库里做内积计算（MIPS），找出 Top-K 篇文档 $z$，并得到它们的检索概率 $p(z\\vert{}x)$。 生成器 BART 把问题 $x$ 和文档 $z$ 拼在一起作为输入，逐词生成答案，得到生成概率 $p(y_i\\vert{}x, z, y_{\\lt i})$。 将检索概率和生成概率结合（边缘化），算出最终的损失函数值（Loss，即上面的负边缘对数似然）。 Backward 与 Fine-tuning： BART： 梯度会流回 BART 的编码器（理解问题+文档）和解码器（生成答案）中。BART 内部的 Self-Attention、Cross-Attention 和FFN 的权重矩阵会进行参数更新。BART 借此学会如何更好地从拼在一起的文本中提取知识并组织成流畅的句子。 $\\text{BERT}_q$： 梯度会穿过生成器，流回到检索概率 $p(z\\vert{}x)$，然后再顺着内积公式 $\\exp(d(z)^\\top q(x))$，最终流回查询向量 $q(x)$，并一直流回 $\\text{BERT}_q$ 的内部参数。$\\text{BERT}_q$ 内部的注意力机制和权重随之更新。这样，下次遇到类似问题时，$\\text{BERT}_q$ 输出的向量坐标就会稍微偏移一点，变得离那些“真正有助于生成答案的文档”的固定向量更近一点。 边缘化及其作用 数学视角的边缘化 从概率论的底层公式以及深度学习的反向传播（梯度流向）角度，来解释“边缘化”在 RAG 模型中的精妙设计。 如果我们需要求事件 $Y$（生成正确答案）发生的概率，但这个过程依赖于一个中间的隐藏系统状态 $Z$（检索到了哪篇文档），且 $Z$ 有多种互斥的可能（即文档集合中的不同文档），我们就可以使用全概率公式。 对于任意一篇具体的文档 $z$，“检索到文档 $z$ 且基于 $z$ 生成答案 $y$” 的联合概率为：$p(y, z\\vert{}x) = p(y\\vert{}x, z) \\cdot p(z\\vert{}x)$。 因为真正的答案不依赖于某一篇特定的文档，所以我们要把所有中间状态 $Z$ 的可能性穷尽并相加。这在数学上就是对隐变量 $Z$ 积分（离散情况下为求和）： $$p(y\\vert{}x) = \\sum_{z} p(y\\vert{}x, z) p(z\\vert{}x)$$ 在 RAG 模型中，为了控制计算复杂度，求和的范围从无限的文档空间，被“截断”近似为了 MIPS 找出的 Top-K 篇文档，即 $z \\in \\text{top-k}(p(\\cdot\\vert{}x))$。 这就是边缘化的数学形态。但在深度学习中，它最重要的意义在于接下来的梯度反向传播。 梯度视角的边缘化 在 2.4 节提到，RAG 没有任何标签告诉检索器“该检索哪篇文档”，它的目标函数是最小化负边缘对数似然： $$\\mathcal{L} = -\\log p(y\\vert{}x) = -\\log \\sum_{z \\in \\text{Top-K}} p_\\theta(y\\vert{}x, z) p_\\eta(z\\vert{}x)$$ 当我们对检索器的参数 $\\eta$ 求计算梯度，有： $$\\frac{\\partial \\mathcal{L}}{\\partial \\eta} = - \\frac{1}{\\sum_{z'} p_\\theta(y\\vert{}x, z') p_\\eta(z'\\vert{}x)} \\sum_{z \\in \\text{Top-K}} p_\\theta(y\\vert{}x, z) \\frac{\\partial p_\\eta(z\\vert{}x)}{\\partial \\eta}$$ 这个梯度公式揭示了模型是如何自学检索的，若选择了恰当的文档 ${\\displaystyle z}$ 那么 $p_\\theta(y\\vert{}x, z)$ 会很高，则梯度会向这个方向更新。它通过加权求和的形式，隐式地将 BART 的成功与否直接转化为了动态的评价信号。 实验与思考 作者把 December 2018 的 wiki dump 中的文章进行了分段，每段大约 100 个单词，共有 2100w 段，作者在这里把一段设定为一个文档。作者从开放领域的QA、抽象式QA、危险边缘问题生成、事实核查四个方面对 RAG 两个模型进行了检测。 即使不使用任何专门促进多样性的解码策略，RAG 模型的生成多样性也显著高于单纯的 BART 模型。其中，RAG-Sequence 的多样性又高于 RAG-Token。这说明引入外部文档作为上下文，天然地丰富了模型生成文本时的词汇和表达。针对于开放领域QA这类检索类较强的场景，RAG-Seq 明显表现更好，对于危险边缘问题生成这类不精确的场景，RAG-Token 由于可以结合多篇文档从而表现更好。 生成任务中不同三元组与总三元组的比例 其中有趣的一点是，RAG-Token 在危险边缘问题生成上的生成多样性不如 RAG-Seq。既然 RAG-Token 能够把多篇文档的信息拼凑在一起，按理说它的词汇和表达应该更丰富、更多样才对。核心原因在于：“RAG-Token 的词元级融合本质上是一种概率平滑与共识妥协，而 RAG-Sequence 是一种路径锁定与个性保留”。 在 RAG-Token 中，模型在生成每一个词时，都会对 ${\\displaystyle k}$ 篇文档给出的","d":"针对于 Retrieval-Augmented Generation 论文做出的笔记以及思索","dt":"2026-08-30","s":"blog","t":"笔记：Retrieval-Augmented Generation","u":"/zh/blog/noterag/"},{"c":"这篇合集把我 2023-2024 年写在博客园的算法笔记整理成了七章。整理时保留了原文的思路讲解、推导和代码（包括当年随手写下的吐槽），个别只贴了代码的地方补了讲解，写得特别长的地方稍作精简，图床失效的图做了说明。想看未删减的原文，点每节开头的源笔记链接即可。 第一章 基础算法 1.1 前缀和与差分 前缀和解决的是\"多次查询任意区间和\"：预处理 $s_i = s_{i-1} + a_i$ 后，$[l, r]$ 的和就是 $s_r - s_{l-1}$。二维版本按容斥展开：$s_{i,j} = s_{i-1,j} + s_{i,j-1} + a_{i,j} - s_{i-1,j-1}$。当时在《基础算法大全》里写的模板： cpp 6 行 ///s[i][j] = s[i-1][j] + s[i][j-1] + a[i][j] - s[i-1][j-1] for (int i = 1; i \u003c= n; i++) for (int j = 1; j \u003c= m; j++) s[i][j] = s[i-1][j] + s[i][j-1] + a[i][j] - s[i-1][j-1]; // 查询 (x1,y1)-(x2,y2)： printf(\"%d\\n\", s[x2][y2] - s[x2][y1-1] - s[x1-1][y2] + s[x1-1][y1-1]); 差分是前缀和的逆运算：$a$ 是 $b$ 的前缀和，那么\"区间 $[l,r]$ 整体加 $c$“只需 $b_l \\mathrel{+}= c,\\ b_{r+1} \\mathrel{-}= c$，最后做一遍前缀和还原： cpp 4 行 void Insert(int l, int r, int c) { b[l] += c; b[r + 1] -= c; } 《再谈 前缀和，差分，离散化》里用三道题把这套东西串了起来： 激光炸弹（P2280）：二维前缀和后枚举每个框。注意\"点在边上无效”——3×3 的框实际框住的是 2×2 的炸弹，所以累加时从 $(1,1)$ 开始而不是 $(0,0)$； 增减序列：目标是把差分数组 $c_2 \\dots c_n$ 全变为 0。设正数和为 $res$、负数和为 $ans$，每次操作可以选一个正一个负同时消去，答案就是 $\\min(res,ans) + |res-ans|$，方案数为 $|res-ans|+1$； 借教室（二分 + 差分）：暴力逐个订单检查是 $O(nm)$ 只有 45 分；观察到\"前 $k$ 个订单不超限\"具有单调性，二分答案，check 里用差分把前 mid 个订单累加后逐位验证，降到 $O((n+m)\\log m)$。那篇笔记里两版代码都留着，对比着看很有意思。 源笔记：基础算法大全 · 再谈 前缀和，差分，离散化 1.2 双指针与离散化 双指针的入门题是最长不重复子串：右指针 $i$ 不断右移，发现重复后左指针 $j$ 一直右移直到窗口干净。两个指针各走 $n$ 步，均摊 $O(n)$： cpp 5 行 for (int i = 0; i \u003c n; i++) { s[a[i]]++; while (s[a[i]] \u003e 1) s[a[j++]]--; ///直到 j 与 i 的区间内没有重复元素 res = max(res, i - j + 1); } 离散化解决\"值域大、个数少\"：把出现过的坐标排序去重，二分找秩。经典应用是程序自动分析（P1955）——$i, j$ 开到 $10^9$，不离散化等着爆吧。流程：先把所有下标排序去重，相等约束先全部合并，再逐条检查不等约束有没有被并进同一集合（查找内鬼）。 源笔记：基础算法大全 1.3 快速幂与高精度 快速幂把 $O(k)$ 的幂运算压到 $O(\\log k)$：指数按二进制拆位，平方底数、按位乘入答案。 cpp 9 行 //a^b%k long long qpow(long long a, long long b, long long k) { long long res = 1; while (b) { if (b \u0026 1) res = res * a % k; b \u003e\u003e= 1, a = a * a % k; } return res; } 高精度用数组按位存（下标 1 为个位）。加法逐位相加带进位 $t$；乘法的核心是\"$i$ 位乘 $j$ 位落在 $i+j-1$ 位\"： cpp 3 行 c[i + j - 1] = a[i] * b[j] + t + c[i + j - 1]; t = c[i + j - 1] / 10; c[i + j - 1] %= 10; 练手：加法/乘法模板题、[NOIP1998] 阶乘之和（边乘边加边进位，最后清前导零）。 源笔记：快速幂 · 高精度 1.4 贪心 当时的贪心笔记是一个区间类大合集，一个模型配一道题： 区间选点 / 最大不相交区间：按右端点排序，能放就放。区间选点（放最少的点覆盖所有区间）和 yyy 选比赛（参加最多的比赛）是同一套排序的两种问法——“结束越早，腾出的空间越多”； 区间分组：按左端点排序，小根堆维护每组的最大右端点。新区间若与堆顶（最小右端点的组）都相交就新开组，否则并入右端点最小的组，组数即堆的大小； 合并果子：每次合并最小的两堆，小根堆裸题； 转化型：雷达覆盖把每个点转成 x 轴上的区间 $[x-d, x+d]$（$d=\\sqrt{r^2-y^2}$），退化成区间选点；田忌赛马用\"上等马对上等马、下等马对下等马、最差的马消耗对方上等马\"的双指针策略；钓鱼问题枚举最后一个湖，堆内按当前产量反复取最大。 区间分组的实现（注释是原文的）： cpp 9 行 // 用小根堆维护所有组的右端点的最大值 priority_queue\u003cint, vector\u003cint\u003e, greater\u003cint\u003e\u003e heap; for (int i = 0; i \u003c n; i++) { // 如果堆为空或者堆的最小右端点 \u003e= 现在区间的左端点，说明有交集，需要新开一个组 if (heap.empty() || heap.top() \u003e= range[i].l) heap.push(range[i].r); // 否则说明至少与最小的右端点的组没有交集，将它放到右端点最小的组里去 else { heap.pop(); heap.push(range[i].r); } } printf(\"%d\\n\", heap.size()); 源笔记：贪心算法 1.5 反悔贪心 这是当时写得最完整的一篇理论笔记，“爬山\"的比喻原文照录： 众所周知，正常的贪心算法是指在对问题求解时，总是做出在当前看来是最好的选择……每一步都是站在当前产生的局面上所作出的最好的选择，是没有反悔操作的。不加反悔的一直朝着当前局面的最优解走很可能导致我们被困在局部的最优解而无法到达全局的最优解，就好像我们爬山就只爬到了一座山的山顶却没有到整片山的最高处。但是反悔贪心允许我们在发现现在不是全局最优解的情况下回退一步或若干步采取另外的策略去取得全局最优解——就好像我们站在的一座山的山峰上，看到了还有比我们现在所在位置还高的山峰，那我们就反悔：下山再爬上那座更高的山。 被困在局部最优：只爬到了一座山的山顶 反悔：下山再爬上那座更高的山 按实现方式分两派：反悔堆（用堆维护已选决策中\"性价比最低\"的，新决策更优就替换）和反悔自动机（设计一种差值拆分，使任何贪心路径都收敛到全局最优）。 用时一定模型（工作调度）：任务按截止时间排序，时间够就做、利润进小根堆；时间不够，就用当前任务换掉堆里利润最低的任务——任务数不变、总利润更大： cpp 7 行 sort(v.begin(), v.end()); int now = 0, res = 0; for (auto [x, y] : v) { // x=截止时间, y=利润 if (x \u003e now) res += y, now++, que.push(y); else if (!que.empty() \u0026\u0026 y \u003e que.top()) res += (y - que.top()), que.pop(), que.push(y); // 反悔：换掉利润最低的 } 价值一定模型（建筑抢修 [JSOI2007]）：价值都一样，就换掉耗时最长的任务，给后面留更多时间——维护大根堆，写法对称：now + x \u003c y 就做，否则 x \u003c que.top() 时替换。 堆反悔自动机（CF865D Buy Low Sell High）的关键是恒等式： $$C_{sell} - C_{buy} = (C_{sell} - C_i) + (C_i - C_{buy})$$原文的解释：我们先把当前的价格放入小根堆一次（贪心），判断当前的价格是否比堆顶大，若是，就将差值计入全局最优解，再将当前的价格放入小根堆（反悔操作）——相当于把当前的股票价格作为\"中间变量” $C_i$ 记录下来，之后某天真的卖出时，差值自然把中间项消掉，等价于从最优的那天买、最优的那天卖。 双向链表反悔自动机（种树 BZOJ2151）：选了 $B$ 之后相邻的 $A, C$ 作废，但如果全局最优是 $A+C$ 呢？新建一个价值为 $a + c - b$ 的节点 $P$ 替换进链表，下次选中 $P$ 就等于反悔\"不选 $B$ 改选 $A+C$\"。配合大根堆 $O(n \\log n)$。原文的四个注意点：一定要记录这个点选没选过，已选过的从堆中丢出去；1 与 n 相邻要特判；双向链表一定不要写挂了；一定要先将新建点","d":"把博客园两年间写下的算法笔记整理成一部合集：基础算法、搜索、动态规划、数据结构、字符串、图论、数学，共七章","dt":"2026-08-29","s":"blog","t":"算法笔记大合集","u":"/zh/blog/algorithm-collection/"},{"c":"确立模拟业务场景，建立数据 我选取的 是自动化科研助手，其中数据是让 AI 随机化生成的，主要结构如下： text 5 行 D:\\Shixun\\harness-research\\ ├── data\\ # 模拟文献、实验数据（只读，Worker 不可改） ├── scripts\\ # 工具脚本（lit_read / exp_stats / report_export）... ├── evidence\\ # 证据目录：调研纪要、分析日志、评审意见（按 task_id 组织） ├── .hermes.md # 项目规则（Hermes 自动发现并注入） 确立工作流 工作流 编排方式 为什么用这种方式 验证架构的哪一层 1. 文献调研纪要 单 Agent 直执行 6 篇文献顺序读取，彼此无依赖也无并行收益，单会话可完成 执行层：工具链能否跑通、Skill 能否加载、审计能否留痕 2. 实验方案设计 delegate_task 并行委派 文献依据 / 数据审计 / 方案设计三个子任务互不依赖，且各自需要独立上下文，避免互相污染 编排层：多 Agent 分工、结构化交接、主 Agent 合并 3. 报告评审全流程 Kanban 跨会话、有依赖顺序（Planner → Worker → Reviewer）、失败后要能阻塞并恢复 状态层 + 控制层：状态持久化、返工闭环、异常恢复 工作流 1 回答「单个 Agent 到底能不能干活」——这是一切的前提； 工作流 2 回答「多个 Agent 能不能分工而不互相干扰」； 工作流 3 回答「出错了能不能恢复」。 建立可提交的 Plugin 新建版本化插件 在工作区新增： text 5 行 D:\\Shixun\\harness-research\\plugins\\research_v2\\ ├─ __init__.py ├─ plugin.yaml ├─ schemas.py └─ tools.py plugin.yaml 使用新名称： yaml 11 行 name: research_v2 version: 2.0.0 description: 科研 Harness 受限业务工具——规划读取、文献读取、实验统计、证据输出与独立评审 provides_tools: - project_read - lit_read - exp_stats - exp_head - evidence_read - report_export - review_export 展开全部 11 行 将工具拆成角色可配置的 toolset 在 __init__.py 中按角色能力注册： toolset 工具 角色 research_planner project_read Planner，只读研究问题和项目规则 research_read lit_read、exp_stats、evidence_read Worker/Reviewer 读取与复核 research_write report_export Worker 输出业务报告 research_review review_export Reviewer 输出评审意见 其余工具按上表注册。这样才能用 hermes tools enable/disable 对 Profile 做真正的工具白名单，而不是让三个角色共享全部写入能力。 用 hermes tools enable/disable 做工具白名单 创建 schemas.py 指明 Agent 中各个角色的模式 schemas.py：各个角色的模式 在 tools.py 加路径白名单，禁止覆盖证据 使用 pathlib.Path.resolve()，把每类工具限制在固定目录： python 4 行 WORKSPACE_ROOT = Path(r\"D:\\Shixun\\harness-research\").resolve() LITERATURE_ROOT = (WORKSPACE_ROOT / \"data\" / \"literature\").resolve() EXPERIMENT_ROOT = (WORKSPACE_ROOT / \"data\" / \"experiments\").resolve() EVIDENCE_ROOT = (WORKSPACE_ROOT / \"evidence\").resolve() 把报告写入模式从 w 改为独占创建 x： python 2 行 with open(output_path, \"x\", encoding=\"utf-8\") as f: ... tools.py 的路径白名单与独占创建 增加逐次业务审计 不依赖 agent.log。每次工具调用另写一个唯一 JSON 审计文件： text 1 行 evidence/\u003ctask_id\u003e/audit/\u003ctimestamp\u003e_\u003cuuid\u003e.json 日志字段具体为： json 12 行 { \"timestamp\": \"2026-08-08T10:00:00+08:00\", \"task_id\": \"task-003\", \"profile\": \"worker\", \"tool\": \"exp_stats\", \"input_paths\": [\"data/experiments/exp_adversarial.csv\"], \"parameters\": {\"columns\": [\"standard_acc\", \"robust_acc\"], \"group_by\": \"setting\"}, \"status\": \"ok\", \"duration_ms\": 12, \"output_path\": null, \"error\": null } 展开全部 12 行 审计中不记录报告全文、API Key、密码或完整环境变量。审计文件同样使用独占创建，保证并发调用不互相覆盖。 测试 Plugin 源码 Powershell 的命令分别为：检查语法错误、测试只读工具、生成的审计日志。 左边界面发现审计日志中有 task_id、profile、tool、parameters、status、duration_ms；没有报告全文、API Key 或密码；路径越界失败也有审计 Plugin 源码测试：语法检查、只读工具与审计日志 语法检查通过、3 个合法调用成功、越界调用失败、审计存在。 安装 Plugin 到 Hermes 由于我在此之前做过一个类似的插件，所以这个插件标记为 v2，因此我需要先禁用掉原来的 Plugin 在启动，从运行截图可以看到 Hermes 安装成功 Hermes 安装 Plugin 成功 执行 text 1 行 hermes tools list hermes tools list 设置角色 Profile、规划、记忆 创建 Profile 创建 Profile，分别是 Planner，Worker，Reviewer，按照以下命令进行，可以看到 list 正常显示了三个角色 text 5 行 hermes profile create planner --clone-all --description \"拆解科研任务、设置依赖和验收标准，只负责规划与编排\" hermes profile create worker --clone-all --description \"调用受限科研工具读取文献、统计数据并生成新证据\" hermes profile create reviewer --clone-all --description \"独立读取原始数据和证据，决定通过、阻塞或返工\" hermes profile list 三个角色的 Profile 列表 建可提交的角色模板目录 下面创建 9 个模板文件：每个角色一个 SOUL.md、一个 memories/USER.md、一个 memories/MEMORY.md，下图展示部分模板： 角色模板目录（部分） 设置工作目录和工具白名单 每个角色都应该针对于不同的 tools 拥有不同的使用权，因此需要单独设置，这里给出 Planner 可以使用以及不可以使用的工具 text 5 行 hermes profile use planner hermes config set terminal.cwd D:\\Shixun\\harness-research hermes tools disable web browser terminal file code_execution vision image_gen bfl tts cronjob computer_use research_read research_write research_review hermes tools enable research_planner skills todo memory session_search clarify delegation hermes tools list Planner 的工具白名单 验证 Profile 权限与 Memory 加载 Planner 权限测试： Planner 权限测试 Worker Memory 测试： Worker Memory 测试 其余角色测试均没问题，不再赘述。 值得注意的是，当我完成 3 个工作流后，Reviewer 的记忆发生了改变，Reviewer 往自己的记忆里面写入了一些新东西 流程结束后 Reviewer 的记忆发生了变化 本阶段通过：三 Profile 存在、工具权限不同、记忆在新会话生效、Planner/R","d":"围绕一个自动化科研助手场景，从 Plugin、权限、审计到三条工作流与自动化测试的 Harness 全流程搭建","dt":"2026-08-08","s":"blog","t":"基于 Hermes 的 Harness 工程","u":"/zh/blog/hermes-harness/"},{"c":"教育经历 天津大学2026.09 – 2029.06（预计） 计算机技术 · 硕士天津 方向：大语言模型与 Agent。 烟台大学2022.09 – 2026.06 计算机科学与技术 · 学士烟台 奖项 蓝桥杯全国总决赛 一等奖（前3%）2026.06 全国高校计算机能力挑战赛（本研组） 一等奖2024.12 团体程序设计天梯赛 个人二等奖（前6%）2026.05 蓝桥杯全国总决赛 二等奖2025.06 团体程序设计天梯赛 个人三等奖 / 团体三等奖2025.05 全国大学生数学竞赛 山东省一等奖2025.11 百度之星程序设计大赛 山东省铜奖2024.7 中国大学生计算机设计大赛 山东省三等奖2024.10 项目 基于深度学习的中国民族歌舞个性化推荐系统 Python · PyTorch · Scrapy 图文、音视频内容的精准推荐，采用离线特征定时更新与在线实时运算的混合模式。 基于 BERT 与 mengzi-T5 的双模型中文问答机器人 Python · PyTorch · Transformers 面向中文阅读理解的高精度问答系统，主要解决长文本语义建模不足、以及用户输入错别字干扰答案抽取这两个问题。 基于 Bahdanau Attention 与 Transformer 的中英翻译 Python · PyTorch 用 PyTorch 从头搭了两个经典 NLP 翻译模型——带 Bahdanau 注意力的 Seq2Seq (GRU) 与标准 Transformer，在 Opus/Tatoeba 上完成中英互译。 技能 深度学习 —— 熟练使用 PyTorch 搭建与训练模型。自学 STAT 157、CS329P 等课程，独立实现过 FCN/ResNet 的人像虚化、Transformer 与 LSTM 的序列生成；有 Kaggle 语义分割、图像分类的实战经验。 算法 —— A*、线段树、动态规划、计算几何、数论，对计算机底层原理也比较熟悉。 语言与工具 —— Python、C/C++、LaTeX；用 Git/GitHub 做版本控制，代码与文档撰写习惯尚可。 英语 —— CET-6；长期读《经济学人》等英文外刊。 兴趣爱好 算法竞赛、写博客、做分享 联系 邮箱：Gmail，QQ 代码在 GitHub，早期的技术笔记在博客园。","d":"","dt":"","s":"","t":"关于我","u":"/zh/about/"}]