《AI Agent 技术原理与架构·决策、记忆与学习》4.2 HTN/PDDL:计划表示与可验证性

上一节说了依赖图,这一节说计划本身:分解用什么表示、校验怎么进行。HTN 负责把复合任务递归拆成原始动作,PDDL 式的动作模型负责判断一串动作在给定状态下能否执行、执行后是否达到目标。实验用发布流程演示完整计划、漏测计划与未知动作三种校验结果。

以下数字为教学示例,不构成对任何真实系统或供应商的承诺。

上一节的 DAG 描述了"谁依赖谁",这一节描述计划本身:一个计划是什么、怎么表示、怎么验证。计划的价值不在于"看起来合理",而在于能执行、能校验、失败能归因。HTN(层次任务网络)负责"怎么把大任务拆成原始动作",PDDL 风格的动作模型负责"这串动作在给定状态下是否合法"。

两个表示是互补的:HTN 管分解,动作模型管执行。合起来,才能回答"这个计划能不能做、缺什么、在第几步失败"。

两种计划表示的分工

表示管什么输出验证什么
HTN 分解复合任务 → 原始动作动作序列每一步前置条件
PDDL 动作模型动作的前置/效果状态转移前提满足、目标达成

HTN 的方法(method)把一个复合任务展开成一组子任务,子任务还能再展开,直到全部成为原始动作。PDDL 风格的动作则声明三样东西:前置条件 pre、添加效果 add、删除效果 delete。展开过程中,前面子任务的效果会累积进状态,因此后面方法的前置条件看到的是"执行到当前位置的状态",而不是初始状态。

前置条件是计划安全的关键

动作模型里最重要的概念是前置条件。一个动作只有在当前状态包含其全部前置条件时才能执行;不满足就在执行前失败,而不是执行到一半才发现。

前置条件带来两个直接收益:

  1. 失败可预测:校验器能报告"第几步缺哪个事实",而不是执行器遇到运行时错误;
  2. 顺序强制:计划中动作的先后必须符合状态累积的规律,不能把"需要测试通过"的动作放在测试之前。

实验里的 deploy_staging 前置条件是 artifact_built, tests_passed, staging_ready 三个事实。缺一个,校验器就能在计划的早期报告,而不是等到部署阶段才暴露。

最小实验:发布流程

下面的实验定义了一个发布流程的动作模型与 HTN 方法,然后做三次校验:

  1. 完整计划:正常分解并执行;
  2. 漏测计划:把 test 从计划里去掉,看校验器能否发现;
  3. 未知动作:计划里出现一个不存在的动作 deploy,看校验器如何报告。
# file: agp_lab/htn_plan.py | write
# tier: 3
# verify: python3 -m unittest tests.test_htn_plan
"""HTN 分解与 PDDL 式计划校验。

HTN 负责“把复合任务拆成原始动作”,PDDL 式的动作模型负责“判断这串
动作在给定状态下能否执行、执行后是否达到目标”。两者合起来,才能
回答计划是否可验证:分解出的每一步都有前置条件,前置条件不满足就
在执行前失败,而不是执行到一半才发现。

实验先分解一个发布任务,再分别用完整计划、漏掉测试的计划和一个含
未知动作的计划做校验,输出失败发生在第几步、缺哪个事实。
"""
from __future__ import annotations

from dataclasses import dataclass


class DecompositionError(ValueError):
    """没有可用方法,或递归深度超限。"""


@dataclass(frozen=True)
class Action:
    name: str
    pre: frozenset[str]
    add: frozenset[str]
    delete: frozenset[str]


@dataclass(frozen=True)
class Method:
    name: str
    task: str
    pre: frozenset[str]
    subtasks: tuple[str, ...]


@dataclass(frozen=True)
class PlanCheck:
    valid: bool
    executed: int
    failure: str | None
    step: int | None
    missing: tuple[str, ...]
    final_state: frozenset[str]


def action(name: str, pre: set[str], add: set[str], delete: set[str] | None = None) -> Action:
    """构造动作的小工具,避免在表格里反复写 frozenset。"""
    return Action(name, frozenset(pre), frozenset(add), frozenset(delete or set()))


def _apply(state: frozenset[str], current: Action) -> frozenset[str]:
    """前置满足时施加动作效果;不满足则保持原状态,交给校验器报错。"""
    if current.pre <= state:
        return (state - current.delete) | current.add
    return state


