《AI Agent 技术原理与架构·决策、记忆与学习》1.3 LLM 作为策略:提示是历史的有损压缩

提示不是历史的副本,而是有损压缩。本节把压缩损失分成事实、不确定性与时间三类,用十项任务历史比较四种压缩策略的关键约束保留率与字符代价,说明为什么“只留事实”或“只留最近”都会丢掉决策所必需的约束,并给出以“决策所需约束是否保住”为准的提示组装判据。

以下实验参数与保留率均为教学示例,不构成对任何真实模型或产品的承诺。十项任务历史、四项限制和四种压缩策略只用于演示损失类型与度量方式。

上一节讲轨迹:一次运行留下了观测、动作、奖励和停止原因。这一节把视角切到策略本身:下一轮动作是怎么从这条轨迹里选出来的?

在 POMDP 里,最优策略的输入是信念状态,而信念是完整历史的充分统计量。LLM 没有显式的信念状态,它看到的是一个提示。提示由历史拼接、截断、摘要或检索而来,因此:

$$
p_t = \operatorname{compress}(h_t), \qquad \pi(a \mid p_t) \approx \pi(a \mid h_t)
$$

右边是理想,左边是现实。提示不是历史的副本,而是历史的有损压缩。 这个认识决定了上下文工程的目标:不是把更多文本塞进窗口,而是让压缩后的提示保留决策所必需的约束。

从历史到提示

把历史压成提示,至少经过四道工序:

工序常见做法可能引入的损失
选择只保留最近 $k$ 轮、只保留工具结果早期约束被丢掉
摘要用模型把长对话写成几句话细节被概括、不确定性被抹平
截断超过窗口就删除中段关键证据恰好落在被删区间
排序按时间或相关性排列位置偏差让模型忽略中间内容

这四道工序都不是中性的。选择会引入近因偏差,摘要会引入二次生成误差,截断会引入位置依赖,排序会改变模型的注意力分配。把它们当成“格式化”,就会低估提示组装的工程责任。

三类损失

压缩损失可以分成三类。这个分类比“丢了多少 token”更有用,因为它直接对应失败模式:

类别丢的是什么典型例子失败后果
事实已确认的约束、字段、结论“退款不含运费”被摘要省略Agent 执行了错误规则
不确定性哪些结论是猜的、哪些是查到的“疑似缓存问题”被写成“缓存问题”Agent 把假设当事实继续行动
时间哪条信息更新、哪条已经过期旧的部署版本号被保留Agent 基于过期状态决策

三类损失里,事实损失最容易被发现,因为它通常导致明显的错误动作;不确定性损失最隐蔽,因为压缩后的提示读起来更“干净”,模型也更自信;时间损失最难排查,因为同一条信息在不同时间点含义不同,而提示里往往没有时间戳。

一个反直觉的结论是:摘要不总是比截断好。 摘要会重写内容,可能把“不确定”改写成“确定”,把“条件成立”改写成“无条件”;截断至少保留了原文,只是少了部分内容。选择哪种压缩,要看任务更怕“信息被改写”还是更怕“信息缺失”。

四种压缩策略

实验比较四种策略,配额都设为 4 项:

策略规则优点风险
keep-all全部保留,忽略配额无损窗口放不下,成本高
recent-first按时间从新到旧取前 4 项简单、近因相关早期关键约束全丢
facts-only只保留事实类,取前 4 项事实密度高不确定性与时间信息全丢
pinned-critical先保留全部关键项,再补最近项关键约束优先依赖关键标记的准确性

pinned-critical 不是“最优策略”,它只是把“关键约束”显式化。如果上游把所有内容都标成关键,它就退化成 keep-all;如果标记本身有噪声,它也会保留错误内容。策略的价值在于让取舍可见,而不是消除取舍。

最小实验:关键约束保留率

实验用一个十项的任务历史,模拟代码修复会话中的约束:仓库名、失败测试、疑似原因、截止时间、运行环境、干扰假设、部署版本、网络限制、负责人、偶发猜测。其中 4 项标为关键。

评价指标有三个:

  • 关键保留率:4 项关键约束中保留了几项;
  • 字符比例:压缩后字符数占原始字符数的比例;
  • 分类保留率:事实、不确定性、时间三类各自保留的比例。
# file: agp_lab/prompt_compression.py | write
# tier: 3
# verify: python3 -m unittest tests.test_prompt_compression
"""提示压缩:把历史压成提示时,哪些约束会丢。

提示是历史的有损压缩。压缩损失可以分成三类:事实(用户与工具确认过的
内容)、不确定性(哪些结论只是猜测)、时间(哪条信息已经过期)。本模块
用固定的十项任务历史比较四种压缩策略,观察关键约束保留率与压缩代价。
"""
from __future__ import annotations

from dataclasses import dataclass

FACT = "fact"
UNCERTAINTY = "uncertainty"
TIME = "time"
KINDS = (FACT, UNCERTAINTY, TIME)


@dataclass(frozen=True)
class Item:
    key: str
    text: str
    kind: str
    critical: bool
    age: int


