以下数字为教学示例,不构成对任何真实系统或供应商的承诺。
上一节的 DAG 描述了"谁依赖谁",这一节描述计划本身:一个计划是什么、怎么表示、怎么验证。计划的价值不在于"看起来合理",而在于能执行、能校验、失败能归因。HTN(层次任务网络)负责"怎么把大任务拆成原始动作",PDDL 风格的动作模型负责"这串动作在给定状态下是否合法"。
两个表示是互补的:HTN 管分解,动作模型管执行。合起来,才能回答"这个计划能不能做、缺什么、在第几步失败"。
两种计划表示的分工
| 表示 | 管什么 | 输出 | 验证什么 |
|---|---|---|---|
| HTN 分解 | 复合任务 → 原始动作 | 动作序列 | 每一步前置条件 |
| PDDL 动作模型 | 动作的前置/效果 | 状态转移 | 前提满足、目标达成 |
HTN 的方法(method)把一个复合任务展开成一组子任务,子任务还能再展开,直到全部成为原始动作。PDDL 风格的动作则声明三样东西:前置条件 pre、添加效果 add、删除效果 delete。展开过程中,前面子任务的效果会累积进状态,因此后面方法的前置条件看到的是"执行到当前位置的状态",而不是初始状态。
前置条件是计划安全的关键
动作模型里最重要的概念是前置条件。一个动作只有在当前状态包含其全部前置条件时才能执行;不满足就在执行前失败,而不是执行到一半才发现。
前置条件带来两个直接收益:
- 失败可预测:校验器能报告"第几步缺哪个事实",而不是执行器遇到运行时错误;
- 顺序强制:计划中动作的先后必须符合状态累积的规律,不能把"需要测试通过"的动作放在测试之前。
实验里的 deploy_staging 前置条件是 artifact_built, tests_passed, staging_ready 三个事实。缺一个,校验器就能在计划的早期报告,而不是等到部署阶段才暴露。
最小实验:发布流程
下面的实验定义了一个发布流程的动作模型与 HTN 方法,然后做三次校验:
- 完整计划:正常分解并执行;
- 漏测计划:把
test从计划里去掉,看校验器能否发现; - 未知动作:计划里出现一个不存在的动作
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。这类错误说明"模型生成了超出动作空间的动作",归因到模型还是工具注册表,比归因到逻辑更准确。
计划校验器的职责
一个合格的计划校验器做四件事,按顺序:
- 结构检查:每个动作都在动作表里;
- 顺序检查:逐个施加效果,前置不满足即失败;
- 目标检查:执行完所有动作后,目标事实是否齐备;
- 报告可读:失败时给出步骤号与缺失事实。
第 3 条容易被忽略:一个计划可以每一步都合法(前置都满足),但执行完没达到目标——比如漏了产生某个目标事实的动作。校验器必须检查最终状态,而不是只检查每步合法。
边界与失败模式
HTN/PDDL 表示有四个已知边界:
| 边界 | 表现 | 应对 |
|---|---|---|
| 状态必须是有限事实集合 | 现实状态是连续的、带数值的 | 用抽象事实近似,或显式声明忽略维度 |
| 效果是确定性的 | 工具结果带噪声、可能失败 | 校验基于假设,执行期仍需重试与确认 |
| 前置条件要人工或自动提炼 | 模型自己声明的前置可能漏 | 用证据回查:前置必须由前置动作产生 |
| 方法选择是贪婪的 | 第一个可用方法不一定最优 | 校验通过 ≠ 最优,仍需要评估质量 |
第一个边界最根本:PDDL 模型把状态建模成事实集合,现实世界往往是数值的、连续的。这不是缺陷,而是约定——你必须声明模型里没建模的维度是允许变化的,否则校验通过的"安全"是虚假的。对 W3 运维处置来说,把"服务健康"抽象成布尔事实没问题,但校验通过只代表"在模型假设下可执行",不代表真实服务无风险。
架构含义
计划表示对架构有三个直接约束:
- 动作模型与执行器共享契约。 动作的名字、前置、效果是执行器的唯一依据;模型输出与契约不符就在规划层拒绝。
- 分解与校验分离。 分解可能失败(没有可用方法),校验可能失败(前置不满足);两种失败要分开处理。
- 失败报告结构化。 步骤号 + 缺失事实 + 失败类型,要让重规划器能直接消费,而不是人类再翻译一遍。
第 3 条直接连到下一节的"重规划":漏测的修复指令是"补一个产生 tests_passed 的动作",这本身就是一次小规模重规划。
架构判据
| 判据 | 合格的样子 | 不合格的样子 |
|---|---|---|
| 动作有模型 | 前置/效果显式声明 | 动作只有名字和说明 |
| 校验全链 | 结构 + 顺序 + 目标 | 只查每步是否在表里 |
| 失败可归因 | 步骤号 + 缺失事实 | 一句"计划不合法" |
| 分解可解释 | 复合任务有方法展开 | 分解结果是黑盒 |
| 状态有约定 | 未建模维度显式声明 | 假设状态即现实 |
“状态有约定"是最容易被突破的一条。计划校验通过给的是"在模型假设下成立"的保证,把模型假设误当成现实保证,是规划类系统最常见的信任错误。
小结
- HTN 管分解,PDDL 风格的动作模型管执行;两者合起来才可验证。
- 前置条件让失败可预测、顺序强制:缺哪个事实在计划早期就能报告。
- 校验器要做结构、顺序、目标三层检查,不只是"动作都在表里”。
- 未知动作是结构错误,漏前置是逻辑错误,两种归因不同。
- 校验通过 ≠ 现实安全:状态模型没建模的维度必须显式声明忽略。
- 失败报告要结构化,让重规划器直接消费,而不是人工翻译。
阅读导航:上一节:4.1 任务分解:DAG、偏序与依赖 · 下一节:4.3 重规划:局部修复 vs 全盘重来 。
常见错误与边界
- 只分解不校验。 没有动作模型和前置检查,“看起来合理"的计划照样执行失败。
- 只查动作在表里。 每步合法但目标没达成,校验器必须检查最终状态。
- 前置凭空出现。 前置事实必须能由前置动作产生,否则校验结果不可信。
- 把校验当现实保证。 未建模维度必须声明忽略;校验通过不等于无风险。
- 失败只报"不合法”。 没有步骤号和缺失事实,重规划无从下手。
- 分解与校验混在一起。 没有可用方法与前置不满足是两种失败,要分开处理。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。