def _decompose(
    task: str,
    methods: list[Method],
    actions: dict[str, Action],
    state: frozenset[str],
    depth: int,
    max_depth: int,
) -> tuple[tuple[str, ...], frozenset[str]]:
    if depth > max_depth:
        raise DecompositionError(f"{task}: 递归深度超过 {max_depth}")
    if task in actions:
        return (task,), _apply(state, actions[task])
    for method in methods:
        if method.task == task and method.pre <= state:
            plan: list[str] = []
            current = state
            for subtask in method.subtasks:
                subplan, current = _decompose(
                    subtask, methods, actions, current, depth + 1, max_depth
                )
                plan.extend(subplan)
            return tuple(plan), current
    raise DecompositionError(f"{task}: 没有可用的分解方法")


def decompose(
    task: str,
    methods: list[Method],
    actions: dict[str, Action],
    state: frozenset[str],
    depth: int = 0,
    max_depth: int = 8,
) -> tuple[str, ...]:
    """按声明顺序选择第一个前置条件满足的方法,递归展开为原始动作。

    展开过程中会把原始动作的效果累加到状态里,因此后面的方法前置
    条件看到的是前面子任务执行后的状态,而不是初始状态。
    """
    plan, _ = _decompose(task, methods, actions, state, depth, max_depth)
    return plan


def validate_plan(
    actions: dict[str, Action],
    initial: frozenset[str],
    plan: tuple[str, ...],
    goal: frozenset[str],
) -> PlanCheck:
    """逐步检查前置条件并施加效果,最后检查目标是否满足。"""
    state = set(initial)
    for index, name in enumerate(plan, start=1):
        current = actions.get(name)
        if current is None:
            return PlanCheck(
                False, index - 1, "unknown_action", index,
                (name,), frozenset(state),
            )
        missing = current.pre - state
        if missing:
            return PlanCheck(
                False, index - 1, "precondition", index,
                tuple(sorted(missing)), frozenset(state),
            )
        state = (state - current.delete) | current.add
    unmet = goal - state
    if unmet:
        return PlanCheck(
            False, len(plan), "goal", None,
            tuple(sorted(unmet)), frozenset(state),
        )
    return PlanCheck(True, len(plan), None, None, (), frozenset(state))


def build_world() -> tuple[dict[str, Action], list[Method], frozenset[str], frozenset[str]]:
    """发布流程的动作模型、HTN 方法与初始/目标状态。"""
    actions = {
        "build": action("build", {"source_ready"}, {"artifact_built"}),
        "test": action("test", {"artifact_built"}, {"tests_passed"}),
        "deploy_staging": action(
            "deploy_staging",
            {"artifact_built", "tests_passed", "staging_ready"},
            {"staging_deployed"},
        ),
        "verify": action("verify", {"staging_deployed"}, {"verified"}),
        "promote": action("promote", {"verified"}, {"production_deployed"}),
    }
    methods = [
        Method("release", "release", frozenset(), ("prepare", "ship")),
        Method("prepare", "prepare", frozenset(), ("build", "test")),
        Method(
            "ship", "ship", frozenset({"tests_passed"}),
            ("deploy_staging", "verify", "promote"),
        ),
    ]
    initial = frozenset({"source_ready", "staging_ready"})
    goal = frozenset({"production_deployed"})
    return actions, methods, initial, goal


def describe(check: PlanCheck) -> str:
    """把校验结果压成一行,缺哪个事实直接可读。"""
    if check.valid:
        return f"valid=True executed={check.executed}"
    missing = ",".join(check.missing) or "-"
    return (
        f"valid=False failure={check.failure} step={check.step} "
        f"missing={missing}"
    )


if __name__ == "__main__":
    actions, methods, initial, goal = build_world()
    plan = decompose("release", methods, actions, initial)
    print("HTN 分解: " + " -> ".join(plan))
    print("完整计划: " + describe(validate_plan(actions, initial, plan, goal)))
    broken = tuple(name for name in plan if name != "test")
    print("漏测计划: " + describe(validate_plan(actions, initial, broken, goal)))
    unknown = ("build", "deploy")
    print("未知动作: " + describe(validate_plan(actions, initial, unknown, goal)))

运行:

cd private/labs/agp-lab
python3 -m agp_lab.htn_plan

输出:

HTN 分解: build -> test -> deploy_staging -> verify -> promote
完整计划: valid=True executed=5
漏测计划: valid=False failure=precondition step=2 missing=tests_passed
未知动作: valid=False failure=unknown_action step=2 missing=deploy

这三行各说一件事。

分解是递归展开的结果。 release 方法拆成 prepare, ship;prepare 拆成 build, test;ship 前置要求 tests_passed,拆成 deploy_staging, verify, promote。最终是一个五步的原始动作序列。这里注意:ship 方法的前置 tests_passed 不是动作,而是状态事实——它必须由前面的 test 动作产生,这也让"漏测计划"必然失效。