HISTORY = (
    Item("repo", "仓库 checkout-service", FACT, True, 9),
    Item("test", "失败测试 test_refund_total", FACT, True, 8),
    Item("cause", "疑似金额四舍五入,未证实", UNCERTAINTY, True, 7),
    Item("deadline", "分支 18:00 冻结", TIME, True, 6),
    Item("python", "运行 Python 3.11", FACT, False, 5),
    Item("cache", "缓存可能是干扰项", UNCERTAINTY, False, 4),
    Item("deploy", "故障在 deploy-42 后出现", TIME, False, 3),
    Item("offline", "本机无外网", FACT, False, 2),
    Item("owner", "负责人 alice", FACT, False, 1),
    Item("flaky", "不确定是否偶发", UNCERTAINTY, False, 0),
)

STRATEGIES = ("keep-all", "recent-first", "facts-only", "pinned-critical")


def _check_limit(limit: int) -> None:
    if limit < 0:
        raise ValueError("limit 不能为负")


def keep_all(history: tuple[Item, ...], limit: int) -> tuple[Item, ...]:
    _check_limit(limit)
    return history


def recent_first(history: tuple[Item, ...], limit: int) -> tuple[Item, ...]:
    _check_limit(limit)
    ordered = sorted(history, key=lambda item: item.age)
    return tuple(ordered[:limit])


def facts_only(history: tuple[Item, ...], limit: int) -> tuple[Item, ...]:
    _check_limit(limit)
    facts = tuple(item for item in history if item.kind == FACT)
    return facts[:limit]


def pinned_critical(history: tuple[Item, ...], limit: int) -> tuple[Item, ...]:
    """先保留全部关键项,再按时间从新到旧补足剩余配额。"""
    _check_limit(limit)
    critical = tuple(item for item in history if item.critical)
    rest = tuple(item for item in sorted(history, key=lambda item: item.age) if not item.critical)
    return (critical + rest)[:limit]


STRATEGY_FUNCS = {
    "keep-all": keep_all,
    "recent-first": recent_first,
    "facts-only": facts_only,
    "pinned-critical": pinned_critical,
}


def chars(items: tuple[Item, ...]) -> int:
    return sum(len(item.key) + len(item.text) for item in items)


def retained_critical(selected: tuple[Item, ...], history: tuple[Item, ...]) -> tuple[Item, ...]:
    kept = {item.key for item in selected}
    return tuple(item for item in history if item.critical and item.key in kept)


def lost_critical(selected: tuple[Item, ...], history: tuple[Item, ...]) -> tuple[Item, ...]:
    kept = {item.key for item in selected}
    return tuple(item for item in history if item.critical and item.key not in kept)


def kind_retention(selected: tuple[Item, ...], history: tuple[Item, ...], kind: str) -> float:
    if kind not in KINDS:
        raise ValueError(f"未知类别: {kind}")
    total = [item for item in history if item.kind == kind]
    if not total:
        return 1.0
    kept = {item.key for item in selected}
    return sum(1 for item in total if item.key in kept) / len(total)


@dataclass(frozen=True)
class Row:
    strategy: str
    kept: int
    chars: int
    ratio: float
    critical_kept: int
    critical_total: int
    lost: tuple[str, ...]
    fact_retention: float
    uncertainty_retention: float
    time_retention: float


def compare(
    history: tuple[Item, ...] = HISTORY,
    limit: int = 4,
    strategies: tuple[str, ...] = STRATEGIES,
) -> list[Row]:
    total_chars = chars(history)
    critical_total = sum(1 for item in history if item.critical)
    rows: list[Row] = []
    for name in strategies:
        selected = STRATEGY_FUNCS[name](history, limit)
        kept_critical = retained_critical(selected, history)
        rows.append(
            Row(
                strategy=name,
                kept=len(selected),
                chars=chars(selected),
                ratio=chars(selected) / total_chars,
                critical_kept=len(kept_critical),
                critical_total=critical_total,
                lost=tuple(item.key for item in lost_critical(selected, history)),
                fact_retention=kind_retention(selected, history, FACT),
                uncertainty_retention=kind_retention(selected, history, UNCERTAINTY),
                time_retention=kind_retention(selected, history, TIME),
            )
        )
    return rows


if __name__ == "__main__":
    print(f"{'strategy':<16}{'kept':>5}{'chars':>7}{'ratio':>7}{'crit':>7}  lost")
    for row in compare():
        lost = ",".join(row.lost) if row.lost else "-"
        print(
            f"{row.strategy:<16}{row.kept:>5}{row.chars:>7}{row.ratio:>7.2f}"
            f"{row.critical_kept:>3}/{row.critical_total:<3}  {lost}"
        )
    print("kind retention (fact/uncertainty/time):")
    for row in compare():
        print(
            f"{row.strategy:<16}{row.fact_retention:>5.2f}"
            f"{row.uncertainty_retention:>6.2f}{row.time_retention:>6.2f}"
        )

运行:

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

输出:

strategy         kept  chars  ratio   crit  lost
keep-all           10    179   1.00  4/4    -
recent-first        4     61   0.34  0/4    repo,test,cause,deadline
facts-only          4     81   0.45  2/4    cause,deadline
pinned-critical     4     85   0.47  4/4    -
kind retention (fact/uncertainty/time):
keep-all         1.00  1.00  1.00
recent-first     0.40  0.33  0.50
facts-only       0.80  0.00  0.00
pinned-critical  0.40  0.33  0.50

recent-first 把字符压到 34%,但 4 项关键约束全部丢失。它保留的是最近的干扰假设、负责人、网络限制和部署版本,恰好都不是决策必需的约束。这是近因偏差的典型形态:压缩率很好看,任务却做不对。

facts-only 保住了仓库名和失败测试两项关键事实,但丢掉了“疑似原因”和“截止时间”。分类保留率显示不确定性为 0、时间为 0:这不是小问题,因为前者决定 Agent 该不该继续验证,后者决定它有没有时间做完整修复。

pinned-critical 用 47% 的字符保住了 4/4 关键约束,代价是事实类的总体保留率只有 40%。这说明它压缩的是“非关键事实”,而不是“所有事实”。如果任务需要完整的事实清单,这个策略仍然不够;它只保证关键约束不丢。

一个容易误读的地方是 keep-all 的 1.00。字符比例 100% 意味着没有压缩,在短历史里可行,在长会话里不可行。压缩策略的比较必须同时看保留率和成本,单看任何一个都会得出片面结论。

边界与失败模式

提示压缩的失败通常不在算法,而在标记和评价:

  1. 关键标记通胀。 所有内容都被标成关键,压缩退化为不压缩,窗口很快耗尽。
  2. 关键标记缺失。 真正重要的约束没有标记,任何策略都保不住它。
  3. 摘要改写语义。 “疑似”被写成“确认”,“仅在测试环境”被省略,模型据此做出过度承诺。
  4. 时间信息丢失。 旧版本号、旧截止时间、旧负责人被保留,模型无法判断哪条最新。
  5. 只优化 token 数。 压缩率上去了,关键保留率下降,任务成功率反而变差。
  6. 评价集覆盖不足。 只用简单问题评估压缩策略,发现不了长尾约束的丢失。

这些失败模式的共同点是:它们在离线指标上不一定可见。字符数、压缩率、甚至平均任务成功率都可能正常,只有按约束类型拆分后,才能看到某类信息被系统性丢弃。

架构含义

把提示当压缩,会推出五个架构要求:

  • 约束注册表。 把用户约束、工具事实、时间窗口、未决问题写成结构化条目,而不是散落在对话里。
  • 压缩策略可版本化。 选择了哪种选择、摘要、截断和排序规则,要随轨迹一起记录,否则无法解释行为变化。
  • 不确定性与时间是一等字段。 每条事实带来源、置信和时间;摘要不能把它们压掉。
  • 按约束类型评估。 评测集要分别覆盖事实、不确定性和时间三类损失,而不是只看总分。
  • 提示组装与对话历史分离。 对话是证据,提示是按策略组装的工作集;两者不应混为一谈。

第五条最关键。很多系统把“聊天记录”直接当提示,于是压缩策略隐含在截断逻辑里,既不可见也不可测试。把提示组装拆成独立组件,才能对压缩做实验、做回归、做灰度。

架构判据

判据合格的样子不合格的样子
约束结构化约束有类型、来源、时间约束只存在于对话文本
关键标记可审计标记规则与责任人明确所有内容都标关键
压缩可解释记录用了哪种策略只知截断到多少 token
损失可度量按事实/不确定性/时间评估只看压缩率
信息可追溯摘要能回到原文摘要替代原文且不可查
时间可判断每条信息带时间戳新旧信息混在一起

这六条里,“损失可度量”决定压缩是否能持续改进。没有分类指标,团队只能凭感觉调窗口和摘要长度;有了分类指标,才能判断某次改动是保住了关键约束,还是只是把提示变短了。

小结

  • LLM 作为策略,输入是提示;提示是历史的有损压缩,不是历史副本。
  • 压缩损失分三类:事实、不确定性、时间;三类对应不同的失败模式。
  • 摘要不一定优于截断:摘要把内容改写,截断只是让内容缺失。
  • recent-first 压缩率高但会丢早期关键约束;facts-only 会丢不确定性与时间信息。
  • pinned-critical 用关键标记换取保留率,前提是标记准确且不通胀。
  • 压缩策略要版本化、可解释,并按约束类型评估,而不是只优化 token 数。

阅读导航:上一节:1.2 策略、Rollout 与轨迹 · 下一节:2.1 循环、步数与停止条件 。

常见错误与边界

  1. 把提示当历史副本。 提示经过选择、摘要、截断和排序,每一道工序都可能丢信息。
  2. 只优化压缩率。 字符数下降不代表任务变好,关键约束丢失会让成功率下降。
  3. 把所有内容标成关键。 标记通胀会让优先级失效,压缩退化为不压缩。
  4. 让摘要抹平不确定性。 “疑似”被改写成“确认”,模型会把假设当事实。
  5. 忽略时间戳。 新旧信息混在一起,模型无法判断哪条仍然有效。
  6. 用一套平均指标评估。 不按事实、不确定性、时间拆分,就看不出系统性损失。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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