漏测被精确归因。 去掉 test 后,校验在第 2 步失败:deploy_staging 的前置 tests_passed 不在状态里。输出直接给出 step=2, missing=tests_passed。这不是"计划不完整"这种模糊提示,而是可执行的修复指令:补上能产生 tests_passed 的动作。

未知动作是结构错误。 deploy 不在动作表里,校验器在它出现的那一步失败,报告 unknown_action。这类错误说明"模型生成了超出动作空间的动作",归因到模型还是工具注册表,比归因到逻辑更准确。

计划校验器的职责

一个合格的计划校验器做四件事,按顺序:

  1. 结构检查:每个动作都在动作表里;
  2. 顺序检查:逐个施加效果,前置不满足即失败;
  3. 目标检查:执行完所有动作后,目标事实是否齐备;
  4. 报告可读:失败时给出步骤号与缺失事实。

第 3 条容易被忽略:一个计划可以每一步都合法(前置都满足),但执行完没达到目标——比如漏了产生某个目标事实的动作。校验器必须检查最终状态,而不是只检查每步合法。

边界与失败模式

HTN/PDDL 表示有四个已知边界:

边界表现应对
状态必须是有限事实集合现实状态是连续的、带数值的用抽象事实近似,或显式声明忽略维度
效果是确定性的工具结果带噪声、可能失败校验基于假设,执行期仍需重试与确认
前置条件要人工或自动提炼模型自己声明的前置可能漏用证据回查:前置必须由前置动作产生
方法选择是贪婪的第一个可用方法不一定最优校验通过 ≠ 最优,仍需要评估质量

第一个边界最根本:PDDL 模型把状态建模成事实集合,现实世界往往是数值的、连续的。这不是缺陷,而是约定——你必须声明模型里没建模的维度是允许变化的,否则校验通过的"安全"是虚假的。对 W3 运维处置来说,把"服务健康"抽象成布尔事实没问题,但校验通过只代表"在模型假设下可执行",不代表真实服务无风险。

架构含义

计划表示对架构有三个直接约束:

  1. 动作模型与执行器共享契约。 动作的名字、前置、效果是执行器的唯一依据;模型输出与契约不符就在规划层拒绝。
  2. 分解与校验分离。 分解可能失败(没有可用方法),校验可能失败(前置不满足);两种失败要分开处理。
  3. 失败报告结构化。 步骤号 + 缺失事实 + 失败类型,要让重规划器能直接消费,而不是人类再翻译一遍。

第 3 条直接连到下一节的"重规划":漏测的修复指令是"补一个产生 tests_passed 的动作",这本身就是一次小规模重规划。

架构判据

判据合格的样子不合格的样子
动作有模型前置/效果显式声明动作只有名字和说明
校验全链结构 + 顺序 + 目标只查每步是否在表里
失败可归因步骤号 + 缺失事实一句"计划不合法"
分解可解释复合任务有方法展开分解结果是黑盒
状态有约定未建模维度显式声明假设状态即现实

“状态有约定"是最容易被突破的一条。计划校验通过给的是"在模型假设下成立"的保证,把模型假设误当成现实保证,是规划类系统最常见的信任错误。

小结

  • HTN 管分解,PDDL 风格的动作模型管执行;两者合起来才可验证。
  • 前置条件让失败可预测、顺序强制:缺哪个事实在计划早期就能报告。
  • 校验器要做结构、顺序、目标三层检查,不只是"动作都在表里”。
  • 未知动作是结构错误,漏前置是逻辑错误,两种归因不同。
  • 校验通过 ≠ 现实安全:状态模型没建模的维度必须显式声明忽略。
  • 失败报告要结构化,让重规划器直接消费,而不是人工翻译。

阅读导航:上一节:4.1 任务分解:DAG、偏序与依赖 · 下一节:4.3 重规划:局部修复 vs 全盘重来 。

常见错误与边界

  1. 只分解不校验。 没有动作模型和前置检查,“看起来合理"的计划照样执行失败。
  2. 只查动作在表里。 每步合法但目标没达成,校验器必须检查最终状态。
  3. 前置凭空出现。 前置事实必须能由前置动作产生,否则校验结果不可信。
  4. 把校验当现实保证。 未建模维度必须声明忽略;校验通过不等于无风险。
  5. 失败只报"不合法”。 没有步骤号和缺失事实,重规划无从下手。
  6. 分解与校验混在一起。 没有可用方法与前置不满足是两种失败,要分开处理。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图